@combeenation/3d-viewer 0.0.1-types

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

@@ -0,0 +1,593 @@
+/**
+ * Use this className as a decorator on a given class definition to add it a name and optionally its module.
+ * You can then use the Tools.getClassName(obj) on an instance to retrieve its class name.
+ * This method is the only way to get it done in all cases, even if the .js file declaring the class is minified
+ * @param name The name of the class, case should be preserved
+ * @param module The name of the Module hosting the class, optional, but strongly recommended to specify if possible. Case should be preserved.
+ */
+export function className(name: any, module: any): (target: any) => void;
+/**
+ * Class containing a set of static utilities functions
+ */
+export class Tools {
+    static set BaseUrl(arg: string);
+    /**
+     * Gets or sets the base URL to use to load assets
+     */
+    static get BaseUrl(): string;
+    static set DefaultRetryStrategy(arg: (url: string, request: WebRequest, retryIndex: number) => number);
+    /**
+     * Gets or sets the retry strategy to apply when an error happens while loading an asset
+     */
+    static get DefaultRetryStrategy(): (url: string, request: WebRequest, retryIndex: number) => number;
+    static set CorsBehavior(arg: string | ((url: string | string[]) => string));
+    /**
+     * Default behaviour for cors in the application.
+     * It can be a string if the expected behavior is identical in the entire app.
+     * Or a callback to be able to set it per url or on a group of them (in case of Video source for instance)
+     */
+    static get CorsBehavior(): string | ((url: string | string[]) => string);
+    static set UseFallbackTexture(arg: boolean);
+    /**
+     * Gets or sets a global variable indicating if fallback texture must be used when a texture cannot be loaded
+     * @ignorenaming
+     */
+    static get UseFallbackTexture(): boolean;
+    static set RegisteredExternalClasses(arg: {
+        [key: string]: Object;
+    });
+    /**
+     * Use this object to register external classes like custom textures or material
+     * to allow the loaders to instantiate them
+     */
+    static get RegisteredExternalClasses(): {
+        [key: string]: Object;
+    };
+    static set fallbackTexture(arg: string);
+    /**
+     * Texture content used if a texture cannot loaded
+     * @ignorenaming
+     */
+    static get fallbackTexture(): string;
+    /**
+     * Read the content of a byte array at a specified coordinates (taking in account wrapping)
+     * @param u defines the coordinate on X axis
+     * @param v defines the coordinate on Y axis
+     * @param width defines the width of the source data
+     * @param height defines the height of the source data
+     * @param pixels defines the source byte array
+     * @param color defines the output color
+     */
+    static FetchToRef(u: any, v: any, width: any, height: any, pixels: any, color: any): void;
+    /**
+     * Interpolates between a and b via alpha
+     * @param a The lower value (returned when alpha = 0)
+     * @param b The upper value (returned when alpha = 1)
+     * @param alpha The interpolation-factor
+     * @returns The mixed value
+     */
+    static Mix(a: any, b: any, alpha: any): number;
+    /**
+     * Tries to instantiate a new object from a given class name
+     * @param className defines the class name to instantiate
+     * @returns the new object or null if the system was not able to do the instantiation
+     */
+    static Instantiate(className: any): any;
+    /**
+     * Polyfill for setImmediate
+     * @param action defines the action to execute after the current execution block
+     */
+    static SetImmediate(action: any): void;
+    /**
+     * Function indicating if a number is an exponent of 2
+     * @param value defines the value to test
+     * @returns true if the value is an exponent of 2
+     */
+    static IsExponentOfTwo(value: any): boolean;
+    /**
+     * Returns the nearest 32-bit single precision float representation of a Number
+     * @param value A Number.  If the parameter is of a different type, it will get converted
+     * to a number or to NaN if it cannot be converted
+     * @returns number
+     */
+    static FloatRound(value: any): number;
+    /**
+     * Extracts the filename from a path
+     * @param path defines the path to use
+     * @returns the filename
+     */
+    static GetFilename(path: any): any;
+    /**
+     * Extracts the "folder" part of a path (everything before the filename).
+     * @param uri The URI to extract the info from
+     * @param returnUnchangedIfNoSlash Do not touch the URI if no slashes are present
+     * @returns The "folder" part of the path
+     */
+    static GetFolderPath(uri: any, returnUnchangedIfNoSlash?: boolean): any;
+    /**
+     * Convert an angle in radians to degrees
+     * @param angle defines the angle to convert
+     * @returns the angle in degrees
+     */
+    static ToDegrees(angle: any): number;
+    /**
+     * Convert an angle in degrees to radians
+     * @param angle defines the angle to convert
+     * @returns the angle in radians
+     */
+    static ToRadians(angle: any): number;
+    /**
+     * Smooth angle changes (kind of low-pass filter), in particular for device orientation "shaking"
+     * Use trigonometric functions to avoid discontinuity (0/360, -180/180)
+     * @param previousAngle defines last angle value, in degrees
+     * @param newAngle defines new angle value, in degrees
+     * @param smoothFactor defines smoothing sensitivity; min 0: no smoothing, max 1: new data ignored
+     * @returns the angle in degrees
+     */
+    static SmoothAngleChange(previousAngle: any, newAngle: any, smoothFactor?: number): number;
+    /**
+     * Returns an array if obj is not an array
+     * @param obj defines the object to evaluate as an array
+     * @param allowsNullUndefined defines a boolean indicating if obj is allowed to be null or undefined
+     * @returns either obj directly if obj is an array or a new array containing obj
+     */
+    static MakeArray(obj: any, allowsNullUndefined: any): any[] | null;
+    /**
+     * Gets the pointer prefix to use
+     * @param engine defines the engine we are finding the prefix for
+     * @returns "pointer" if touch is enabled. Else returns "mouse"
+     */
+    static GetPointerPrefix(engine: any): string;
+    /**
+     * Sets the cors behavior on a dom element. This will add the required Tools.CorsBehavior to the element.
+     * @param url define the url we are trying
+     * @param element define the dom element where to configure the cors policy
+     * @param element.crossOrigin
+     */
+    static SetCorsBehavior(url: any, element: any): void;
+    /**
+     * Sets the referrerPolicy behavior on a dom element.
+     * @param referrerPolicy define the referrer policy to use
+     * @param element define the dom element where to configure the referrer policy
+     * @param element.referrerPolicy
+     */
+    static SetReferrerPolicyBehavior(referrerPolicy: any, element: any): void;
+    /**
+     * Removes unwanted characters from an url
+     * @param url defines the url to clean
+     * @returns the cleaned url
+     */
+    static CleanUrl(url: any): any;
+    static set PreprocessUrl(arg: (url: string) => string);
+    /**
+     * Gets or sets a function used to pre-process url before using them to load assets
+     */
+    static get PreprocessUrl(): (url: string) => string;
+    /**
+     * Loads an image as an HTMLImageElement.
+     * @param input url string, ArrayBuffer, or Blob to load
+     * @param onLoad callback called when the image successfully loads
+     * @param onError callback called when the image fails to load
+     * @param offlineProvider offline provider for caching
+     * @param mimeType optional mime type
+     * @param imageBitmapOptions optional the options to use when creating an ImageBitmap
+     * @returns the HTMLImageElement of the loaded image
+     */
+    static LoadImage(input: any, onLoad: any, onError: any, offlineProvider: any, mimeType: any, imageBitmapOptions: any): import("@babylonjs/core").Nullable<HTMLImageElement>;
+    /**
+     * Loads a file from a url
+     * @param url url string, ArrayBuffer, or Blob to load
+     * @param onSuccess callback called when the file successfully loads
+     * @param onProgress callback called while file is loading (if the server supports this mode)
+     * @param offlineProvider defines the offline provider for caching
+     * @param useArrayBuffer defines a boolean indicating that date must be returned as ArrayBuffer
+     * @param onError callback called when the file fails to load
+     * @returns a file request object
+     */
+    static LoadFile(url: any, onSuccess: any, onProgress: any, offlineProvider: any, useArrayBuffer: any, onError: any): import("@babylonjs/core").IFileRequest;
+    /**
+     * Loads a file from a url
+     * @param url the file url to load
+     * @param useArrayBuffer defines a boolean indicating that date must be returned as ArrayBuffer
+     * @returns a promise containing an ArrayBuffer corresponding to the loaded file
+     */
+    static LoadFileAsync(url: any, useArrayBuffer?: boolean): Promise<any>;
+    /**
+     * Load a script (identified by an url). When the url returns, the
+     * content of this file is added into a new script element, attached to the DOM (body element)
+     * @param scriptUrl defines the url of the script to laod
+     * @param onSuccess defines the callback called when the script is loaded
+     * @param onError defines the callback to call if an error occurs
+     * @param scriptId defines the id of the script element
+     */
+    static LoadScript(scriptUrl: any, onSuccess: any, onError: any, scriptId: any): void;
+    /**
+     * Load an asynchronous script (identified by an url). When the url returns, the
+     * content of this file is added into a new script element, attached to the DOM (body element)
+     * @param scriptUrl defines the url of the script to laod
+     * @returns a promise request object
+     */
+    static LoadScriptAsync(scriptUrl: any): Promise<any>;
+    /**
+     * Loads a file from a blob
+     * @param fileToLoad defines the blob to use
+     * @param callback defines the callback to call when data is loaded
+     * @param progressCallback defines the callback to call during loading process
+     * @returns a file request object
+     */
+    static ReadFileAsDataURL(fileToLoad: any, callback: any, progressCallback: any): {
+        onCompleteObservable: Observable<any>;
+        abort: () => void;
+    };
+    /**
+     * Reads a file from a File object
+     * @param file defines the file to load
+     * @param onSuccess defines the callback to call when data is loaded
+     * @param onProgress defines the callback to call during loading process
+     * @param useArrayBuffer defines a boolean indicating that data must be returned as an ArrayBuffer
+     * @param onError defines the callback to call when an error occurs
+     * @returns a file request object
+     */
+    static ReadFile(file: any, onSuccess: any, onProgress: any, useArrayBuffer: any, onError: any): import("@babylonjs/core").IFileRequest;
+    /**
+     * Creates a data url from a given string content
+     * @param content defines the content to convert
+     * @returns the new data url link
+     */
+    static FileAsURL(content: any): string;
+    /**
+     * Format the given number to a specific decimal format
+     * @param value defines the number to format
+     * @param decimals defines the number of decimals to use
+     * @returns the formatted string
+     */
+    static Format(value: any, decimals?: number): any;
+    /**
+     * Tries to copy an object by duplicating every property
+     * @param source defines the source object
+     * @param destination defines the target object
+     * @param doNotCopyList defines a list of properties to avoid
+     * @param mustCopyList defines a list of properties to copy (even if they start with _)
+     */
+    static DeepCopy(source: any, destination: any, doNotCopyList: any, mustCopyList: any): void;
+    /**
+     * Gets a boolean indicating if the given object has no own property
+     * @param obj defines the object to test
+     * @returns true if object has no own property
+     */
+    static IsEmpty(obj: any): boolean;
+    /**
+     * Function used to register events at window level
+     * @param windowElement defines the Window object to use
+     * @param events defines the events to register
+     */
+    static RegisterTopRootEvents(windowElement: any, events: any): void;
+    /**
+     * Function used to unregister events from window level
+     * @param windowElement defines the Window object to use
+     * @param events defines the events to unregister
+     */
+    static UnregisterTopRootEvents(windowElement: any, events: any): void;
+    /**
+     * Dumps the current bound framebuffer
+     * @param width defines the rendering width
+     * @param height defines the rendering height
+     * @param engine defines the hosting engine
+     * @param successCallback defines the callback triggered once the data are available
+     * @param mimeType defines the mime type of the result
+     * @param fileName defines the filename to download. If present, the result will automatically be downloaded
+     * @returns a void promise
+     */
+    static DumpFramebuffer(width: any, height: any, engine: any, successCallback: any, mimeType: string | undefined, fileName: any): Promise<void>;
+    /**
+     * Dumps an array buffer
+     * @param width defines the rendering width
+     * @param height defines the rendering height
+     * @param data the data array
+     * @param successCallback defines the callback triggered once the data are available
+     * @param mimeType defines the mime type of the result
+     * @param fileName defines the filename to download. If present, the result will automatically be downloaded
+     * @param invertY true to invert the picture in the Y dimension
+     * @param toArrayBuffer true to convert the data to an ArrayBuffer (encoded as `mimeType`) instead of a base64 string
+     * @param quality defines the quality of the result
+     */
+    static DumpData(width: any, height: any, data: any, successCallback: any, mimeType: string | undefined, fileName: any, invertY: boolean | undefined, toArrayBuffer: boolean | undefined, quality: any): void;
+    /**
+     * Dumps an array buffer
+     * @param width defines the rendering width
+     * @param height defines the rendering height
+     * @param data the data array
+     * @param mimeType defines the mime type of the result
+     * @param fileName defines the filename to download. If present, the result will automatically be downloaded
+     * @param invertY true to invert the picture in the Y dimension
+     * @param toArrayBuffer true to convert the data to an ArrayBuffer (encoded as `mimeType`) instead of a base64 string
+     * @param quality defines the quality of the result
+     * @returns a promise that resolve to the final data
+     */
+    static DumpDataAsync(width: any, height: any, data: any, mimeType: string | undefined, fileName: any, invertY: boolean | undefined, toArrayBuffer: boolean | undefined, quality: any): Promise<any>;
+    /**
+     * Converts the canvas data to blob.
+     * This acts as a polyfill for browsers not supporting the to blob function.
+     * @param canvas Defines the canvas to extract the data from
+     * @param successCallback Defines the callback triggered once the data are available
+     * @param mimeType Defines the mime type of the result
+     * @param quality defines the quality of the result
+     */
+    static ToBlob(canvas: any, successCallback: any, mimeType: string | undefined, quality: any): void;
+    /**
+     * Download a Blob object
+     * @param blob the Blob object
+     * @param fileName the file name to download
+     * @returns
+     */
+    static DownloadBlob(blob: any, fileName: any): void;
+    /**
+     * Encodes the canvas data to base 64 or automatically download the result if filename is defined
+     * @param successCallback defines the callback triggered once the data are available
+     * @param mimeType defines the mime type of the result
+     * @param fileName defines he filename to download. If present, the result will automatically be downloaded
+     * @param canvas canvas to get the data from. If not provided, use the default screenshot canvas
+     * @param quality defines the quality of the result
+     */
+    static EncodeScreenshotCanvasData(successCallback: any, mimeType: string | undefined, fileName: any, canvas: any, quality: any): void;
+    /**
+     * Downloads a blob in the browser
+     * @param blob defines the blob to download
+     * @param fileName defines the name of the downloaded file
+     */
+    static Download(blob: any, fileName: any): void;
+    /**
+     * Will return the right value of the noPreventDefault variable
+     * Needed to keep backwards compatibility to the old API.
+     *
+     * @param args arguments passed to the attachControl function
+     * @returns the correct value for noPreventDefault
+     */
+    static BackCompatCameraNoPreventDefault(args: any): boolean;
+    /**
+     * Captures a screenshot of the current rendering
+     * @see https://doc.babylonjs.com/how_to/render_scene_on_a_png
+     * @param engine defines the rendering engine
+     * @param camera defines the source camera
+     * @param size This parameter can be set to a single number or to an object with the
+     * following (optional) properties: precision, width, height. If a single number is passed,
+     * it will be used for both width and height. If an object is passed, the screenshot size
+     * will be derived from the parameters. The precision property is a multiplier allowing
+     * rendering at a higher or lower resolution
+     * @param successCallback defines the callback receives a single parameter which contains the
+     * screenshot as a string of base64-encoded characters. This string can be assigned to the
+     * src parameter of an <img> to display it
+     * @param mimeType defines the MIME type of the screenshot image (default: image/png).
+     * Check your browser for supported MIME types
+     */
+    static CreateScreenshot(engine: any, camera: any, size: any, successCallback: any, mimeType?: string): void;
+    /**
+     * Captures a screenshot of the current rendering
+     * @see https://doc.babylonjs.com/how_to/render_scene_on_a_png
+     * @param engine defines the rendering engine
+     * @param camera defines the source camera
+     * @param size This parameter can be set to a single number or to an object with the
+     * following (optional) properties: precision, width, height. If a single number is passed,
+     * it will be used for both width and height. If an object is passed, the screenshot size
+     * will be derived from the parameters. The precision property is a multiplier allowing
+     * rendering at a higher or lower resolution
+     * @param mimeType defines the MIME type of the screenshot image (default: image/png).
+     * Check your browser for supported MIME types
+     * @returns screenshot as a string of base64-encoded characters. This string can be assigned
+     * to the src parameter of an <img> to display it
+     */
+    static CreateScreenshotAsync(engine: any, camera: any, size: any, mimeType?: string): void;
+    /**
+     * Generates an image screenshot from the specified camera.
+     * @see https://doc.babylonjs.com/how_to/render_scene_on_a_png
+     * @param engine The engine to use for rendering
+     * @param camera The camera to use for rendering
+     * @param size This parameter can be set to a single number or to an object with the
+     * following (optional) properties: precision, width, height. If a single number is passed,
+     * it will be used for both width and height. If an object is passed, the screenshot size
+     * will be derived from the parameters. The precision property is a multiplier allowing
+     * rendering at a higher or lower resolution
+     * @param successCallback The callback receives a single parameter which contains the
+     * screenshot as a string of base64-encoded characters. This string can be assigned to the
+     * src parameter of an <img> to display it
+     * @param mimeType The MIME type of the screenshot image (default: image/png).
+     * Check your browser for supported MIME types
+     * @param samples Texture samples (default: 1)
+     * @param antialiasing Whether antialiasing should be turned on or not (default: false)
+     * @param fileName A name for for the downloaded file.
+     */
+    static CreateScreenshotUsingRenderTarget(engine: any, camera: any, size: any, successCallback: any, mimeType: string | undefined, samples: number | undefined, antialiasing: boolean | undefined, fileName: any): void;
+    /**
+     * Generates an image screenshot from the specified camera.
+     * @see https://doc.babylonjs.com/how_to/render_scene_on_a_png
+     * @param engine The engine to use for rendering
+     * @param camera The camera to use for rendering
+     * @param size This parameter can be set to a single number or to an object with the
+     * following (optional) properties: precision, width, height. If a single number is passed,
+     * it will be used for both width and height. If an object is passed, the screenshot size
+     * will be derived from the parameters. The precision property is a multiplier allowing
+     * rendering at a higher or lower resolution
+     * @param mimeType The MIME type of the screenshot image (default: image/png).
+     * Check your browser for supported MIME types
+     * @param samples Texture samples (default: 1)
+     * @param antialiasing Whether antialiasing should be turned on or not (default: false)
+     * @param fileName A name for for the downloaded file.
+     * @returns screenshot as a string of base64-encoded characters. This string can be assigned
+     * to the src parameter of an <img> to display it
+     */
+    static CreateScreenshotUsingRenderTargetAsync(engine: any, camera: any, size: any, mimeType: string | undefined, samples: number | undefined, antialiasing: boolean | undefined, fileName: any): void;
+    /**
+     * Implementation from http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#answer-2117523
+     * Be aware Math.random() could cause collisions, but:
+     * "All but 6 of the 128 bits of the ID are randomly generated, which means that for any two ids, there's a 1 in 2^^122 (or 5.3x10^^36) chance they'll collide"
+     * @returns a pseudo random id
+     */
+    static RandomId(): string;
+    /**
+     * Test if the given uri is a base64 string
+     * @deprecated Please use FileTools.IsBase64DataUrl instead.
+     * @param uri The uri to test
+     * @returns True if the uri is a base64 string or false otherwise
+     */
+    static IsBase64(uri: any): boolean;
+    /**
+     * Decode the given base64 uri.
+     * @deprecated Please use FileTools.DecodeBase64UrlToBinary instead.
+     * @param uri The uri to decode
+     * @returns The decoded base64 data.
+     */
+    static DecodeBase64(uri: any): ArrayBuffer;
+    /**
+     * Gets a value indicating the number of loading errors
+     * @ignorenaming
+     */
+    static get errorsCount(): number;
+    /**
+     * Log a message to the console
+     * @param message defines the message to log
+     */
+    static Log(message: any): void;
+    /**
+     * Write a warning message to the console
+     * @param message defines the message to log
+     */
+    static Warn(message: any): void;
+    /**
+     * Write an error message to the console
+     * @param message defines the message to log
+     */
+    static Error(message: 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);
+    /**
+     * Sets the current performance log level
+     */
+    static set PerformanceLogLevel(arg: any);
+    static _StartPerformanceCounterDisabled(counterName: any, condition: any): void;
+    static _EndPerformanceCounterDisabled(counterName: any, condition: any): void;
+    static _StartUserMark(counterName: any, condition?: boolean): void;
+    static _EndUserMark(counterName: any, condition?: boolean): void;
+    static _StartPerformanceConsole(counterName: any, condition?: boolean): void;
+    static _EndPerformanceConsole(counterName: any, condition?: boolean): void;
+    /**
+     * Gets either window.performance.now() if supported or Date.now() else
+     */
+    static get Now(): number;
+    /**
+     * This method will return the name of the class used to create the instance of the given object.
+     * It will works only on Javascript basic data types (number, string, ...) and instance of class declared with the @className decorator.
+     * @param object the object to get the class name from
+     * @param isType defines if the object is actually a type
+     * @returns the name of the class, will be "object" for a custom data type not using the @className decorator
+     */
+    static GetClassName(object: any, isType?: boolean): any;
+    /**
+     * Gets the first element of an array satisfying a given predicate
+     * @param array defines the array to browse
+     * @param predicate defines the predicate to use
+     * @returns null if not found or the element
+     */
+    static First(array: any, predicate: any): any;
+    /**
+     * This method will return the name of the full name of the class, including its owning module (if any).
+     * It will works only on Javascript basic data types (number, string, ...) and instance of class declared with the @className decorator or implementing a method getClassName():string (in which case the module won't be specified).
+     * @param object the object to get the class name from
+     * @param isType defines if the object is actually a type
+     * @returns a string that can have two forms: "moduleName.className" if module was specified when the class' Name was registered or "className" if there was not module specified.
+     * @ignorenaming
+     */
+    static getFullClassName(object: any, isType?: boolean): string | null;
+    /**
+     * Returns a promise that resolves after the given amount of time.
+     * @param delay Number of milliseconds to delay
+     * @returns Promise that resolves after the given amount of time
+     */
+    static DelayAsync(delay: any): Promise<any>;
+    /**
+     * Utility function to detect if the current user agent is Safari
+     * @returns whether or not the current user agent is safari
+     */
+    static IsSafari(): boolean;
+}
+export namespace Tools {
+    export const UseCustomRequestHeaders: boolean;
+    export const CustomRequestHeaders: {
+        [key: string]: string;
+    };
+    export const _TmpFloatArray: Float32Array;
+    export { GetDOMTextContent };
+    export function GetAbsoluteUrl(url: any): string;
+    export const NoneLogLevel: number;
+    export const MessageLogLevel: number;
+    export const WarningLogLevel: number;
+    export const ErrorLogLevel: number;
+    export const AllLogLevel: number;
+    export { IsWindowObjectExist };
+    export const PerformanceNoneLogLevel: number;
+    export const PerformanceUserMarkLogLevel: number;
+    export const PerformanceConsoleLogLevel: number;
+    import StartPerformanceCounter = Tools._StartPerformanceCounterDisabled;
+    export { StartPerformanceCounter };
+    import EndPerformanceCounter = Tools._EndPerformanceCounterDisabled;
+    export { EndPerformanceCounter };
+}
+/**
+ * An implementation of a loop for asynchronous functions.
+ */
+export class AsyncLoop {
+    /**
+     * Create and run an async loop.
+     * @param iterations the number of iterations.
+     * @param fn the function to run each iteration
+     * @param successCallback the callback that will be called upon successful execution
+     * @param offset starting offset.
+     * @returns the created async loop object
+     */
+    static Run(iterations: any, fn: any, successCallback: any, offset?: number): AsyncLoop;
+    /**
+     * A for-loop that will run a given number of iterations synchronous and the rest async.
+     * @param iterations total number of iterations
+     * @param syncedIterations number of synchronous iterations in each async iteration.
+     * @param fn the function to call each iteration.
+     * @param callback a success call back that will be called when iterating stops.
+     * @param breakFunction a break condition (optional)
+     * @param timeout timeout settings for the setTimeout function. default - 0.
+     * @returns the created async loop object
+     */
+    static SyncAsyncForLoop(iterations: any, syncedIterations: any, fn: any, callback: any, breakFunction: any, timeout?: number): AsyncLoop;
+    /**
+     * Constructor.
+     * @param iterations the number of iterations.
+     * @param func the function to run each iteration
+     * @param successCallback the callback that will be called upon successful execution
+     * @param offset starting offset.
+     */
+    constructor(iterations: any, func: any, successCallback: any, offset?: number);
+    iterations: any;
+    index: number;
+    _done: boolean;
+    _fn: any;
+    _successCallback: any;
+    /**
+     * Execute the next iteration. Must be called after the last iteration was finished.
+     */
+    executeNext(): void;
+    /**
+     * Break the loop and run the success callback.
+     */
+    breakLoop(): void;
+}
+import { WebRequest } from "./webRequest.js";
+import { Observable } from "./observable.js";
+import { GetDOMTextContent } from "./domManagement.js";
+import { IsWindowObjectExist } from "./domManagement.js";