@combeenation/3d-viewer 0.0.1-types

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

@@ -0,0 +1,50 @@
+/**
+ * for description see https://www.khronos.org/opengles/sdk/tools/KTX/
+ * for file layout see https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/
+ */
+export class KhronosTextureContainer {
+    /**
+     * Checks if the given data starts with a KTX file identifier.
+     * @param data the data to check
+     * @returns true if the data is a KTX file or false otherwise
+     */
+    static IsValid(data: any): boolean;
+    /**
+     * Creates a new KhronosTextureContainer
+     * @param data contents of the KTX container file
+     * @param facesExpected should be either 1 or 6, based whether a cube texture or or
+     */
+    constructor(data: any, facesExpected: any);
+    data: any;
+    /**
+     * If the container has been made invalid (eg. constructor failed to correctly load array buffer)
+     */
+    isInvalid: boolean;
+    glType: number | undefined;
+    glTypeSize: number | undefined;
+    glFormat: number | undefined;
+    glInternalFormat: number | undefined;
+    glBaseInternalFormat: number | undefined;
+    pixelWidth: number | undefined;
+    pixelHeight: number | undefined;
+    pixelDepth: number | undefined;
+    numberOfArrayElements: number | undefined;
+    numberOfFaces: number | undefined;
+    numberOfMipmapLevels: number | undefined;
+    bytesOfKeyValueData: number | undefined;
+    loadType: number | undefined;
+    /**
+     * Uploads KTX content to a Babylon Texture.
+     * It is assumed that the texture has already been created & is currently bound
+     * @internal
+     */
+    uploadLevels(texture: any, loadMipmaps: any): void;
+    _upload2DCompressedLevels(texture: any, loadMipmaps: any): void;
+}
+export namespace KhronosTextureContainer {
+    const HEADER_LEN: number;
+    const COMPRESSED_2D: number;
+    const COMPRESSED_3D: number;
+    const TEX_2D: number;
+    const TEX_3D: number;
+}

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

@@ -0,0 +1,38 @@
+/**
+ * Class for loading KTX2 files
+ */
+export class KhronosTextureContainer2 {
+    static GetDefaultNumWorkers(): number;
+    static _Initialize(numWorkers: any): void;
+    /**
+     * Checks if the given data starts with a KTX2 file identifier.
+     * @param data the data to check
+     * @returns true if the data is a KTX2 file or false otherwise
+     */
+    static IsValid(data: any): boolean;
+    /**
+     * Constructor
+     * @param engine The engine to use
+     * @param numWorkers The number of workers for async operations. Specify `0` to disable web workers and run synchronously in the current context.
+     */
+    constructor(engine: any, numWorkers?: number);
+    _engine: any;
+    /**
+     * @internal
+     */
+    uploadAsync(data: any, internalTexture: any, options: any): any;
+    _createTexture(data: any, internalTexture: any, options: any): void;
+}
+export namespace KhronosTextureContainer2 {
+    namespace URLConfig {
+        const jsDecoderModule: string;
+        const wasmUASTCToASTC: null;
+        const wasmUASTCToBC7: null;
+        const wasmUASTCToRGBA_UNORM: null;
+        const wasmUASTCToRGBA_SRGB: null;
+        const jsMSCTranscoder: null;
+        const wasmMSCTranscoder: null;
+        const wasmZSTDDecoder: null;
+    }
+    const DefaultNumWorkers: number;
+}

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

@@ -0,0 +1,50 @@
+/**
+ * Logger used throughout the application to allow configuration of
+ * the log level required for the messages.
+ */
+export class Logger {
+    static _CheckLimit(message: any, limit: any): boolean;
+    static _GenerateLimitMessage(message: any, level?: number): void;
+    static _AddLogEntry(entry: any): void;
+    static _FormatMessage(message: any): string;
+    static _LogDisabled(message: any, limit: any): void;
+    static _LogEnabled(level: number | undefined, message: any, limit: any): void;
+    /**
+     * Gets current log cache (list of logs)
+     */
+    static get LogCache(): string;
+    /**
+     * Clears the log cache
+     */
+    static ClearLogCache(): void;
+    /**
+     * Sets the current log level (MessageLogLevel / WarningLogLevel / ErrorLogLevel)
+     */
+    static set LogLevels(arg: any);
+}
+export namespace Logger {
+    const NoneLogLevel: number;
+    const MessageLogLevel: number;
+    const WarningLogLevel: number;
+    const ErrorLogLevel: number;
+    const AllLogLevel: number;
+    const MessageLimitReached: string;
+    const _LogCache: string;
+    const _LogLimitOutputs: {};
+    const _Levels: ({
+        color?: undefined;
+        logFunc?: undefined;
+        name?: undefined;
+    } | {
+        color: string;
+        logFunc: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+        name: string;
+    })[];
+    const errorsCount: number;
+    const Log: (message?: any, limit?: any) => void;
+    const Warn: (message?: any, limit?: any) => void;
+    const Error: (message?: any, limit?: any) => void;
+}

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

@@ -0,0 +1,35 @@
+/**
+ * Class used to explode meshes (ie. to have a center and move them away from that center to better see the overall organization)
+ */
+export class MeshExploder {
+    /**
+     * Explodes meshes from a center mesh.
+     * @param meshes The meshes to explode.
+     * @param centerMesh The mesh to be center of explosion.
+     */
+    constructor(meshes: any, centerMesh: any);
+    _meshesOrigins: any[];
+    _toCenterVectors: Vector3[];
+    _scaledDirection: Vector3;
+    _newPosition: Vector3;
+    _centerPosition: any;
+    _meshes: any;
+    _centerMesh: any;
+    _setCenterMesh(): void;
+    /**
+     * Get class name
+     * @returns "MeshExploder"
+     */
+    getClassName(): string;
+    /**
+     * "Exploded meshes"
+     * @returns Array of meshes with the centerMesh at index 0.
+     */
+    getMeshes(): any;
+    /**
+     * Explodes meshes giving a specific direction
+     * @param direction Number to multiply distance of each mesh's origin from center. Use a negative number to implode, or zero to reset.
+     */
+    explode(direction?: number): void;
+}
+import { Vector3 } from "../Maths/math.vector.js";

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

@@ -0,0 +1,68 @@
+/**
+ * This class computes a min/max reduction from a texture: it means it computes the minimum
+ * and maximum values from all values of the texture.
+ * It is performed on the GPU for better performances, thanks to a succession of post processes.
+ * The source values are read from the red channel of the texture.
+ */
+export class MinMaxReducer {
+    /**
+     * Creates a min/max reducer
+     * @param camera The camera to use for the post processes
+     */
+    constructor(camera: any);
+    /**
+     * Observable triggered when the computation has been performed
+     */
+    onAfterReductionPerformed: Observable<any>;
+    _forceFullscreenViewport: boolean;
+    _activated: boolean;
+    _camera: any;
+    _postProcessManager: PostProcessManager;
+    _onContextRestoredObserver: any;
+    /**
+     * Gets the texture used to read the values from.
+     */
+    get sourceTexture(): any;
+    /**
+     * Sets the source texture to read the values from.
+     * One must indicate if the texture is a depth texture or not through the depthRedux parameter
+     * because in such textures '1' value must not be taken into account to compute the maximum
+     * as this value is used to clear the texture.
+     * Note that the computation is not activated by calling this function, you must call activate() for that!
+     * @param sourceTexture The texture to read the values from. The values should be in the red channel.
+     * @param depthRedux Indicates if the texture is a depth texture or not
+     * @param type The type of the textures created for the reduction (defaults to TEXTURETYPE_HALF_FLOAT)
+     * @param forceFullscreenViewport Forces the post processes used for the reduction to be applied without taking into account viewport (defaults to true)
+     */
+    setSourceTexture(sourceTexture: any, depthRedux: any, type?: number, forceFullscreenViewport?: boolean): void;
+    _sourceTexture: any;
+    _reductionSteps: any[] | null | undefined;
+    set refreshRate(arg: any);
+    /**
+     * Defines the refresh rate of the computation.
+     * Use 0 to compute just once, 1 to compute on every frame, 2 to compute every two frames and so on...
+     */
+    get refreshRate(): any;
+    /**
+     * Gets the activation status of the reducer
+     */
+    get activated(): boolean;
+    /**
+     * Activates the reduction computation.
+     * When activated, the observers registered in onAfterReductionPerformed are
+     * called after the computation is performed
+     */
+    activate(): void;
+    _onAfterUnbindObserver: any;
+    /**
+     * Deactivates the reduction computation.
+     */
+    deactivate(): void;
+    /**
+     * Disposes the min/max reducer
+     * @param disposeAll true to dispose all the resources. You should always call this function with true as the parameter (or without any parameter as it is the default one). This flag is meant to be used internally.
+     */
+    dispose(disposeAll?: boolean): void;
+}
+import { Observable } from "./observable.js";
+import { PostProcessManager } from "../PostProcesses/postProcessManager.js";

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

@@ -0,0 +1,158 @@
+/**
+ * A class serves as a medium between the observable and its observers
+ */
+export class EventState {
+    /**
+     * Create a new EventState
+     * @param mask defines the mask associated with this state
+     * @param skipNextObservers defines a flag which will instruct the observable to skip following observers when set to true
+     * @param target defines the original target of the state
+     * @param currentTarget defines the current target of the state
+     */
+    constructor(mask: any, skipNextObservers: boolean | undefined, target: any, currentTarget: any);
+    /**
+     * Initialize the current event state
+     * @param mask defines the mask associated with this state
+     * @param skipNextObservers defines a flag which will instruct the observable to skip following observers when set to true
+     * @param target defines the original target of the state
+     * @param currentTarget defines the current target of the state
+     * @returns the current event state
+     */
+    initialize(mask: any, skipNextObservers: boolean | undefined, target: any, currentTarget: any): EventState;
+    mask: any;
+    skipNextObservers: boolean | undefined;
+    target: any;
+    currentTarget: any;
+}
+/**
+ * Represent an Observer registered to a given Observable object.
+ */
+export class Observer {
+    /**
+     * Creates a new observer
+     * @param callback defines the callback to call when the observer is notified
+     * @param mask defines the mask of the observer (used to filter notifications)
+     * @param scope defines the current scope used to restore the JS context
+     */
+    constructor(callback: any, mask: any, scope?: null);
+    callback: any;
+    mask: any;
+    scope: any;
+    /** @internal */
+    _willBeUnregistered: boolean;
+    /**
+     * Gets or sets a property defining that the observer as to be unregistered after the next notification
+     */
+    unregisterOnNextCall: boolean;
+}
+/**
+ * The Observable class is a simple implementation of the Observable pattern.
+ *
+ * There's one slight particularity though: a given Observable can notify its observer using a particular mask value, only the Observers registered with this mask value will be notified.
+ * This enable a more fine grained execution without having to rely on multiple different Observable objects.
+ * For instance you may have a given Observable that have four different types of notifications: Move (mask = 0x01), Stop (mask = 0x02), Turn Right (mask = 0X04), Turn Left (mask = 0X08).
+ * A given observer can register itself with only Move and Stop (mask = 0x03), then it will only be notified when one of these two occurs and will never be for Turn Left/Right.
+ */
+export class Observable {
+    /**
+     * Create an observable from a Promise.
+     * @param promise a promise to observe for fulfillment.
+     * @param onErrorObservable an observable to notify if a promise was rejected.
+     * @returns the new Observable
+     */
+    static FromPromise(promise: any, onErrorObservable: any): Observable;
+    /**
+     * Creates a new observable
+     * @param onObserverAdded defines a callback to call when a new observer is added
+     */
+    constructor(onObserverAdded: any);
+    _observers: any[];
+    _eventState: EventState;
+    _onObserverAdded: any;
+    /**
+     * Gets the list of observers
+     */
+    get observers(): any[];
+    /**
+     * Create a new Observer with the specified callback
+     * @param callback the callback that will be executed for that Observer
+     * @param mask the mask used to filter observers
+     * @param insertFirst if true the callback will be inserted at the first position, hence executed before the others ones. If false (default behavior) the callback will be inserted at the last position, executed after all the others already present.
+     * @param scope optional scope for the callback to be called from
+     * @param unregisterOnFirstCall defines if the observer as to be unregistered after the next notification
+     * @returns the new observer created for the callback
+     */
+    add(callback: any, mask?: number, insertFirst?: boolean, scope?: null, unregisterOnFirstCall?: boolean): Observer | null;
+    /**
+     * Create a new Observer with the specified callback and unregisters after the next notification
+     * @param callback the callback that will be executed for that Observer
+     * @returns the new observer created for the callback
+     */
+    addOnce(callback: any): Observer | null;
+    /**
+     * Remove an Observer from the Observable object
+     * @param observer the instance of the Observer to remove
+     * @returns false if it doesn't belong to this Observable
+     */
+    remove(observer: any): boolean;
+    /**
+     * Remove a callback from the Observable object
+     * @param callback the callback to remove
+     * @param scope optional scope. If used only the callbacks with this scope will be removed
+     * @returns false if it doesn't belong to this Observable
+     */
+    removeCallback(callback: any, scope: any): boolean;
+    /**
+     * @internal
+     */
+    _deferUnregister(observer: any): void;
+    _remove(observer: any): boolean;
+    /**
+     * Moves the observable to the top of the observer list making it get called first when notified
+     * @param observer the observer to move
+     */
+    makeObserverTopPriority(observer: any): void;
+    /**
+     * Moves the observable to the bottom of the observer list making it get called last when notified
+     * @param observer the observer to move
+     */
+    makeObserverBottomPriority(observer: any): void;
+    /**
+     * Notify all Observers by calling their respective callback with the given data
+     * Will return true if all observers were executed, false if an observer set skipNextObservers to true, then prevent the subsequent ones to execute
+     * @param eventData defines the data to send to all observers
+     * @param mask defines the mask of the current notification (observers with incompatible mask (ie mask & observer.mask === 0) will not be notified)
+     * @param target defines the original target of the state
+     * @param currentTarget defines the current target of the state
+     * @param userInfo defines any user info to send to observers
+     * @returns false if the complete observer chain was not processed (because one observer set the skipNextObservers to true)
+     */
+    notifyObservers(eventData: any, mask: number | undefined, target: any, currentTarget: any, userInfo: any): boolean;
+    /**
+     * Notify a specific observer
+     * @param observer defines the observer to notify
+     * @param eventData defines the data to be sent to each callback
+     * @param mask is used to filter observers defaults to -1
+     */
+    notifyObserver(observer: any, eventData: any, mask?: number): void;
+    /**
+     * Gets a boolean indicating if the observable has at least one observer
+     * @returns true is the Observable has at least one Observer registered
+     */
+    hasObservers(): boolean;
+    /**
+     * Clear the list of observers
+     */
+    clear(): void;
+    /**
+     * Clone the current observable
+     * @returns a new observable
+     */
+    clone(): Observable;
+    /**
+     * Does this observable handles observer registered with a given mask
+     * @param mask defines the mask to be tested
+     * @returns whether or not one observer registered with the given mask is handled
+     **/
+    hasSpecificMask(mask?: number): boolean;
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Represent a list of observers registered to multiple Observables object.
+ */
+export class MultiObserver {
+    /**
+     * Raise a callback when one of the observable will notify
+     * @param observables defines a list of observables to watch
+     * @param callback defines the callback to call on notification
+     * @param mask defines the mask used to filter notifications
+     * @param scope defines the current scope used to restore the JS context
+     * @returns the new MultiObserver
+     */
+    static Watch(observables: any, callback: any, mask?: number, scope?: null): MultiObserver;
+    /**
+     * Release associated resources
+     */
+    dispose(): void;
+    _observers: any;
+    _observables: any;
+}

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

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

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

@@ -0,0 +1,73 @@
+/**
+ * This class is used to track a performance counter which is number based.
+ * The user has access to many properties which give statistics of different nature.
+ *
+ * The implementer can track two kinds of Performance Counter: time and count.
+ * For time you can optionally call fetchNewFrame() to notify the start of a new frame to monitor, then call beginMonitoring() to start and endMonitoring() to record the lapsed time. endMonitoring takes a newFrame parameter for you to specify if the monitored time should be set for a new frame or accumulated to the current frame being monitored.
+ * For count you first have to call fetchNewFrame() to notify the start of a new frame to monitor, then call addCount() how many time required to increment the count value you monitor.
+ */
+export class PerfCounter {
+    _startMonitoringTime: number;
+    _min: number;
+    _max: number;
+    _average: number;
+    _lastSecAverage: number;
+    _current: number;
+    _totalValueCount: number;
+    _totalAccumulated: number;
+    _lastSecAccumulated: number;
+    _lastSecTime: number;
+    _lastSecValueCount: number;
+    /**
+     * Returns the smallest value ever
+     */
+    get min(): number;
+    /**
+     * Returns the biggest value ever
+     */
+    get max(): number;
+    /**
+     * Returns the average value since the performance counter is running
+     */
+    get average(): number;
+    /**
+     * Returns the average value of the last second the counter was monitored
+     */
+    get lastSecAverage(): number;
+    /**
+     * Returns the current value
+     */
+    get current(): number;
+    /**
+     * Gets the accumulated total
+     */
+    get total(): number;
+    /**
+     * Gets the total value count
+     */
+    get count(): number;
+    /**
+     * Call this method to start monitoring a new frame.
+     * This scenario is typically used when you accumulate monitoring time many times for a single frame, you call this method at the start of the frame, then beginMonitoring to start recording and endMonitoring(false) to accumulated the recorded time to the PerfCounter or addCount() to accumulate a monitored count.
+     */
+    fetchNewFrame(): void;
+    /**
+     * Call this method to monitor a count of something (e.g. mesh drawn in viewport count)
+     * @param newCount the count value to add to the monitored count
+     * @param fetchResult true when it's the last time in the frame you add to the counter and you wish to update the statistics properties (min/max/average), false if you only want to update statistics.
+     */
+    addCount(newCount: any, fetchResult: any): void;
+    /**
+     * Start monitoring this performance counter
+     */
+    beginMonitoring(): void;
+    /**
+     * Compute the time lapsed since the previous beginMonitoring() call.
+     * @param newFrame true by default to fetch the result and monitor a new frame, if false the time monitored will be added to the current frame counter
+     */
+    endMonitoring(newFrame?: boolean): void;
+    _fetchResult(): void;
+}
+export namespace PerfCounter {
+    const Enabled: boolean;
+}

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

@@ -0,0 +1,103 @@
+/**
+ * Performance monitor tracks rolling average frame-time and frame-time variance over a user defined sliding-window
+ */
+export class PerformanceMonitor {
+    /**
+     * constructor
+     * @param frameSampleSize The number of samples required to saturate the sliding window
+     */
+    constructor(frameSampleSize?: number);
+    _enabled: boolean;
+    _rollingFrameTime: RollingAverage;
+    /**
+     * Samples current frame
+     * @param timeMs A timestamp in milliseconds of the current frame to compare with other frames
+     */
+    sampleFrame(timeMs?: number): void;
+    _lastFrameTimeMs: number | null | undefined;
+    /**
+     * Returns the average frame time in milliseconds over the sliding window (or the subset of frames sampled so far)
+     */
+    get averageFrameTime(): number | undefined;
+    /**
+     * Returns the variance frame time in milliseconds over the sliding window (or the subset of frames sampled so far)
+     */
+    get averageFrameTimeVariance(): number | undefined;
+    /**
+     * Returns the frame time of the most recent frame
+     */
+    get instantaneousFrameTime(): any;
+    /**
+     * Returns the average framerate in frames per second over the sliding window (or the subset of frames sampled so far)
+     */
+    get averageFPS(): number;
+    /**
+     * Returns the average framerate in frames per second using the most recent frame time
+     */
+    get instantaneousFPS(): number;
+    /**
+     * Returns true if enough samples have been taken to completely fill the sliding window
+     */
+    get isSaturated(): boolean;
+    /**
+     * Enables contributions to the sliding window sample set
+     */
+    enable(): void;
+    /**
+     * Disables contributions to the sliding window sample set
+     * Samples will not be interpolated over the disabled period
+     */
+    disable(): void;
+    /**
+     * Returns true if sampling is enabled
+     */
+    get isEnabled(): boolean;
+    /**
+     * Resets performance monitor
+     */
+    reset(): void;
+}
+/**
+ * RollingAverage
+ *
+ * Utility to efficiently compute the rolling average and variance over a sliding window of samples
+ */
+export class RollingAverage {
+    /**
+     * constructor
+     * @param length The number of samples required to saturate the sliding window
+     */
+    constructor(length: any);
+    _samples: any[];
+    /**
+     * Adds a sample to the sample set
+     * @param v The sample value
+     */
+    add(v: any): void;
+    variance: number | undefined;
+    /**
+     * Returns previously added values or null if outside of history or outside the sliding window domain
+     * @param i Index in history. For example, pass 0 for the most recent value and 1 for the value before that
+     * @returns Value previously recorded with add() or null if outside of range
+     */
+    history(i: any): any;
+    /**
+     * Returns true if enough samples have been taken to completely fill the sliding window
+     * @returns true if sample-set saturated
+     */
+    isSaturated(): boolean;
+    /**
+     * Resets the rolling average (equivalent to 0 samples taken so far)
+     */
+    reset(): void;
+    average: number | undefined;
+    _sampleCount: number | undefined;
+    _pos: number | undefined;
+    _m2: number | undefined;
+    /**
+     * Wraps a value around the sample range boundaries
+     * @param i Position in sample range, for example if the sample length is 5, and i is -3, then 2 will be returned.
+     * @returns Wrapped position in sample range
+     */
+    _wrapPosition(i: any): number;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Class containing a set of static utilities functions for managing Pivots
+ * @internal
+ */
+export class PivotTools {
+    /**
+     * @internal
+     */
+    static _RemoveAndStorePivotPoint(mesh: any): void;
+    /**
+     * @internal
+     */
+    static _RestorePivotPoint(mesh: any): void;
+}
+export namespace PivotTools {
+    const _PivotCached: number;
+    const _OldPivotPoint: Vector3;
+    const _PivotTranslation: Vector3;
+    const _PivotTmpVector: Vector3;
+    const _PivotPostMultiplyPivotMatrix: boolean;
+}
+import { Vector3 } from "../Maths/math.vector.js";

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

@@ -0,0 +1,9 @@
+/**
+ * Class containing a set of static utilities functions for precision date
+ */
+export class PrecisionDate {
+    /**
+     * Gets either window.performance.now() if supported or Date.now() else
+     */
+    static get Now(): number;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Class used to connect with the reflector zone of the sandbox via the reflector bridge
+ * @since 5.0.0
+ */
+export class Reflector {
+    /**
+     * Constructs a reflector object.
+     * @param scene The scene to use
+     * @param hostname The hostname of the reflector bridge
+     * @param port The port of the reflector bridge
+     */
+    constructor(scene: any, hostname: any, port: any);
+    _scene: any;
+    _webSocket: WebSocket;
+    /**
+     * Closes the reflector connection
+     */
+    close(): void;
+    _handleServerMessage(message: any): void;
+    _handleClientMessage(): void;
+}
+export namespace Reflector {
+    const _SERVER_PREFIX: string;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Class used to define a retry strategy when error happens while loading assets
+ */
+export class RetryStrategy {
+    /**
+     * Function used to defines an exponential back off strategy
+     * @param maxRetries defines the maximum number of retries (3 by default)
+     * @param baseInterval defines the interval between retries
+     * @returns the strategy function to use
+     */
+    static ExponentialBackoff(maxRetries?: number, baseInterval?: number): (url: any, request: any, retryIndex: any) => number;
+}