apify 2.3.1-beta.2 → 3.0.0-alpha.0

package/build/apify.d.ts

@@ -1,752 +0,0 @@
-/**
- * `Apify` class serves as an alternative approach to the static helpers exported from the package. It allows to pass configuration
- * that will be used on the instance methods. Environment variables will have precedence over this configuration.
- * See {@link Configuration} for details about what can be configured and what are the default values.
- *
- * @property {Configuration} config Configuration of this SDK instance (provided to its constructor). See {@link Configuration} for details.
- * @ignore
- */
-export class Apify {
-    constructor(options?: {});
-    config: Configuration;
-    _storageManagers: Map<any, any>;
-    /**
-     * Runs the main user function that performs the job of the actor
-     * and terminates the process when the user function finishes.
-     *
-     * **The `Apify.main()` function is optional** and is provided merely for your convenience.
-     * It is mainly useful when you're running your code as an actor on the [Apify platform](https://apify.com/actors).
-     * However, if you want to use Apify SDK tools directly inside your existing projects, e.g.
-     * running in an [Express](https://expressjs.com/) server, on
-     * [Google Cloud functions](https://cloud.google.com/functions)
-     * or [AWS Lambda](https://aws.amazon.com/lambda/), it's better to avoid
-     * it since the function terminates the main process when it finishes!
-     *
-     * The `Apify.main()` function performs the following actions:
-     *
-     * - When running on the Apify platform (i.e. <code>APIFY_IS_AT_HOME</code> environment variable is set),
-     *   it sets up a connection to listen for platform events.
-     *   For example, to get a notification about an imminent migration to another server.
-     *   See {@link Apify.events} for details.
-     * - It checks that either <code>APIFY_TOKEN</code> or <code>APIFY_LOCAL_STORAGE_DIR</code> environment variable
-     *   is defined. If not, the functions sets <code>APIFY_LOCAL_STORAGE_DIR</code> to <code>./apify_storage</code>
-     *   inside the current working directory. This is to simplify running code examples.
-     * - It invokes the user function passed as the <code>userFunc</code> parameter.
-     * - If the user function returned a promise, waits for it to resolve.
-     * - If the user function throws an exception or some other error is encountered,
-     *   prints error details to console so that they are stored to the log.
-     * - Exits the Node.js process, with zero exit code on success and non-zero on errors.
-     *
-     * The user function can be synchronous:
-     *
-     * ```javascript
-     * Apify.main(() => {
-     *   // My synchronous function that returns immediately
-     *   console.log('Hello world from actor!');
-     * });
-     * ```
-     *
-     * If the user function returns a promise, it is considered asynchronous:
-     * ```javascript
-     * const { requestAsBrowser } = require('some-request-library');
-     *
-     * Apify.main(() => {
-     *   // My asynchronous function that returns a promise
-     *   return request('http://www.example.com').then((html) => {
-     *     console.log(html);
-     *   });
-     * });
-     * ```
-     *
-     * To simplify your code, you can take advantage of the `async`/`await` keywords:
-     *
-     * ```javascript
-     * const request = require('some-request-library');
-     *
-     * Apify.main(async () => {
-     *   // My asynchronous function
-     *   const html = await request('http://www.example.com');
-     *   console.log(html);
-     * });
-     * ```
-     *
-     * @param {UserFunc} userFunc User function to be executed. If it returns a promise,
-     * the promise will be awaited. The user function is called with no arguments.
-     * @return {Promise<unknown>}
-     */
-    main(userFunc: UserFunc): Promise<unknown>;
-    /**
-     * Runs an actor on the Apify platform using the current user account (determined by the `APIFY_TOKEN` environment variable),
-     * waits for the actor to finish and fetches its output.
-     *
-     * By passing the `waitSecs` option you can reduce the maximum amount of time to wait for the run to finish.
-     * If the value is less than or equal to zero, the function returns immediately after the run is started.
-     *
-     * The result of the function is an {@link ActorRun} object
-     * that contains details about the actor run and its output (if any).
-     * If the actor run fails, the function throws the {@link ApifyCallError} exception.
-     *
-     * If you want to run an actor task rather than an actor, please use the
-     * {@link Apify#callTask} function instead.
-     *
-     * For more information about actors, read the
-     * [documentation](https://docs.apify.com/actor).
-     *
-     * **Example usage:**
-     *
-     * ```javascript
-     * const run = await Apify.call('apify/hello-world', { myInput: 123 });
-     * console.log(`Received message: ${run.output.body.message}`);
-     * ```
-     *
-     * Internally, the `call()` function invokes the
-     * [Run actor](https://apify.com/docs/api/v2#/reference/actors/run-collection/run-actor)
-     * and several other API endpoints to obtain the output.
-     *
-     * @param {string} actId
-     *  Allowed formats are `username/actor-name`, `userId/actor-name` or actor ID.
-     * @param {Object<string, *>} [input]
-     *  Input for the actor. If it is an object, it will be stringified to
-     *  JSON and its content type set to `application/json; charset=utf-8`.
-     *  Otherwise the `options.contentType` parameter must be provided.
-     * @param {object} [options]
-     *   Object with the settings below:
-     * @param {string} [options.contentType]
-     *  Content type for the `input`. If not specified,
-     *  `input` is expected to be an object that will be stringified to JSON and content type set to
-     *  `application/json; charset=utf-8`. If `options.contentType` is specified, then `input` must be a
-     *  `String` or `Buffer`.
-     * @param {string} [options.token]
-     *  User API token that is used to run the actor. By default, it is taken from the `APIFY_TOKEN` environment variable.
-     * @param {number} [options.memoryMbytes]
-     *  Memory in megabytes which will be allocated for the new actor run.
-     *  If not provided, the run uses memory of the default actor run configuration.
-     * @param {number} [options.timeoutSecs]
-     *  Timeout for the actor run in seconds. Zero value means there is no timeout.
-     *  If not provided, the run uses timeout of the default actor run configuration.
-     * @param {string} [options.build]
-     *  Tag or number of the actor build to run (e.g. `beta` or `1.2.345`).
-     *  If not provided, the run uses build tag or number from the default actor run configuration (typically `latest`).
-     * @param {number} [options.waitSecs]
-     *  Maximum time to wait for the actor run to finish, in seconds.
-     *  If the limit is reached, the returned promise is resolved to a run object that will have
-     *  status `READY` or `RUNNING` and it will not contain the actor run output.
-     *  If `waitSecs` is null or undefined, the function waits for the actor to finish (default behavior).
-     * @param {boolean} [options.fetchOutput=true]
-     *  If `false` then the function does not fetch output of the actor.
-     * @param {boolean} [options.disableBodyParser=false]
-     *  If `true` then the function will not attempt to parse the
-     *  actor's output and will return it in a raw `Buffer`.
-     * @param {Array<AdhocWebhook>} [options.webhooks] Specifies optional webhooks associated with the actor run, which can be used
-     *  to receive a notification e.g. when the actor finished or failed, see
-     *  [ad hook webhooks documentation](https://docs.apify.com/webhooks/ad-hoc-webhooks) for detailed description.
-     * @returns {Promise<ActorRun>}
-     * @throws {ApifyCallError} If the run did not succeed, e.g. if it failed or timed out.
-     */
-    call(actId: string, input?: {
-        [x: string]: any;
-    } | undefined, options?: {
-        contentType?: string | undefined;
-        token?: string | undefined;
-        memoryMbytes?: number | undefined;
-        timeoutSecs?: number | undefined;
-        build?: string | undefined;
-        waitSecs?: number | undefined;
-        fetchOutput?: boolean | undefined;
-        disableBodyParser?: boolean | undefined;
-        webhooks?: AdhocWebhook[] | undefined;
-    } | undefined): Promise<ActorRun>;
-    /**
-     * Runs an actor task on the Apify platform using the current user account (determined by the `APIFY_TOKEN` environment variable),
-     * waits for the task to finish and fetches its output.
-     *
-     * By passing the `waitSecs` option you can reduce the maximum amount of time to wait for the run to finish.
-     * If the value is less than or equal to zero, the function returns immediately after the run is started.
-     *
-     * The result of the function is an {@link ActorRun} object
-     * that contains details about the actor run and its output (if any).
-     * If the actor run failed, the function fails with {@link ApifyCallError} exception.
-     *
-     * Note that an actor task is a saved input configuration and options for an actor.
-     * If you want to run an actor directly rather than an actor task, please use the
-     * {@link Apify#call} function instead.
-     *
-     * For more information about actor tasks, read the [documentation](https://docs.apify.com/tasks).
-     *
-     * **Example usage:**
-     *
-     * ```javascript
-     * const run = await Apify.callTask('bob/some-task');
-     * console.log(`Received message: ${run.output.body.message}`);
-     * ```
-     *
-     * Internally, the `callTask()` function calls the
-     * [Run task](https://apify.com/docs/api/v2#/reference/actor-tasks/run-collection/run-task)
-     * and several other API endpoints to obtain the output.
-     *
-     * @param {string} taskId
-     *  Allowed formats are `username/task-name`, `userId/task-name` or task ID.
-     * @param {Object<string, *>} [input]
-     *  Input overrides for the actor task. If it is an object, it will be stringified to
-     *  JSON and its content type set to `application/json; charset=utf-8`.
-     *  Provided input will be merged with actor task input.
-     * @param {object} [options]
-     *   Object with the settings below:
-     * @param {string} [options.token]
-     *  User API token that is used to run the actor. By default, it is taken from the `APIFY_TOKEN` environment variable.
-     * @param {number} [options.memoryMbytes]
-     *  Memory in megabytes which will be allocated for the new actor task run.
-     *  If not provided, the run uses memory of the default actor run configuration.
-     * @param {number} [options.timeoutSecs]
-     *  Timeout for the actor task run in seconds. Zero value means there is no timeout.
-     *  If not provided, the run uses timeout of the default actor run configuration.
-     * @param {string} [options.build]
-     *  Tag or number of the actor build to run (e.g. `beta` or `1.2.345`).
-     *  If not provided, the run uses build tag or number from the default actor run configuration (typically `latest`).
-     * @param {number} [options.waitSecs]
-     *  Maximum time to wait for the actor task run to finish, in seconds.
-     *  If the limit is reached, the returned promise is resolved to a run object that will have
-     *  status `READY` or `RUNNING` and it will not contain the actor run output.
-     *  If `waitSecs` is null or undefined, the function waits for the actor task to finish (default behavior).
-     * @param {Array<AdhocWebhook>} [options.webhooks] Specifies optional webhooks associated with the actor run, which can be used
-     *  to receive a notification e.g. when the actor finished or failed, see
-     *  [ad hook webhooks documentation](https://docs.apify.com/webhooks/ad-hoc-webhooks) for detailed description.
-     * @returns {Promise<ActorRun>}
-     * @throws {ApifyCallError} If the run did not succeed, e.g. if it failed or timed out.
-     */
-    callTask(taskId: string, input?: {
-        [x: string]: any;
-    } | undefined, options?: {
-        token?: string | undefined;
-        memoryMbytes?: number | undefined;
-        timeoutSecs?: number | undefined;
-        build?: string | undefined;
-        waitSecs?: number | undefined;
-        webhooks?: AdhocWebhook[] | undefined;
-    } | undefined): Promise<ActorRun>;
-    /**
-     * Transforms this actor run to an actor run of a given actor. The system stops the current container and starts
-     * the new container instead. All the default storages are preserved and the new input is stored under the `INPUT-METAMORPH-1` key
-     * in the same default key-value store.
-     *
-     * @param {string} targetActorId
-     *  Either `username/actor-name` or actor ID of an actor to which we want to metamorph.
-     * @param {Object<string, *>} [input]
-     *  Input for the actor. If it is an object, it will be stringified to
-     *  JSON and its content type set to `application/json; charset=utf-8`.
-     *  Otherwise the `options.contentType` parameter must be provided.
-     * @param {object} [options]
-     *   Object with the settings below:
-     * @param {string} [options.contentType]
-     *  Content type for the `input`. If not specified,
-     *  `input` is expected to be an object that will be stringified to JSON and content type set to
-     *  `application/json; charset=utf-8`. If `options.contentType` is specified, then `input` must be a
-     *  `String` or `Buffer`.
-     * @param {string} [options.build]
-     *  Tag or number of the target actor build to metamorph into (e.g. `beta` or `1.2.345`).
-     *  If not provided, the run uses build tag or number from the default actor run configuration (typically `latest`).
-     * @returns {Promise<void>}
-     */
-    metamorph(targetActorId: string, input?: {
-        [x: string]: any;
-    } | undefined, options?: {
-        contentType?: string | undefined;
-        build?: string | undefined;
-    } | undefined): Promise<void>;
-    /**
-     *
-     * Creates an ad-hoc webhook for the current actor run, which lets you receive a notification when the actor run finished or failed.
-     * For more information about Apify actor webhooks, please see the [documentation](https://docs.apify.com/webhooks).
-     *
-     * Note that webhooks are only supported for actors running on the Apify platform.
-     * In local environment, the function will print a warning and have no effect.
-     *
-     * @param {object} options
-     * @param {EventTypes} options.eventTypes
-     *   Array of event types, which you can set for actor run, see
-     *   the [actor run events](https://docs.apify.com/webhooks/events#actor-run) in the Apify doc.
-     * @param {string}  options.requestUrl
-     *   URL which will be requested using HTTP POST request, when actor run will reach the set event type.
-     * @param {string} [options.payloadTemplate]
-     *   Payload template is a JSON-like string that describes the structure of the webhook POST request payload.
-     *   It uses JSON syntax, extended with a double curly braces syntax for injecting variables `{{variable}}`.
-     *   Those variables are resolved at the time of the webhook's dispatch, and a list of available variables with their descriptions
-     *   is available in the [Apify webhook documentation](https://docs.apify.com/webhooks).
-     *   If `payloadTemplate` is omitted, the default payload template is used
-     *   ([view docs](https://docs.apify.com/webhooks/actions#payload-template)).
-     * @param {string} [options.idempotencyKey]
-     *   Idempotency key enables you to ensure that a webhook will not be added multiple times in case of
-     *   an actor restart or other situation that would cause the `addWebhook()` function to be called again.
-     *   We suggest using the actor run ID as the idempotency key. You can get the run ID by calling
-     *   {@link Apify#getEnv} function.
-     * @return {Promise<WebhookRun|undefined>} The return value is the Webhook object.
-     * For more information, see the [Get webhook](https://apify.com/docs/api/v2#/reference/webhooks/webhook-object/get-webhook) API endpoint.
-     */
-    addWebhook(options: {
-        eventTypes: EventTypes;
-        requestUrl: string;
-        payloadTemplate?: string | undefined;
-        idempotencyKey?: string | undefined;
-    }): Promise<WebhookRun | undefined>;
-    /**
-     * Stores an object or an array of objects to the default {@link Dataset} of the current actor run.
-     *
-     * This is just a convenient shortcut for {@link Dataset#pushData}.
-     * For example, calling the following code:
-     * ```javascript
-     * await Apify.pushData({ myValue: 123 });
-     * ```
-     *
-     * is equivalent to:
-     * ```javascript
-     * const dataset = await Apify.openDataset();
-     * await dataset.pushData({ myValue: 123 });
-     * ```
-     *
-     * For more information, see {@link Apify#openDataset} and {@link Dataset#pushData}
-     *
-     * **IMPORTANT**: Make sure to use the `await` keyword when calling `pushData()`,
-     * otherwise the actor process might finish before the data are stored!
-     *
-     * @param {object} item Object or array of objects containing data to be stored in the default dataset.
-     * The objects must be serializable to JSON and the JSON representation of each object must be smaller than 9MB.
-     * @returns {Promise<void>}
-     */
-    pushData(item: object): Promise<void>;
-    /**
-     * Opens a dataset and returns a promise resolving to an instance of the {@link Dataset} class.
-     *
-     * Datasets are used to store structured data where each object stored has the same attributes,
-     * such as online store products or real estate offers.
-     * The actual data is stored either on the local filesystem or in the cloud.
-     *
-     * For more details and code examples, see the {@link Dataset} class.
-     *
-     * @param {string} [datasetIdOrName]
-     *   ID or name of the dataset to be opened. If `null` or `undefined`,
-     *   the function returns the default dataset associated with the actor run.
-     * @param {Object} [options]
-     * @param {boolean} [options.forceCloud=false]
-     *   If set to `true` then the function uses cloud storage usage even if the `APIFY_LOCAL_STORAGE_DIR`
-     *   environment variable is set. This way it is possible to combine local and cloud storage.
-     * @returns {Promise<Dataset>}
-     */
-    openDataset(datasetIdOrName?: string | undefined, options?: {
-        forceCloud?: boolean | undefined;
-    } | undefined): Promise<Dataset>;
-    /**
-     * Gets a value from the default {@link KeyValueStore} associated with the current actor run.
-     *
-     * This is just a convenient shortcut for {@link KeyValueStore#getValue}.
-     * For example, calling the following code:
-     * ```javascript
-     * const value = await Apify.getValue('my-key');
-     * ```
-     *
-     * is equivalent to:
-     * ```javascript
-     * const store = await Apify.openKeyValueStore();
-     * const value = await store.getValue('my-key');
-     * ```
-     *
-     * To store the value to the default key-value store, you can use the {@link Apify#setValue} function.
-     *
-     * For more information, see  {@link Apify#openKeyValueStore}
-     * and  {@link KeyValueStore#getValue}.
-     *
-     * @param {string} key
-     *   Unique record key.
-     * @returns {Promise<Object<string, *>|string|Buffer|null>}
-     *   Returns a promise that resolves to an object, string
-     *   or [`Buffer`](https://nodejs.org/api/buffer.html), depending
-     *   on the MIME content type of the record, or `null`
-     *   if the record is missing.
-     */
-    getValue(key: string): Promise<{
-        [x: string]: any;
-    } | string | Buffer | null>;
-    /**
-     * Stores or deletes a value in the default {@link KeyValueStore} associated with the current actor run.
-     *
-     * This is just a convenient shortcut for  {@link KeyValueStore#setValue}.
-     * For example, calling the following code:
-     * ```javascript
-     * await Apify.setValue('OUTPUT', { foo: "bar" });
-     * ```
-     *
-     * is equivalent to:
-     * ```javascript
-     * const store = await Apify.openKeyValueStore();
-     * await store.setValue('OUTPUT', { foo: "bar" });
-     * ```
-     *
-     * To get a value from the default key-value store, you can use the  {@link Apify#getValue} function.
-     *
-     * For more information, see  {@link Apify#openKeyValueStore}
-     * and  {@link KeyValueStore#getValue}.
-     *
-     * @param {string} key
-     *   Unique record key.
-     * @param {*} value
-     *   Record data, which can be one of the following values:
-     *    - If `null`, the record in the key-value store is deleted.
-     *    - If no `options.contentType` is specified, `value` can be any JavaScript object and it will be stringified to JSON.
-     *    - If `options.contentType` is set, `value` is taken as is and it must be a `String` or [`Buffer`](https://nodejs.org/api/buffer.html).
-     *   For any other value an error will be thrown.
-     * @param {object} [options]
-     * @param {string} [options.contentType]
-     *   Specifies a custom MIME content type of the record.
-     * @return {Promise<void>}
-     */
-    setValue(key: string, value: any, options?: {
-        contentType?: string | undefined;
-    } | undefined): Promise<void>;
-    /**
-     * Gets the actor input value from the default {@link KeyValueStore} associated with the current actor run.
-     *
-     * This is just a convenient shortcut for [`keyValueStore.getValue('INPUT')`](key-value-store#getvalue).
-     * For example, calling the following code:
-     * ```javascript
-     * const input = await Apify.getInput();
-     * ```
-     *
-     * is equivalent to:
-     * ```javascript
-     * const store = await Apify.openKeyValueStore();
-     * await store.getValue('INPUT');
-     * ```
-     *
-     * Note that the `getInput()` function does not cache the value read from the key-value store.
-     * If you need to use the input multiple times in your actor,
-     * it is far more efficient to read it once and store it locally.
-     *
-     * For more information, see  {@link Apify#openKeyValueStore}
-     * and {@link KeyValueStore#getValue}.
-     *
-     * @returns {Promise<Object<string, *>|string|Buffer|null>}
-     *   Returns a promise that resolves to an object, string
-     *   or [`Buffer`](https://nodejs.org/api/buffer.html), depending
-     *   on the MIME content type of the record, or `null`
-     *   if the record is missing.
-     */
-    getInput(): Promise<{
-        [x: string]: any;
-    } | string | Buffer | null>;
-    /**
-     * Opens a key-value store and returns a promise resolving to an instance of the {@link KeyValueStore} class.
-     *
-     * Key-value stores are used to store records or files, along with their MIME content type.
-     * The records are stored and retrieved using a unique key.
-     * The actual data is stored either on a local filesystem or in the Apify cloud.
-     *
-     * For more details and code examples, see the {@link KeyValueStore} class.
-     *
-     * @param {string} [storeIdOrName]
-     *   ID or name of the key-value store to be opened. If `null` or `undefined`,
-     *   the function returns the default key-value store associated with the actor run.
-     * @param {object} [options]
-     * @param {boolean} [options.forceCloud=false]
-     *   If set to `true` then the function uses cloud storage usage even if the `APIFY_LOCAL_STORAGE_DIR`
-     *   environment variable is set. This way it is possible to combine local and cloud storage.
-     * @returns {Promise<KeyValueStore>}
-     */
-    openKeyValueStore(storeIdOrName?: string | undefined, options?: {
-        forceCloud?: boolean | undefined;
-    } | undefined): Promise<KeyValueStore>;
-    /**
-     * Opens a request list and returns a promise resolving to an instance
-     * of the {@link RequestList} class that is already initialized.
-     *
-     * {@link RequestList} represents a list of URLs to crawl, which is always stored in memory.
-     * To enable picking up where left off after a process restart, the request list sources
-     * are persisted to the key-value store at initialization of the list. Then, while crawling,
-     * a small state object is regularly persisted to keep track of the crawling status.
-     *
-     * For more details and code examples, see the {@link RequestList} class.
-     *
-     * **Example usage:**
-     *
-     * ```javascript
-     * const sources = [
-     *     'https://www.example.com',
-     *     'https://www.google.com',
-     *     'https://www.bing.com'
-     * ];
-     *
-     * const requestList = await Apify.openRequestList('my-name', sources);
-     * ```
-     *
-     * @param {string|null} listName
-     *   Name of the request list to be opened. Setting a name enables the `RequestList`'s state to be persisted
-     *   in the key-value store. This is useful in case of a restart or migration. Since `RequestList` is only
-     *   stored in memory, a restart or migration wipes it clean. Setting a name will enable the `RequestList`'s
-     *   state to survive those situations and continue where it left off.
-     *
-     *   The name will be used as a prefix in key-value store, producing keys such as `NAME-REQUEST_LIST_STATE`
-     *   and `NAME-REQUEST_LIST_SOURCES`.
-     *
-     *   If `null`, the list will not be persisted and will only be stored in memory. Process restart
-     *   will then cause the list to be crawled again from the beginning. We suggest always using a name.
-     * @param {Array<RequestOptions|Request|string>} sources
-     *  An array of sources of URLs for the {@link RequestList}. It can be either an array of strings,
-     *  plain objects that define at least the `url` property, or an array of {@link Request} instances.
-     *
-     *  **IMPORTANT:** The `sources` array will be consumed (left empty) after {@link RequestList} initializes.
-     *  This is a measure to prevent memory leaks in situations when millions of sources are
-     *  added.
-     *
-     *  Additionally, the `requestsFromUrl` property may be used instead of `url`,
-     *  which will instruct {@link RequestList} to download the source URLs from a given remote location.
-     *  The URLs will be parsed from the received response. In this case you can limit the URLs
-     *  using `regex` parameter containing regular expression pattern for URLs to be included.
-     *
-     *  For details, see the {@link RequestListOptions.sources}
-     * @param {RequestListOptions} [options]
-     *   The {@link RequestList} options. Note that the `listName` parameter supersedes
-     *   the {@link RequestListOptions.persistStateKey} and {@link RequestListOptions.persistRequestsKey}
-     *   options and the `sources` parameter supersedes the {@link RequestListOptions.sources} option.
-     * @returns {Promise<RequestList>}
-     */
-    openRequestList(listName: string | null, sources: Array<RequestOptions | Request | string>, options?: any): Promise<RequestList>;
-    /**
-     * Opens a request queue and returns a promise resolving to an instance
-     * of the {@link RequestQueue} class.
-     *
-     * {@link RequestQueue} represents a queue of URLs to crawl, which is stored either on local filesystem or in the cloud.
-     * The queue is used for deep crawling of websites, where you start with several URLs and then
-     * recursively follow links to other pages. The data structure supports both breadth-first
-     * and depth-first crawling orders.
-     *
-     * For more details and code examples, see the {@link RequestQueue} class.
-     *
-     * @param {string} [queueIdOrName]
-     *   ID or name of the request queue to be opened. If `null` or `undefined`,
-     *   the function returns the default request queue associated with the actor run.
-     * @param {object} [options]
-     * @param {boolean} [options.forceCloud=false]
-     *   If set to `true` then the function uses cloud storage usage even if the `APIFY_LOCAL_STORAGE_DIR`
-     *   environment variable is set. This way it is possible to combine local and cloud storage.
-     * @returns {Promise<RequestQueue>}
-     */
-    openRequestQueue(queueIdOrName?: string | undefined, options?: {
-        forceCloud?: boolean | undefined;
-    } | undefined): Promise<RequestQueue>;
-    /**
-     * Opens a SessionPool and returns a promise resolving to an instance
-     * of the {@link SessionPool} class that is already initialized.
-     *
-     * For more details and code examples, see the {@link SessionPool} class.
-     *
-     * @param {SessionPoolOptions} sessionPoolOptions
-     * @return {Promise<SessionPool>}
-     */
-    openSessionPool(sessionPoolOptions: SessionPoolOptions): Promise<SessionPool>;
-    /**
-     * Creates a proxy configuration and returns a promise resolving to an instance
-     * of the {@link ProxyConfiguration} class that is already initialized.
-     *
-     * Configures connection to a proxy server with the provided options. Proxy servers are used to prevent target websites from blocking
-     * your crawlers based on IP address rate limits or blacklists. Setting proxy configuration in your crawlers automatically configures
-     * them to use the selected proxies for all connections.
-     *
-     * For more details and code examples, see the {@link ProxyConfiguration} class.
-     *
-     * ```javascript
-     *
-     * // Returns initialized proxy configuration class
-     * const proxyConfiguration = await Apify.createProxyConfiguration({
-     *     groups: ['GROUP1', 'GROUP2'] // List of Apify proxy groups
-     *     countryCode: 'US'
-     * });
-     *
-     * const crawler = new Apify.CheerioCrawler({
-     *   // ...
-     *   proxyConfiguration,
-     *   handlePageFunction: ({ proxyInfo }) => {
-     *       const usedProxyUrl = proxyInfo.url; // Getting the proxy URL
-     *   }
-     * })
-     *
-     * ```
-     *
-     * For compatibility with existing Actor Input UI (Input Schema), this function
-     * returns `undefined` when the following object is passed as `proxyConfigurationOptions`.
-     *
-     * ```
-     * { useApifyProxy: false }
-     * ```
-     *
-     * @param {ProxyConfigurationOptions} [proxyConfigurationOptions]
-     * @returns {Promise<ProxyConfiguration|undefined>}
-     */
-    createProxyConfiguration(proxyConfigurationOptions?: any): Promise<ProxyConfiguration | undefined>;
-    /**
-     * Returns a new {@link ApifyEnv} object which contains information parsed from all the `APIFY_XXX` environment variables.
-     *
-     * For the list of the `APIFY_XXX` environment variables, see
-     * [Actor documentation](https://docs.apify.com/actor/run#environment-variables).
-     * If some of the variables are not defined or are invalid, the corresponding value in the resulting object will be null.
-     * @returns {ApifyEnv}
-     */
-    getEnv(): ApifyEnv;
-    /**
-     * Returns a new instance of the Apify API client. The `ApifyClient` class is provided
-     * by the <a href="https://www.npmjs.com/package/apify-client" target="_blank">apify-client</a>
-     * NPM package, and it is automatically configured using the `APIFY_API_BASE_URL`, and `APIFY_TOKEN`
-     * environment variables. You can override the token via the available options. That's useful
-     * if you want to use the client as a different Apify user than the SDK internals are using.
-     *
-     * @param {object} [options]
-     * @param {string} [options.token]
-     * @param {string} [options.maxRetries]
-     * @param {string} [options.minDelayBetweenRetriesMillis]
-     * @return {ApifyClient}
-     */
-    newClient(options?: {
-        token?: string | undefined;
-        maxRetries?: string | undefined;
-        minDelayBetweenRetriesMillis?: string | undefined;
-    } | undefined): ApifyClient;
-    /**
-     * Returns `true` when code is running on Apify platform and `false` otherwise (for example locally).
-     *
-     * @returns {boolean}
-     */
-    isAtHome(): boolean;
-    get utils(): {
-        puppeteer: {
-// @ts-ignore optional peer dependency
-            injectFile: (page: import("puppeteer").Page, filePath: string, options?: {
-                surviveNavigations?: boolean | undefined;
-            } | undefined) => Promise<any>;
-// @ts-ignore optional peer dependency
-            injectJQuery: (page: import("puppeteer").Page) => Promise<any>;
-// @ts-ignore optional peer dependency
-            injectUnderscore: (page: import("puppeteer").Page) => Promise<any>;
-            enqueueLinksByClickingElements: typeof import("./enqueue_links/click_elements").enqueueLinksByClickingElements;
-// @ts-ignore optional peer dependency
-            blockRequests: (page: import("puppeteer").Page, options?: {
-                urlPatterns?: string[] | undefined;
-                extraUrlPatterns?: string[] | undefined;
-            } | undefined) => Promise<void>;
-            blockResources: (page: any, resourceTypes?: string[]) => Promise<void>;
-// @ts-ignore optional peer dependency
-            cacheResponses: (page: import("puppeteer").Page, cache: {
-                [x: string]: any;
-            }, responseUrlRules: (string | RegExp)[]) => Promise<void>;
-            compileScript: (scriptString: string, context?: {
-                [x: string]: any;
-            }) => import("./puppeteer_utils").CompiledScriptFunction;
-// @ts-ignore optional peer dependency
-            gotoExtended: (page: import("puppeteer").Page, request: Request, gotoOptions?: any) => Promise<any>;
-// @ts-ignore optional peer dependency
-            addInterceptRequestHandler: (page: import("puppeteer").Page, handler: import("./puppeteer_request_interception").InterceptHandler) => Promise<void>;
-// @ts-ignore optional peer dependency
-            removeInterceptRequestHandler: (page: import("puppeteer").Page, handler: import("./puppeteer_request_interception").InterceptHandler) => Promise<void>;
-// @ts-ignore optional peer dependency
-            infiniteScroll: (page: import("puppeteer").Page, options?: {
-                timeoutSecs?: number | undefined;
-                waitForSecs?: number | undefined;
-                scrollDownAndUp?: boolean | undefined;
-                buttonSelector?: string | undefined;
-                stopScrollCallback?: Function | undefined;
-            } | undefined) => Promise<void>;
-// @ts-ignore optional peer dependency
-            saveSnapshot: (page: import("puppeteer").Page, options?: {
-                key?: string | undefined;
-                screenshotQuality?: number | undefined;
-                saveScreenshot?: boolean | undefined;
-                saveHtml?: boolean | undefined;
-                keyValueStoreName?: string | null | undefined;
-            } | undefined) => Promise<void>;
-        };
-        playwright: {
-            gotoExtended: (page: import("playwright-core").Page, request: import("./request").default, gotoOptions?: import("./typedefs").DirectNavigationOptions | undefined) => Promise<import("playwright-core").Response | null>;
-        };
-        social: {
-            emailsFromText: (text: string) => string[];
-            emailsFromUrls: (urls: string[]) => string[];
-            phonesFromText: (text: string) => string[];
-            phonesFromUrls: (urls: string[]) => string[];
-            parseHandlesFromHtml: (html: string, data?: any) => import("./utils_social").SocialHandles;
-            EMAIL_REGEX: RegExp;
-            EMAIL_REGEX_GLOBAL: RegExp;
-            LINKEDIN_REGEX: RegExp;
-            LINKEDIN_REGEX_GLOBAL: RegExp;
-            INSTAGRAM_REGEX: RegExp;
-            INSTAGRAM_REGEX_GLOBAL: RegExp;
-            TWITTER_REGEX: RegExp;
-            TWITTER_REGEX_GLOBAL: RegExp;
-            FACEBOOK_REGEX: RegExp;
-            FACEBOOK_REGEX_GLOBAL: RegExp;
-            YOUTUBE_REGEX: RegExp;
-            YOUTUBE_REGEX_GLOBAL: RegExp;
-            TIKTOK_REGEX: RegExp;
-            TIKTOK_REGEX_GLOBAL: RegExp;
-            PINTEREST_REGEX: RegExp;
-            PINTEREST_REGEX_GLOBAL: RegExp;
-            DISCORD_REGEX: RegExp | undefined;
-            DISCORD_REGEX_GLOBAL: RegExp;
-        };
-        log: import("@apify/log/log").Log;
-        enqueueLinks: typeof enqueueLinks;
-        requestAsBrowser: (options?: import("./utils_request").RequestAsBrowserOptions) => Promise<import("./utils_request").RequestAsBrowserResult>;
-        isDocker: (forceReset: boolean) => Promise<boolean>;
-        sleep: (millis: number) => Promise<void>;
-        downloadListOfUrls: (options: {
-            url: string;
-            encoding?: string | undefined;
-            proxyUrl?: string | undefined;
-            urlRegExp?: RegExp | undefined;
-        }) => Promise<string[]>;
-        extractUrls: (options: {
-            string: string;
-            urlRegExp?: RegExp | undefined;
-        }) => string[];
-        htmlToText: (html: string | import("cheerio").CheerioAPI) => string;
-        URL_NO_COMMAS_REGEX: RegExp;
-        URL_WITH_COMMAS_REGEX: RegExp;
-        createRequestDebugInfo: (request: import("./request").default | RequestOptions, response?: any, additionalFields?: {
-            [x: string]: any;
-        } | undefined) => {
-            [x: string]: any;
-        };
-        waitForRunToFinish: (options: {
-            actorId: string;
-            runId: string;
-            waitSecs?: string | undefined;
-            token?: string | undefined;
-        }) => Promise<ActorRun>;
-        purgeLocalStorage: (folder?: string | undefined) => Promise<void>;
-    };
-    /**
-     * @param {Function} storageClass
-     * @return {StorageManager}
-     * @private
-     */
-    private _getStorageManager;
-    /**
-     * @param {ACT_JOB_STATUSES} status
-     * @return {boolean}
-     * @private
-     */
-    private _isRunUnsuccessful;
-}
-import { Configuration } from "./configuration";
-import { UserFunc } from "./actor";
-import { AdhocWebhook } from "./actor";
-import { ActorRun } from "./typedefs";
-import { EventTypes } from "./actor";
-import { WebhookRun } from "./actor";
-import { Dataset } from "./storages/dataset";
-import { KeyValueStore } from "./storages/key_value_store";
-import { RequestOptions } from "./request";
-import { RequestList } from "./request_list";
-import { RequestQueue } from "./storages/request_queue";
-import { SessionPoolOptions } from "./session_pool/session_pool";
-import { SessionPool } from "./session_pool/session_pool";
-import { ProxyConfiguration } from "./proxy_configuration";
-import { ApifyEnv } from "./actor";
-import { ApifyClient } from "apify-client/dist/apify_client";
-import { enqueueLinks } from "./enqueue_links/enqueue_links";
-//# sourceMappingURL=apify.d.ts.map