@crawlee/core 4.0.0-beta.26 → 4.0.0-beta.261

package/system-info/ps-tree.js

@@ -0,0 +1,144 @@
+import { spawn } from 'node:child_process';
+import * as readline from 'node:readline';
+/**
+ * Returns a promise that resolves with an array of ProcessInfo objects representing
+ * the children of the given PID.
+ *
+ * @param pid - The PID (number or string) for which to list child processes.
+ * @param includeRoot - Optional flag. When true, include the process with the given PID if found.
+ *                      Defaults to false.
+ * @internal
+ */
+export async function psTree(pid, includeRoot = false) {
+    return new Promise((resolve, reject) => {
+        if (typeof pid === 'number') {
+            pid = pid.toString();
+        }
+        let processLister;
+        if (process.platform === 'win32') {
+            processLister = spawn('powershell', [
+                '-NoProfile',
+                '-Command',
+                'Get-CimInstance Win32_Process | Format-Table ProcessId,ParentProcessId,WorkingSetSize,Name',
+            ]);
+        }
+        else {
+            processLister = spawn('ps', ['-A', '-o', 'ppid,pid,stat,rss,comm']);
+        }
+        processLister.on('error', reject);
+        if (!processLister.stdout) {
+            reject(new Error('Child process stdout is null'));
+            return;
+        }
+        // Create a readline interface to process stdout line-by-line.
+        const rl = readline.createInterface({
+            input: processLister.stdout,
+        });
+        const rows = [];
+        let headers = null;
+        rl.on('line', (line) => {
+            const trimmed = line.trim();
+            if (trimmed === '') {
+                return; // Skip empty lines.
+            }
+            // When headers have been set, skip a dashed separator line.
+            const fields = trimmed.split(/\s+/);
+            if (headers !== null && fields.every((field) => /^-+$/.test(field))) {
+                return;
+            }
+            // The first nonempty line is assumed to be the header row.
+            if (!headers) {
+                headers = fields.map(normalizeHeader);
+                return;
+            }
+            // Copy the fields into an array to process.
+            const columns = fields.slice();
+            // Build the process row object.
+            const row = {};
+            const hdrs = headers.slice();
+            // For all headers except the last one, assign one column per header.
+            // The last header gets all remaining columns joined (in case the command name contains spaces).
+            for (const [index, header] of hdrs.entries()) {
+                let value;
+                if (index === hdrs.length - 1) {
+                    value = columns.join(' ');
+                }
+                else {
+                    value = columns.shift();
+                }
+                if (header === 'RSS') {
+                    row[header] = Number.parseInt(value, 10);
+                    if (process.platform !== 'win32') {
+                        // On Unix like systems, convert RSS (in KB) to bytes.
+                        row[header] *= 1024;
+                    }
+                }
+                else {
+                    row[header] = value;
+                }
+            }
+            // On Windows, add STAT with a null value for compatibility.
+            if (process.platform === 'win32') {
+                row.STAT = null;
+            }
+            rows.push(row);
+        });
+        rl.on('close', () => {
+            const parents = {};
+            const children = [];
+            // Seed with the provided PID.
+            parents[pid] = true;
+            // Build the list of child processes.
+            rows.forEach((proc) => {
+                // Skip the 'ps' or 'powershell' commands used by psTree to query the processes
+                if (proc.COMMAND === 'ps' || proc.COMMAND === 'powershell.exe') {
+                    return;
+                }
+                if (parents[proc.PPID]) {
+                    parents[proc.PID] = true;
+                    children.push(proc);
+                }
+                else if (includeRoot && pid === proc.PID) {
+                    children.push(proc);
+                }
+            });
+            resolve(children);
+        });
+        // Also listen for errors on the stdout stream.
+        processLister.stdout.on('error', reject);
+    });
+}
+/**
+ * Normalizes the header names so that the rest of the code can work uniformly.
+ *
+ * On non‑Windows systems, we only adjust "COMM" to "COMMAND" (e.g. on macOS).
+ * On Windows, the headers from Get-CimInstance + Format-Table are:
+ *
+ *    ProcessId, ParentProcessId, WorkingSetSize, Name
+ *
+ * which are mapped to:
+ *
+ *    PID, PPID, RSS, COMMAND
+ */
+function normalizeHeader(str) {
+    if (process.platform !== 'win32') {
+        // macOS may output "COMM" instead of "COMMAND"
+        if (str === 'COMM')
+            return 'COMMAND';
+        return str;
+    }
+    switch (str) {
+        case 'Name':
+            return 'COMMAND';
+        case 'ParentProcessId':
+            return 'PPID';
+        case 'ProcessId':
+            return 'PID';
+        case 'Status':
+            return 'STAT';
+        case 'WorkingSetSize':
+            return 'RSS';
+        default:
+            throw new Error(`Unknown process listing header: ${str}`);
+    }
+}

package/system-info/runtime.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns a `Promise` that resolves to true if the code is running in a Docker container.
+ */
+export declare function isDocker(forceReset?: boolean): Promise<boolean>;
+/**
+ * Detects if crawlee is running in a containerized environment.
+ */
+export declare function isContainerized(): Promise<boolean>;
+export declare function isLambda(): boolean;
+/**
+ * gets the cgroup version by checking for a file at /sys/fs/cgroup/memory
+ * @returns "V1" or "V2" for the version of cgroup or null if cgroup is not found.
+ */
+export declare function getCgroupsVersion(forceReset?: boolean): Promise<"V1" | "V2" | null>;

package/system-info/runtime.js

@@ -0,0 +1,80 @@
+import fs from 'node:fs/promises';
+let isDockerPromiseCache;
+async function createIsDockerPromise() {
+    const promise1 = fs
+        .stat('/.dockerenv')
+        .then(() => true)
+        .catch(() => false);
+    const promise2 = fs
+        .readFile('/proc/self/cgroup', 'utf8')
+        .then((content) => content.includes('docker'))
+        .catch(() => false);
+    const [result1, result2] = await Promise.all([promise1, promise2]);
+    return result1 || result2;
+}
+/**
+ * Returns a `Promise` that resolves to true if the code is running in a Docker container.
+ */
+export async function isDocker(forceReset) {
+    // Parameter forceReset is just internal for unit tests.
+    if (!isDockerPromiseCache || forceReset)
+        isDockerPromiseCache = createIsDockerPromise();
+    return isDockerPromiseCache;
+}
+let isContainerizedResult;
+/**
+ * Detects if crawlee is running in a containerized environment.
+ */
+export async function isContainerized() {
+    // Value is very unlikley to change. Cache the result after the first execution.
+    if (isContainerizedResult !== undefined) {
+        return isContainerizedResult;
+    }
+    // return false if running in aws lambda
+    if (isLambda()) {
+        isContainerizedResult = false;
+        return isContainerizedResult;
+    }
+    const dockerenvCheck = fs
+        .stat('/.dockerenv')
+        .then(() => true)
+        .catch(() => false);
+    const cgroupCheck = fs
+        .readFile('/proc/self/cgroup', 'utf8')
+        .then((content) => content.includes('docker'))
+        .catch(() => false);
+    const [dockerenvResult, cgroupResult] = await Promise.all([dockerenvCheck, cgroupCheck]);
+    isContainerizedResult = dockerenvResult || cgroupResult || !!process.env.KUBERNETES_SERVICE_HOST;
+    return isContainerizedResult;
+}
+export function isLambda() {
+    return !!process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE;
+}
+let cgroupsVersion;
+/**
+ * gets the cgroup version by checking for a file at /sys/fs/cgroup/memory
+ * @returns "V1" or "V2" for the version of cgroup or null if cgroup is not found.
+ */
+export async function getCgroupsVersion(forceReset) {
+    // Parameter forceReset is just internal for unit tests.
+    if (cgroupsVersion !== undefined && !forceReset) {
+        return cgroupsVersion;
+    }
+    try {
+        // If this directory does not exists, cgroups are not available
+        await fs.access('/sys/fs/cgroup/');
+    }
+    catch (e) {
+        cgroupsVersion = null;
+        return null;
+    }
+    cgroupsVersion = 'V1';
+    try {
+        // If this directory does not exists, assume the container is using cgroups V2
+        await fs.access('/sys/fs/cgroup/memory/');
+    }
+    catch (e) {
+        cgroupsVersion = 'V2';
+    }
+    return cgroupsVersion;
+}

package/typedefs.d.ts

@@ -1,10 +1,4 @@
 /** @ignore */
-export type Constructor<T = unknown> = new (...args: any[]) => T;
-/** @ignore */
-export type Awaitable<T> = T | PromiseLike<T>;
-/** @ignore */
 export declare function entries<T extends {}>(obj: T): [keyof T, T[keyof T]][];
 /** @ignore */
 export declare function keys<T extends {}>(obj: T): (keyof T)[];
-export { AllowedHttpMethods } from '@crawlee/types';
-//# sourceMappingURL=typedefs.d.ts.map

package/typedefs.js

@@ -6,4 +6,3 @@ export function entries(obj) {
 export function keys(obj) {
     return Object.keys(obj);
 }
-//# sourceMappingURL=typedefs.js.map

package/url.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The canonical form of a hostname: lower-case, punycode, and without the optional root dot.
+ *
+ * Pass both sides of a hostname comparison through this, so that a domain written as `háčky.cz` still matches the
+ * `xn--hky-ela4t.cz` that `URL` reports.
+ *
+ * @internal
+ */
+export declare function normalizeHostname(hostname: string): string;

package/url.js

@@ -0,0 +1,11 @@
+/**
+ * The canonical form of a hostname: lower-case, punycode, and without the optional root dot.
+ *
+ * Pass both sides of a hostname comparison through this, so that a domain written as `háčky.cz` still matches the
+ * `xn--hky-ela4t.cz` that `URL` reports.
+ *
+ * @internal
+ */
+export function normalizeHostname(hostname) {
+    return hostname.toLowerCase().replace(/\.$/, '');
+}

package/validators.d.ts

@@ -1,21 +1,26 @@
-import type { Dictionary } from '@crawlee/types';
+export { ArgumentValidationError } from '@crawlee/utils';
+export { parseArgument } from '@crawlee/utils/internal';
+export { schemas } from '@crawlee/utils/internal';
 /** @internal */
 export declare const validators: {
-    browserPage: (value: Dictionary) => {
-        validator: boolean;
-        message: (label: string) => string;
-    };
-    proxyConfiguration: (value: Dictionary) => {
-        validator: boolean;
-        message: (label: string) => string;
-    };
-    requestList: (value: Dictionary) => {
-        validator: boolean;
-        message: (label: string) => string;
-    };
-    requestQueue: (value: Dictionary) => {
-        validator: boolean;
-        message: (label: string) => string;
-    };
+// @ts-ignore optional peer dependency or compatibility with es2022
+    browserPage: import("zod").ZodType<import("@crawlee/types").Dictionary, unknown, import("zod/v4/core").$ZodTypeInternals<import("@crawlee/types").Dictionary, unknown>>;
+// @ts-ignore optional peer dependency or compatibility with es2022
+    proxyConfiguration: import("zod").ZodType<import("@crawlee/types").Dictionary, unknown, import("zod/v4/core").$ZodTypeInternals<import("@crawlee/types").Dictionary, unknown>>;
+// @ts-ignore optional peer dependency or compatibility with es2022
+    requestList: import("zod").ZodType<import("@crawlee/types").Dictionary, unknown, import("zod/v4/core").$ZodTypeInternals<import("@crawlee/types").Dictionary, unknown>>;
+// @ts-ignore optional peer dependency or compatibility with es2022
+    requestQueue: import("zod").ZodType<import("@crawlee/types").Dictionary, unknown, import("zod/v4/core").$ZodTypeInternals<import("@crawlee/types").Dictionary, unknown>>;
+// @ts-ignore optional peer dependency or compatibility with es2022
+    browserPool: import("zod").ZodType<import("@crawlee/types").Dictionary, unknown, import("zod/v4/core").$ZodTypeInternals<import("@crawlee/types").Dictionary, unknown>>;
+// @ts-ignore optional peer dependency or compatibility with es2022
+    sessionPool: import("zod").ZodType<import("@crawlee/types").Dictionary, unknown, import("zod/v4/core").$ZodTypeInternals<import("@crawlee/types").Dictionary, unknown>>;
+// @ts-ignore optional peer dependency or compatibility with es2022
+    requestManager: import("zod").ZodType<import("@crawlee/types").Dictionary, unknown, import("zod/v4/core").$ZodTypeInternals<import("@crawlee/types").Dictionary, unknown>>;
+// @ts-ignore optional peer dependency or compatibility with es2022
+    storageBackend: import("zod").ZodType<import("@crawlee/types").Dictionary, unknown, import("zod/v4/core").$ZodTypeInternals<import("@crawlee/types").Dictionary, unknown>>;
+// @ts-ignore optional peer dependency or compatibility with es2022
+    logger: import("zod").ZodType<import("@crawlee/types").Dictionary, unknown, import("zod/v4/core").$ZodTypeInternals<import("@crawlee/types").Dictionary, unknown>>;
+// @ts-ignore optional peer dependency or compatibility with es2022
+    httpClient: import("zod").ZodInstanceOf<import("@crawlee/http-client").BaseHttpClient>;
 };
-//# sourceMappingURL=validators.d.ts.map

package/validators.js

@@ -1,22 +1,18 @@
-import ow from 'ow';
+import { schemas } from '@crawlee/utils/internal';
+export { ArgumentValidationError } from '@crawlee/utils';
+export { parseArgument } from '@crawlee/utils/internal';
+export { schemas } from '@crawlee/utils/internal';
 /** @internal */
 export const validators = {
     // Naming it browser page for future proofing with Playwright
-    browserPage: (value) => ({
-        validator: ow.isValid(value, ow.object.hasKeys('goto', 'evaluate', '$', 'on')),
-        message: (label) => `Expected argument '${label}' to be a Puppeteer Page, got something else.`,
-    }),
-    proxyConfiguration: (value) => ({
-        validator: ow.isValid(value, ow.object.hasKeys('newUrl', 'newProxyInfo')),
-        message: (label) => `Expected argument '${label}' to be a ProxyConfiguration, got something else.`,
-    }),
-    requestList: (value) => ({
-        validator: ow.isValid(value, ow.object.hasKeys('fetchNextRequest', 'persistState')),
-        message: (label) => `Expected argument '${label}' to be a RequestList, got something else.`,
-    }),
-    requestQueue: (value) => ({
-        validator: ow.isValid(value, ow.object.hasKeys('fetchNextRequest', 'addRequest')),
-        message: (label) => `Expected argument '${label}' to be a RequestQueue, got something else.`,
-    }),
+    browserPage: schemas.objectWithKeys(['goto', 'evaluate', '$', 'on'], 'Expected a Puppeteer Page, got something else.'),
+    proxyConfiguration: schemas.objectWithKeys(['newProxyInfo'], "Expected an object implementing the IProxyConfiguration interface (missing 'newProxyInfo'), got something else."),
+    requestList: schemas.objectWithKeys(['fetchNextRequest', 'checkReadiness'], 'Expected a RequestList, got something else.'),
+    requestQueue: schemas.objectWithKeys(['fetchNextRequest', 'addRequest'], 'Expected a RequestQueue, got something else.'),
+    browserPool: schemas.objectWithKeys(['newPage', 'closePage', 'extractPageState', 'injectPageState'], "Expected an object implementing the IBrowserPool interface (missing one of 'newPage', 'closePage', 'extractPageState', 'injectPageState'), got something else."),
+    sessionPool: schemas.objectWithKeys(['getSession'], "Expected an object implementing the ISessionPool interface (missing 'getSession'), got something else."),
+    requestManager: schemas.objectWithKeys(['fetchNextRequest', 'addRequest', 'addRequestsBatched'], "Expected an object implementing the IRequestManager interface (missing one of 'fetchNextRequest', 'addRequest', 'addRequestsBatched'), got something else."),
+    storageBackend: schemas.objectWithKeys(['createDatasetBackend', 'createKeyValueStoreBackend', 'createRequestQueueBackend'], "Expected an object implementing the StorageBackend interface (missing one of 'createDatasetBackend', 'createKeyValueStoreBackend', 'createRequestQueueBackend'), got something else."),
+    logger: schemas.logger,
+    httpClient: schemas.httpClient,
 };
-//# sourceMappingURL=validators.js.map

package/autoscaling/autoscaled_pool.d.ts

@@ -1,300 +0,0 @@
-import type { Log } from '@apify/log';
-import { Configuration } from '../configuration.js';
-import type { SnapshotterOptions } from './snapshotter.js';
-import type { SystemInfo, SystemStatusOptions } from './system_status.js';
-export interface AutoscaledPoolOptions {
-    /**
-     * A function that performs an asynchronous resource-intensive task.
-     * The function must either be labeled `async` or return a promise.
-     */
-    runTaskFunction?: () => Promise<unknown>;
-    /**
-     * A function that indicates whether `runTaskFunction` should be called.
-     * This function is called every time there is free capacity for a new task and it should
-     * indicate whether it should start a new task or not by resolving to either `true` or `false`.
-     * Besides its obvious use, it is also useful for task throttling to save resources.
-     */
-    isTaskReadyFunction?: () => Promise<boolean>;
-    /**
-     * A function that is called only when there are no tasks to be processed.
-     * If it resolves to `true` then the pool's run finishes. Being called only
-     * when there are no tasks being processed means that as long as `isTaskReadyFunction()`
-     * keeps resolving to `true`, `isFinishedFunction()` will never be called.
-     * To abort a run, use the {@link AutoscaledPool.abort} method.
-     */
-    isFinishedFunction?: () => Promise<boolean>;
-    /**
-     * The minimum number of tasks running in parallel.
-     *
-     * *WARNING:* If you set this value too high with respect to the available system memory and CPU, your code might run extremely slow or crash.
-     * If you're not sure, just keep the default value and the concurrency will scale up automatically.
-     * @default 1
-     */
-    minConcurrency?: number;
-    /**
-     * The maximum number of tasks running in parallel.
-     * @default 200
-     */
-    maxConcurrency?: number;
-    /**
-     * The desired number of tasks that should be running parallel on the start of the pool,
-     * if there is a large enough supply of them.
-     * By default, it is `minConcurrency`.
-     */
-    desiredConcurrency?: number;
-    /**
-     * Minimum level of desired concurrency to reach before more scaling up is allowed.
-     * @default 0.90
-     */
-    desiredConcurrencyRatio?: number;
-    /**
-     * Defines the fractional amount of desired concurrency to be added with each scaling up.
-     * The minimum scaling step is one.
-     * @default 0.05
-     */
-    scaleUpStepRatio?: number;
-    /**
-     * Defines the amount of desired concurrency to be subtracted with each scaling down.
-     * The minimum scaling step is one.
-     * @default 0.05
-     */
-    scaleDownStepRatio?: number;
-    /**
-     * Indicates how often the pool should call the `runTaskFunction()` to start a new task, in seconds.
-     * This has no effect on starting new tasks immediately after a task completes.
-     * @default 0.5
-     */
-    maybeRunIntervalSecs?: number;
-    /**
-     * Specifies a period in which the instance logs its state, in seconds.
-     * Set to `null` to disable periodic logging.
-     * @default 60
-     */
-    loggingIntervalSecs?: number | null;
-    /**
-     * Defines in seconds how often the pool should attempt to adjust the desired concurrency
-     * based on the latest system status. Setting it lower than 1 might have a severe impact on performance.
-     * We suggest using a value from 5 to 20.
-     * @default 10
-     */
-    autoscaleIntervalSecs?: number;
-    /**
-     * Timeout in which the `runTaskFunction` needs to finish, given in seconds.
-     * @default 0
-     */
-    taskTimeoutSecs?: number;
-    /**
-     * Options to be passed down to the {@link Snapshotter} constructor. This is useful for fine-tuning
-     * the snapshot intervals and history.
-     */
-    snapshotterOptions?: SnapshotterOptions;
-    /**
-     * Options to be passed down to the {@link SystemStatus} constructor. This is useful for fine-tuning
-     * the system status reports. If a custom snapshotter is set in the options, it will be used
-     * by the pool.
-     */
-    systemStatusOptions?: SystemStatusOptions;
-    /**
-     * The maximum number of tasks per minute the pool can run.
-     * By default, this is set to `Infinity`, but you can pass any positive, non-zero integer.
-     */
-    maxTasksPerMinute?: number;
-    log?: Log;
-}
-/**
- * Manages a pool of asynchronous resource-intensive tasks that are executed in parallel.
- * The pool only starts new tasks if there is enough free CPU and memory available
- * and the Javascript event loop is not blocked.
- *
- * The information about the CPU and memory usage is obtained by the {@link Snapshotter} class,
- * which makes regular snapshots of system resources that may be either local
- * or from the Apify cloud infrastructure in case the process is running on the Apify platform.
- * Meaningful data gathered from these snapshots is provided to `AutoscaledPool` by the {@link SystemStatus} class.
- *
- * Before running the pool, you need to implement the following three functions:
- * {@link AutoscaledPoolOptions.runTaskFunction},
- * {@link AutoscaledPoolOptions.isTaskReadyFunction} and
- * {@link AutoscaledPoolOptions.isFinishedFunction}.
- *
- * The auto-scaled pool is started by calling the {@link AutoscaledPool.run} function.
- * The pool periodically queries the {@link AutoscaledPoolOptions.isTaskReadyFunction} function
- * for more tasks, managing optimal concurrency, until the function resolves to `false`. The pool then queries
- * the {@link AutoscaledPoolOptions.isFinishedFunction}. If it resolves to `true`, the run finishes after all running tasks complete.
- * If it resolves to `false`, it assumes there will be more tasks available later and keeps periodically querying for tasks.
- * If any of the tasks throws then the {@link AutoscaledPool.run} function rejects the promise with an error.
- *
- * The pool evaluates whether it should start a new task every time one of the tasks finishes
- * and also in the interval set by the `options.maybeRunIntervalSecs` parameter.
- *
- * **Example usage:**
- *
- * ```javascript
- * const pool = new AutoscaledPool({
- *     maxConcurrency: 50,
- *     runTaskFunction: async () => {
- *         // Run some resource-intensive asynchronous operation here.
- *     },
- *     isTaskReadyFunction: async () => {
- *         // Tell the pool whether more tasks are ready to be processed.
- *         // Return true or false
- *     },
- *     isFinishedFunction: async () => {
- *         // Tell the pool whether it should finish
- *         // or wait for more tasks to become available.
- *         // Return true or false
- *     }
- * });
- *
- * await pool.run();
- * ```
- * @category Scaling
- */
-export declare class AutoscaledPool {
-    private readonly config;
-    private readonly log;
-    private readonly desiredConcurrencyRatio;
-    private readonly scaleUpStepRatio;
-    private readonly scaleDownStepRatio;
-    private readonly maybeRunIntervalMillis;
-    private readonly loggingIntervalMillis;
-    private readonly autoscaleIntervalMillis;
-    private readonly taskTimeoutMillis;
-    private readonly runTaskFunction;
-    private readonly isFinishedFunction;
-    private readonly isTaskReadyFunction;
-    private readonly maxTasksPerMinute;
-    private _minConcurrency;
-    private _maxConcurrency;
-    private _desiredConcurrency;
-    private _currentConcurrency;
-    private isStopped;
-    private lastLoggingTime?;
-    private resolve;
-    private reject;
-    private snapshotter;
-    private systemStatus;
-    private autoscaleInterval;
-    private maybeRunInterval;
-    private queryingIsTaskReady;
-    private queryingIsFinished;
-    private tasksDonePerSecondInterval?;
-    private _tasksPerMinute;
-    constructor(options: AutoscaledPoolOptions, config?: Configuration);
-    /**
-     * Gets the minimum number of tasks running in parallel.
-     */
-    get minConcurrency(): number;
-    /**
-     * Sets the minimum number of tasks running in parallel.
-     *
-     * *WARNING:* If you set this value too high with respect to the available system memory and CPU, your code might run extremely slow or crash.
-     * If you're not sure, just keep the default value and the concurrency will scale up automatically.
-     */
-    set minConcurrency(value: number);
-    /**
-     * Gets the maximum number of tasks running in parallel.
-     */
-    get maxConcurrency(): number;
-    /**
-     * Sets the maximum number of tasks running in parallel.
-     */
-    set maxConcurrency(value: number);
-    /**
-     * Gets the desired concurrency for the pool,
-     * which is an estimated number of parallel tasks that the system can currently support.
-     */
-    get desiredConcurrency(): number;
-    /**
-     * Sets the desired concurrency for the pool, i.e. the number of tasks that should be running
-     * in parallel if there's large enough supply of tasks.
-     */
-    set desiredConcurrency(value: number);
-    /**
-     * Gets the number of parallel tasks currently running in the pool.
-     */
-    get currentConcurrency(): number;
-    /**
-     * Runs the auto-scaled pool. Returns a promise that gets resolved or rejected once
-     * all the tasks are finished or one of them fails.
-     */
-    run(): Promise<void>;
-    /**
-     * Aborts the run of the auto-scaled pool and destroys it. The promise returned from
-     * the {@link AutoscaledPool.run} function will immediately resolve, no more new tasks
-     * will be spawned and all running tasks will be left in their current state.
-     *
-     * Due to the nature of the tasks, auto-scaled pool cannot reliably guarantee abortion
-     * of all the running tasks, therefore, no abortion is attempted and some of the tasks
-     * may finish, while others may not. Essentially, auto-scaled pool doesn't care about
-     * their state after the invocation of `.abort()`, but that does not mean that some
-     * parts of their asynchronous chains of commands will not execute.
-     */
-    abort(): Promise<void>;
-    /**
-     * Prevents the auto-scaled pool from starting new tasks, but allows the running ones to finish
-     * (unlike abort, which terminates them). Used together with {@link AutoscaledPool.resume}
-     *
-     * The function's promise will resolve once all running tasks have completed and the pool
-     * is effectively idle. If the `timeoutSecs` argument is provided, the promise will reject
-     * with a timeout error after the `timeoutSecs` seconds.
-     *
-     * The promise returned from the {@link AutoscaledPool.run} function will not resolve
-     * when `.pause()` is invoked (unlike abort, which resolves it).
-     */
-    pause(timeoutSecs?: number): Promise<void>;
-    /**
-     * Resumes the operation of the autoscaled-pool by allowing more tasks to be run.
-     * Used together with {@link AutoscaledPool.pause}
-     *
-     * Tasks will automatically start running again in `options.maybeRunIntervalSecs`.
-     */
-    resume(): void;
-    /**
-     * Explicitly check the queue for new tasks. The AutoscaledPool checks the queue for new tasks periodically,
-     * every `maybeRunIntervalSecs` seconds. If you want to trigger the processing immediately, use this method.
-     */
-    notify(): Promise<void>;
-    /**
-     * Starts a new task
-     * if the number of running tasks (current concurrency) is lower than desired concurrency
-     * and the system is not currently overloaded
-     * and this.isTaskReadyFunction() returns true.
-     *
-     * It doesn't allow multiple concurrent runs of this method.
-     */
-    protected _maybeRunTask(intervalCallback?: () => void): Promise<void>;
-    /**
-     * Gets called every autoScaleIntervalSecs and evaluates the current system status.
-     * If the system IS NOT overloaded and the settings allow it, it scales up.
-     * If the system IS overloaded and the settings allow it, it scales down.
-     */
-    protected _autoscale(intervalCallback: () => void): void;
-    /**
-     * Scales the pool up by increasing
-     * the desired concurrency by the scaleUpStepRatio.
-     *
-     * @param systemStatus for logging
-     */
-    protected _scaleUp(systemStatus: SystemInfo): void;
-    /**
-     * Scales the pool down by decreasing
-     * the desired concurrency by the scaleDownStepRatio.
-     *
-     * @param systemStatus for logging
-     */
-    protected _scaleDown(systemStatus: SystemInfo): void;
-    /**
-     * If there are no running tasks and this.isFinishedFunction() returns true then closes
-     * the pool and resolves the pool's promise returned by the run() method.
-     *
-     * It doesn't allow multiple concurrent runs of this method.
-     */
-    protected _maybeFinish(): Promise<void>;
-    /**
-     * Cleans up resources.
-     */
-    protected _destroy(): Promise<void>;
-    protected _incrementTasksDonePerSecond(intervalCallback: () => void): void;
-    protected get _isOverMaxRequestLimit(): boolean;
-}
-//# sourceMappingURL=autoscaled_pool.d.ts.map