@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Misc/assetsManager.d.ts

@@ -0,0 +1,406 @@
+/**
+ * Defines the list of states available for a task inside a AssetsManager
+ */
+export const AssetTaskState: any;
+/**
+ * Define an abstract asset task used with a AssetsManager class to load assets into a scene
+ */
+export class AbstractAssetTask {
+    /**
+     * Creates a new AssetsManager
+     * @param name defines the name of the task
+     */
+    constructor(name: any);
+    name: any;
+    _isCompleted: boolean;
+    _taskState: any;
+    /**
+     * Get if the task is completed
+     */
+    get isCompleted(): boolean;
+    /**
+     * Gets the current state of the task
+     */
+    get taskState(): any;
+    /**
+     * Gets the current error object (if task is in error)
+     */
+    get errorObject(): {
+        message: any;
+        exception: any;
+    } | {
+        message: any;
+        exception: any;
+    } | undefined;
+    /**
+     * Internal only
+     * @internal
+     */
+    _setErrorObject(message: any, exception: any): void;
+    _errorObject: {
+        message: any;
+        exception: any;
+    } | {
+        message: any;
+        exception: any;
+    } | undefined;
+    /**
+     * Execute the current task
+     * @param scene defines the scene where you want your assets to be loaded
+     * @param onSuccess is a callback called when the task is successfully executed
+     * @param onError is a callback called if an error occurs
+     */
+    run(scene: any, onSuccess: any, onError: any): void;
+    /**
+     * Execute the current task
+     * @param scene defines the scene where you want your assets to be loaded
+     * @param onSuccess is a callback called when the task is successfully executed
+     * @param onError is a callback called if an error occurs
+     */
+    runTask(scene: any, onSuccess: any, onError: any): void;
+    /**
+     * Reset will set the task state back to INIT, so the next load call of the assets manager will execute this task again.
+     * This can be used with failed tasks that have the reason for failure fixed.
+     */
+    reset(): void;
+    _onErrorCallback(onError: any, message: any, exception: any): void;
+    _onDoneCallback(onSuccess: any, onError: any): void;
+}
+/**
+ * Class used to share progress information about assets loading
+ */
+export class AssetsProgressEvent {
+    /**
+     * Creates a AssetsProgressEvent
+     * @param remainingCount defines the number of remaining tasks to process
+     * @param totalCount defines the total number of tasks
+     * @param task defines the task that was just processed
+     */
+    constructor(remainingCount: any, totalCount: any, task: any);
+    remainingCount: any;
+    totalCount: any;
+    task: any;
+}
+/**
+ * Define a task used by AssetsManager to load assets into a container
+ */
+export class ContainerAssetTask extends AbstractAssetTask {
+    /**
+     * Creates a new ContainerAssetTask
+     * @param name defines the name of the task
+     * @param meshesNames defines the list of mesh's names you want to load
+     * @param rootUrl defines the root url to use as a base to load your meshes and associated resources
+     * @param sceneFilename defines the filename or File of the scene to load from
+     */
+    constructor(name: any, meshesNames: any, rootUrl: any, sceneFilename: any);
+    meshesNames: any;
+    rootUrl: any;
+    sceneFilename: any;
+    loadedContainer: import("@babylonjs/core").AssetContainer | undefined;
+    loadedMeshes: import("@babylonjs/core").AbstractMesh[] | undefined;
+    loadedTransformNodes: import("@babylonjs/core").TransformNode[] | undefined;
+    loadedParticleSystems: import("@babylonjs/core").IParticleSystem[] | undefined;
+    loadedSkeletons: import("@babylonjs/core").Skeleton[] | undefined;
+    loadedAnimationGroups: import("@babylonjs/core").AnimationGroup[] | undefined;
+}
+/**
+ * Define a task used by AssetsManager to load meshes
+ */
+export class MeshAssetTask extends AbstractAssetTask {
+    /**
+     * Creates a new MeshAssetTask
+     * @param name defines the name of the task
+     * @param meshesNames defines the list of mesh's names you want to load
+     * @param rootUrl defines the root url to use as a base to load your meshes and associated resources
+     * @param sceneFilename defines the filename or File of the scene to load from
+     */
+    constructor(name: any, meshesNames: any, rootUrl: any, sceneFilename: any);
+    meshesNames: any;
+    rootUrl: any;
+    sceneFilename: any;
+    loadedMeshes: import("@babylonjs/core").AbstractMesh[] | undefined;
+    loadedTransformNodes: import("@babylonjs/core").TransformNode[] | undefined;
+    loadedParticleSystems: import("@babylonjs/core").IParticleSystem[] | undefined;
+    loadedSkeletons: import("@babylonjs/core").Skeleton[] | undefined;
+    loadedAnimationGroups: import("@babylonjs/core").AnimationGroup[] | undefined;
+}
+/**
+ * Define a task used by AssetsManager to load text content
+ */
+export class TextFileAssetTask extends AbstractAssetTask {
+    /**
+     * Creates a new TextFileAssetTask object
+     * @param name defines the name of the task
+     * @param url defines the location of the file to load
+     */
+    constructor(name: any, url: any);
+    url: any;
+    text: any;
+}
+/**
+ * Define a task used by AssetsManager to load binary data
+ */
+export class BinaryFileAssetTask extends AbstractAssetTask {
+    /**
+     * Creates a new BinaryFileAssetTask object
+     * @param name defines the name of the new task
+     * @param url defines the location of the file to load
+     */
+    constructor(name: any, url: any);
+    url: any;
+    data: any;
+}
+/**
+ * Define a task used by AssetsManager to load images
+ */
+export class ImageAssetTask extends AbstractAssetTask {
+    /**
+     * Creates a new ImageAssetTask
+     * @param name defines the name of the task
+     * @param url defines the location of the image to load
+     */
+    constructor(name: any, url: any);
+    url: any;
+    image: HTMLImageElement | undefined;
+}
+/**
+ * Define a task used by AssetsManager to load 2D textures
+ */
+export class TextureAssetTask extends AbstractAssetTask {
+    /**
+     * Creates a new TextureAssetTask object
+     * @param name defines the name of the task
+     * @param url defines the location of the file to load
+     * @param noMipmap defines if mipmap should not be generated (default is false)
+     * @param invertY defines if texture must be inverted on Y axis (default is true)
+     * @param samplingMode defines the sampling mode to use (default is Texture.TRILINEAR_SAMPLINGMODE)
+     */
+    constructor(name: any, url: any, noMipmap: any, invertY?: boolean, samplingMode?: number);
+    url: any;
+    noMipmap: any;
+    invertY: boolean;
+    samplingMode: number;
+    texture: Texture | undefined;
+}
+/**
+ * Define a task used by AssetsManager to load cube textures
+ */
+export class CubeTextureAssetTask extends AbstractAssetTask {
+    /**
+     * Creates a new CubeTextureAssetTask
+     * @param name defines the name of the task
+     * @param url defines the location of the files to load (You have to specify the folder where the files are + filename with no extension)
+     * @param extensions defines the extensions to use to load files (["_px", "_py", "_pz", "_nx", "_ny", "_nz"] by default)
+     * @param noMipmap defines if mipmaps should not be generated (default is false)
+     * @param files defines the explicit list of files (undefined by default)
+     * @param prefiltered
+     */
+    constructor(name: any, url: any, extensions: any, noMipmap: any, files: any, prefiltered: any);
+    url: any;
+    extensions: any;
+    noMipmap: any;
+    files: any;
+    prefiltered: any;
+    texture: CubeTexture | undefined;
+}
+/**
+ * Define a task used by AssetsManager to load HDR cube textures
+ */
+export class HDRCubeTextureAssetTask extends AbstractAssetTask {
+    /**
+     * Creates a new HDRCubeTextureAssetTask object
+     * @param name defines the name of the task
+     * @param url defines the location of the file to load
+     * @param size defines the desired size (the more it increases the longer the generation will be) If the size is omitted this implies you are using a preprocessed cubemap.
+     * @param noMipmap defines if mipmaps should not be generated (default is false)
+     * @param generateHarmonics specifies whether you want to extract the polynomial harmonics during the generation process (default is true)
+     * @param gammaSpace specifies if the texture will be use in gamma or linear space (the PBR material requires those texture in linear space, but the standard material would require them in Gamma space) (default is false)
+     * @param reserved Internal use only
+     */
+    constructor(name: any, url: any, size: any, noMipmap?: boolean, generateHarmonics?: boolean, gammaSpace?: boolean, reserved?: boolean);
+    url: any;
+    size: any;
+    noMipmap: boolean;
+    generateHarmonics: boolean;
+    gammaSpace: boolean;
+    reserved: boolean;
+    texture: HDRCubeTexture | undefined;
+}
+/**
+ * Define a task used by AssetsManager to load Equirectangular cube textures
+ */
+export class EquiRectangularCubeTextureAssetTask extends AbstractAssetTask {
+    /**
+     * Creates a new EquiRectangularCubeTextureAssetTask object
+     * @param name defines the name of the task
+     * @param url defines the location of the file to load
+     * @param size defines the desired size (the more it increases the longer the generation will be)
+     * If the size is omitted this implies you are using a preprocessed cubemap.
+     * @param noMipmap defines if mipmaps should not be generated (default is false)
+     * @param gammaSpace specifies if the texture will be used in gamma or linear space
+     * (the PBR material requires those texture in linear space, but the standard material would require them in Gamma space)
+     * (default is true)
+     */
+    constructor(name: any, url: any, size: any, noMipmap?: boolean, gammaSpace?: boolean);
+    url: any;
+    size: any;
+    noMipmap: boolean;
+    gammaSpace: boolean;
+    texture: EquiRectangularCubeTexture | undefined;
+}
+/**
+ * This class can be used to easily import assets into a scene
+ * @see https://doc.babylonjs.com/how_to/how_to_use_assetsmanager
+ */
+export class AssetsManager {
+    /**
+     * Creates a new AssetsManager
+     * @param scene defines the scene to work on
+     */
+    constructor(scene: any);
+    _isLoading: boolean;
+    _tasks: any[];
+    _waitingTasksCount: number;
+    _totalTasksCount: number;
+    /**
+     * Observable called when all tasks are processed
+     */
+    onTaskSuccessObservable: Observable<any>;
+    /**
+     * Observable called when a task had an error
+     */
+    onTaskErrorObservable: Observable<any>;
+    /**
+     * Observable called when all tasks were executed
+     */
+    onTasksDoneObservable: Observable<any>;
+    /**
+     * Observable called when a task is done (whatever the result is)
+     */
+    onProgressObservable: Observable<any>;
+    /**
+     * Gets or sets a boolean defining if the AssetsManager should use the default loading screen
+     * @see https://doc.babylonjs.com/how_to/creating_a_custom_loading_screen
+     */
+    useDefaultLoadingScreen: boolean;
+    /**
+     * Gets or sets a boolean defining if the AssetsManager should automatically hide the loading screen
+     * when all assets have been downloaded.
+     * If set to false, you need to manually call in hideLoadingUI() once your scene is ready.
+     */
+    autoHideLoadingUI: boolean;
+    _scene: any;
+    /**
+     * Add a ContainerAssetTask to the list of active tasks
+     * @param taskName defines the name of the new task
+     * @param meshesNames defines the name of meshes to load
+     * @param rootUrl defines the root url to use to locate files
+     * @param sceneFilename defines the filename of the scene file or the File itself
+     * @returns a new ContainerAssetTask object
+     */
+    addContainerTask(taskName: any, meshesNames: any, rootUrl: any, sceneFilename: any): ContainerAssetTask;
+    /**
+     * Add a MeshAssetTask to the list of active tasks
+     * @param taskName defines the name of the new task
+     * @param meshesNames defines the name of meshes to load
+     * @param rootUrl defines the root url to use to locate files
+     * @param sceneFilename defines the filename of the scene file or the File itself
+     * @returns a new MeshAssetTask object
+     */
+    addMeshTask(taskName: any, meshesNames: any, rootUrl: any, sceneFilename: any): MeshAssetTask;
+    /**
+     * Add a TextFileAssetTask to the list of active tasks
+     * @param taskName defines the name of the new task
+     * @param url defines the url of the file to load
+     * @returns a new TextFileAssetTask object
+     */
+    addTextFileTask(taskName: any, url: any): TextFileAssetTask;
+    /**
+     * Add a BinaryFileAssetTask to the list of active tasks
+     * @param taskName defines the name of the new task
+     * @param url defines the url of the file to load
+     * @returns a new BinaryFileAssetTask object
+     */
+    addBinaryFileTask(taskName: any, url: any): BinaryFileAssetTask;
+    /**
+     * Add a ImageAssetTask to the list of active tasks
+     * @param taskName defines the name of the new task
+     * @param url defines the url of the file to load
+     * @returns a new ImageAssetTask object
+     */
+    addImageTask(taskName: any, url: any): ImageAssetTask;
+    /**
+     * Add a TextureAssetTask to the list of active tasks
+     * @param taskName defines the name of the new task
+     * @param url defines the url of the file to load
+     * @param noMipmap defines if the texture must not receive mipmaps (false by default)
+     * @param invertY defines if you want to invert Y axis of the loaded texture (false by default)
+     * @param samplingMode defines the sampling mode to use (Texture.TRILINEAR_SAMPLINGMODE by default)
+     * @returns a new TextureAssetTask object
+     */
+    addTextureTask(taskName: any, url: any, noMipmap: any, invertY: any, samplingMode?: number): TextureAssetTask;
+    /**
+     * Add a CubeTextureAssetTask to the list of active tasks
+     * @param taskName defines the name of the new task
+     * @param url defines the url of the file to load
+     * @param extensions defines the extension to use to load the cube map (can be null)
+     * @param noMipmap defines if the texture must not receive mipmaps (false by default)
+     * @param files defines the list of files to load (can be null)
+     * @param prefiltered defines the prefiltered texture option (default is false)
+     * @returns a new CubeTextureAssetTask object
+     */
+    addCubeTextureTask(taskName: any, url: any, extensions: any, noMipmap: any, files: any, prefiltered: any): CubeTextureAssetTask;
+    /**
+     *
+     * Add a HDRCubeTextureAssetTask to the list of active tasks
+     * @param taskName defines the name of the new task
+     * @param url defines the url of the file to load
+     * @param size defines the size you want for the cubemap (can be null)
+     * @param noMipmap defines if the texture must not receive mipmaps (false by default)
+     * @param generateHarmonics defines if you want to automatically generate (true by default)
+     * @param gammaSpace specifies if the texture will be use in gamma or linear space (the PBR material requires those texture in linear space, but the standard material would require them in Gamma space) (default is false)
+     * @param reserved Internal use only
+     * @returns a new HDRCubeTextureAssetTask object
+     */
+    addHDRCubeTextureTask(taskName: any, url: any, size: any, noMipmap?: boolean, generateHarmonics?: boolean, gammaSpace?: boolean, reserved?: boolean): HDRCubeTextureAssetTask;
+    /**
+     *
+     * Add a EquiRectangularCubeTextureAssetTask to the list of active tasks
+     * @param taskName defines the name of the new task
+     * @param url defines the url of the file to load
+     * @param size defines the size you want for the cubemap (can be null)
+     * @param noMipmap defines if the texture must not receive mipmaps (false by default)
+     * @param gammaSpace Specifies if the texture will be used in gamma or linear space
+     * (the PBR material requires those textures in linear space, but the standard material would require them in Gamma space)
+     * @returns a new EquiRectangularCubeTextureAssetTask object
+     */
+    addEquiRectangularCubeTextureAssetTask(taskName: any, url: any, size: any, noMipmap?: boolean, gammaSpace?: boolean): EquiRectangularCubeTextureAssetTask;
+    /**
+     * Remove a task from the assets manager.
+     * @param task the task to remove
+     */
+    removeTask(task: any): void;
+    _decreaseWaitingTasksCount(task: any): void;
+    _runTask(task: any): void;
+    _formatTaskErrorMessage(task: any): string;
+    /**
+     * Reset the AssetsManager and remove all tasks
+     * @returns the current instance of the AssetsManager
+     */
+    reset(): AssetsManager;
+    /**
+     * Start the loading process
+     * @returns the current instance of the AssetsManager
+     */
+    load(): AssetsManager;
+    /**
+     * Start the loading process as an async operation
+     * @returns a promise returning the list of failed tasks
+     */
+    loadAsync(): Promise<any>;
+}
+import { Texture } from "../Materials/Textures/texture.js";
+import { CubeTexture } from "../Materials/Textures/cubeTexture.js";
+import { HDRCubeTexture } from "../Materials/Textures/hdrCubeTexture.js";
+import { EquiRectangularCubeTexture } from "../Materials/Textures/equiRectangularCubeTexture.js";
+import { Observable } from "./observable.js";

package/dist/types/node_modules/@babylonjs/core/Misc/basis.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Configuration options for the Basis transcoder
+ */
+export class BasisTranscodeConfiguration {
+}
+export namespace BasisToolsOptions {
+    const JSModuleURL: string;
+    const WasmModuleURL: string;
+}
+export function GetInternalFormatFromBasisFormat(basisFormat: any, engine: any): number;
+export function TranscodeAsync(data: any, config: any): Promise<any>;
+export function LoadTextureFromTranscodeResult(texture: any, transcodeResult: any): void;
+export namespace BasisTools {
+    const JSModuleURL_1: string;
+    export { JSModuleURL_1 as JSModuleURL };
+    const WasmModuleURL_1: string;
+    export { WasmModuleURL_1 as WasmModuleURL };
+}

package/dist/types/node_modules/@babylonjs/core/Misc/brdfTextureTools.d.ts

@@ -0,0 +1,4 @@
+export function GetEnvironmentBRDFTexture(scene: any): any;
+export namespace BRDFTextureTools {
+    export { GetEnvironmentBRDFTexture };
+}

package/dist/types/node_modules/@babylonjs/core/Misc/codeStringParsingTools.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Extracts the characters between two markers (for eg, between "(" and ")"). The function handles nested markers as well as markers inside strings (delimited by ", ' or `) and comments
+ * @param markerOpen opening marker
+ * @param markerClose closing marker
+ * @param block code block to parse
+ * @param startIndex starting index in block where the extraction must start. The character at block[startIndex] should be the markerOpen character!
+ * @returns index of the last character for the extraction (or -1 if the string is invalid - no matching closing marker found). The string to extract (without the markers) is the string between startIndex + 1 and the returned value (exclusive)
+ */
+export function ExtractBetweenMarkers(markerOpen: any, markerClose: any, block: any, startIndex: any): number;
+/**
+ * Parses a string and skip whitespaces
+ * @param s string to parse
+ * @param index index where to start parsing
+ * @returns the index after all whitespaces have been skipped
+ */
+export function SkipWhitespaces(s: any, index: any): any;
+/**
+ * Checks if a character is an identifier character (meaning, if it is 0-9, A-Z, a-z or _)
+ * @param c character to check
+ * @returns true if the character is an identifier character
+ */
+export function IsIdentifierChar(c: any): boolean;
+/**
+ * Removes the comments of a code block
+ * @param block code block to parse
+ * @returns block with the comments removed
+ */
+export function RemoveComments(block: any): string;
+/**
+ * Finds the first occurrence of a character in a string going backward
+ * @param s the string to parse
+ * @param index starting index in the string
+ * @param c the character to find
+ * @returns the index of the character if found, else -1
+ */
+export function FindBackward(s: any, index: any, c: any): any;
+/**
+ * Escapes a string so that it is usable as a regular expression
+ * @param s string to escape
+ * @returns escaped string
+ */
+export function EscapeRegExp(s: any): any;

package/dist/types/node_modules/@babylonjs/core/Misc/computePressure.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A wrapper for the experimental compute pressure api which allows a callback to be called whenever certain thresholds are met.
+ */
+export class ComputePressureObserverWrapper {
+    /**
+     * Returns true if ComputePressureObserver is available for use, false otherwise.
+     */
+    static get IsAvailable(): any;
+    /**
+     * A compute pressure observer will call this callback, whenever these thresholds are met.
+     * @param callback The callback that is called whenever thresholds are met.
+     * @param thresholds An object containing the thresholds used to decide what value to to return for each update property (average of start and end of a threshold boundary).
+     */
+    constructor(callback: any, thresholds: any);
+    _observer: any;
+    /**
+     * Method that must be called to begin observing changes, and triggering callbacks.
+     * @param source defines the source to observe
+     */
+    observe(source: any): void;
+    /**
+     * Method that must be called to stop observing changes and triggering callbacks (cleanup function).
+     * @param source defines the source to unobserve
+     */
+    unobserve(source: any): void;
+}

package/dist/types/node_modules/@babylonjs/core/Misc/copyTools.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Transform some pixel data to a base64 string
+ * @param pixels defines the pixel data to transform to base64
+ * @param size defines the width and height of the (texture) data
+ * @param invertY true if the data must be inverted for the Y coordinate during the conversion
+ * @returns The base64 encoded string or null
+ */
+export function GenerateBase64StringFromPixelData(pixels: any, size: any, invertY?: boolean): string | null;
+/**
+ * Reads the pixels stored in the webgl texture and returns them as a base64 string
+ * @param texture defines the texture to read pixels from
+ * @param faceIndex defines the face of the texture to read (in case of cube texture)
+ * @param level defines the LOD level of the texture to read (in case of Mip Maps)
+ * @returns The base64 encoded string or null
+ */
+export function GenerateBase64StringFromTexture(texture: any, faceIndex?: number, level?: number): string | null;
+/**
+ * Reads the pixels stored in the webgl texture and returns them as a base64 string
+ * @param texture defines the texture to read pixels from
+ * @param faceIndex defines the face of the texture to read (in case of cube texture)
+ * @param level defines the LOD level of the texture to read (in case of Mip Maps)
+ * @returns The base64 encoded string or null wrapped in a promise
+ */
+export function GenerateBase64StringFromTextureAsync(texture: any, faceIndex?: number, level?: number): Promise<string | null>;
+export namespace CopyTools {
+    export { GenerateBase64StringFromPixelData };
+    export { GenerateBase64StringFromTexture };
+    export { GenerateBase64StringFromTextureAsync };
+}

package/dist/types/node_modules/@babylonjs/core/Misc/coroutine.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @internal
+ */
+export function inlineScheduler(coroutine: any, onStep: any, onError: any): void;
+/**
+ * @internal
+ */
+export function createYieldingScheduler(yieldAfterMS?: number): (coroutine: any, onStep: any, onError: any) => void;
+/**
+ * @internal
+ */
+export function runCoroutine(coroutine: any, scheduler: any, onSuccess: any, onError: any, abortSignal: any): void;
+/**
+ * @internal
+ */
+export function runCoroutineSync(coroutine: any, abortSignal: any): undefined;
+/**
+ * @internal
+ */
+export function runCoroutineAsync(coroutine: any, scheduler: any, abortSignal: any): Promise<any>;
+/**
+ * Given a function that returns a Coroutine<T>, produce a function with the same parameters that returns a T.
+ * The returned function runs the coroutine synchronously.
+ * @param coroutineFactory A function that returns a Coroutine<T>.
+ * @param abortSignal
+ * @returns A function that runs the coroutine synchronously.
+ * @internal
+ */
+export function makeSyncFunction(coroutineFactory: any, abortSignal: any): (...params: any[]) => undefined;
+/**
+ * Given a function that returns a Coroutine<T>, product a function with the same parameters that returns a Promise<T>.
+ * The returned function runs the coroutine asynchronously, yield control of the execution context occasionally to enable a more responsive experience.
+ * @param coroutineFactory A function that returns a Coroutine<T>.
+ * @param scheduler
+ * @param abortSignal
+ * @returns A function that runs the coroutine asynchronously.
+ * @internal
+ */
+export function makeAsyncFunction(coroutineFactory: any, scheduler: any, abortSignal: any): (...params: any[]) => Promise<any>;

package/dist/types/node_modules/@babylonjs/core/Misc/customAnimationFrameRequester.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/node_modules/@babylonjs/core/Misc/dataReader.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Utility class for reading from a data buffer
+ */
+export class DataReader {
+    /**
+     * Constructor
+     * @param buffer The buffer to read
+     */
+    constructor(buffer: any);
+    /**
+     * The current byte offset from the beginning of the data buffer.
+     */
+    byteOffset: number;
+    buffer: any;
+    /**
+     * Loads the given byte length.
+     * @param byteLength The byte length to load
+     * @returns A promise that resolves when the load is complete
+     */
+    loadAsync(byteLength: any): any;
+    _dataView: DataView | undefined;
+    _dataByteOffset: number | undefined;
+    /**
+     * Read a unsigned 32-bit integer from the currently loaded data range.
+     * @returns The 32-bit integer read
+     */
+    readUint32(): number;
+    /**
+     * Read a byte array from the currently loaded data range.
+     * @param byteLength The byte length to read
+     * @returns The byte array read
+     */
+    readUint8Array(byteLength: any): Uint8Array;
+    /**
+     * Read a string from the currently loaded data range.
+     * @param byteLength The byte length to read
+     * @returns The string read
+     */
+    readString(byteLength: any): string;
+    /**
+     * Skips the given byte length the currently loaded data range.
+     * @param byteLength The byte length to skip
+     */
+    skipBytes(byteLength: any): void;
+}

package/dist/types/node_modules/@babylonjs/core/Misc/dataStorage.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Class for storing data to local storage if available or in-memory storage otherwise
+ */
+export class DataStorage {
+    static _GetStorage(): Storage | {
+        getItem: (key: any) => any;
+        setItem: (key: any, value: any) => void;
+    };
+    /**
+     * Reads a string from the data storage
+     * @param key The key to read
+     * @param defaultValue The value if the key doesn't exist
+     * @returns The string value
+     */
+    static ReadString(key: any, defaultValue: any): any;
+    /**
+     * Writes a string to the data storage
+     * @param key The key to write
+     * @param value The value to write
+     */
+    static WriteString(key: any, value: any): void;
+    /**
+     * Reads a boolean from the data storage
+     * @param key The key to read
+     * @param defaultValue The value if the key doesn't exist
+     * @returns The boolean value
+     */
+    static ReadBoolean(key: any, defaultValue: any): any;
+    /**
+     * Writes a boolean to the data storage
+     * @param key The key to write
+     * @param value The value to write
+     */
+    static WriteBoolean(key: any, value: any): void;
+    /**
+     * Reads a number from the data storage
+     * @param key The key to read
+     * @param defaultValue The value if the key doesn't exist
+     * @returns The number value
+     */
+    static ReadNumber(key: any, defaultValue: any): any;
+    /**
+     * Writes a number to the data storage
+     * @param key The key to write
+     * @param value The value to write
+     */
+    static WriteNumber(key: any, value: any): void;
+}
+export namespace DataStorage {
+    const _Storage: Storage | {
+        getItem: (key: any) => any;
+        setItem: (key: any, value: any) => void;
+    };
+}