@crawlee/core 4.0.0-beta.99 → 4.0.0-rc.1

package/autoscaling/autoscaled_pool.d.ts

@@ -1,213 +0,0 @@
-import type { ConcurrencyConsumer, IConcurrencySystem } from './concurrency_system.js';
-import type { CrawleeLogger } from '../log.js';
-/**
- * The two predicates that steer a task loop: *is there work ready?* and *are we done?* These are the parts of the loop
- * a caller legitimately overrides, as opposed to the task itself (`runTaskFunction`), which the loop's driver owns.
- */
-export interface TaskLoopPredicates {
-    /**
-     * 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 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.
-     */
-    isFinishedFunction?: () => Promise<boolean>;
-}
-/** @internal */
-export interface AutoscaledPoolOptions extends TaskLoopPredicates {
-    /**
-     * The governor that decides whether there is free compute for one more task. Typically a
-     * {@link ConcurrencySystem}, but any {@link IConcurrencySystem} works. Share a single instance across
-     * multiple pools (and therefore multiple crawlers) to cap their *combined* concurrency against one budget.
-     *
-     * All concurrency/scaling/snapshotter configuration lives on the governor — the pool only owns the task loop and
-     * its cadence.
-     */
-    concurrencySystem: IConcurrencySystem;
-    /**
-     * Who this pool is, presented to the governor on every capacity query and booking so that a shared one can tell
-     * several pools apart. Worth naming meaningfully — a governor that allocates per consumer reports this `id`.
-     */
-    consumer: ConcurrencyConsumer;
-    /**
-     * A function that performs an asynchronous resource-intensive task.
-     * The function must either be labeled `async` or return a promise.
-     */
-    runTaskFunction?: () => Promise<unknown>;
-    /**
-     * 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;
-    /**
-     * Timeout in which the `runTaskFunction` needs to finish, given in seconds.
-     * @default 0
-     */
-    taskTimeoutSecs?: number;
-    log?: CrawleeLogger;
-}
-/**
- * Manages a pool of asynchronous resource-intensive tasks that are executed in parallel.
- * The pool only starts new tasks while its {@link IConcurrencySystem|concurrency system} reports free capacity —
- * that governor is what monitors CPU, memory and event loop load and autoscales the concurrency budget.
- *
- * Before running the pool, you need to implement the following three functions:
- * {@link AutoscaledPoolOptions.runTaskFunction|`runTaskFunction`},
- * {@link TaskLoopPredicates.isTaskReadyFunction|`isTaskReadyFunction`} and
- * {@link TaskLoopPredicates.isFinishedFunction|`isFinishedFunction`}.
- *
- * The auto-scaled pool is started by calling the {@link AutoscaledPool.run} function.
- * The pool periodically queries `isTaskReadyFunction` for more tasks, managing optimal concurrency, until the function
- * resolves to `false`. The pool then queries `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 concurrencySystem = new ConcurrencySystem({ maxConcurrency: 50 });
- * await concurrencySystem.start();
- *
- * const pool = new AutoscaledPool({
- *     concurrencySystem,
- *     consumer: { id: 'my-pool' },
- *     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
- *     }
- * });
- *
- * try {
- *     await pool.run();
- * } finally {
- *     await concurrencySystem.stop();
- * }
- * ```
- *
- * @internal
- */
-export declare class AutoscaledPool {
-    private readonly log;
-    private readonly maybeRunIntervalMillis;
-    private readonly taskTimeoutMillis;
-    private readonly runTaskFunction;
-    private readonly isFinishedFunction;
-    private readonly isTaskReadyFunction;
-    private readonly concurrencySystem;
-    private readonly consumer;
-    private isStopped;
-    private resolve;
-    private reject;
-    private maybeRunInterval;
-    private queryingIsTaskReady;
-    private queryingIsFinished;
-    /**
-     * This pool's *own* in-flight task count, as opposed to {@link AutoscaledPool.currentConcurrency}, which is the
-     * (possibly shared) governor's total. `pause()` and `maybeFinish()` care only about this pool draining.
-     */
-    private ownConcurrency;
-    constructor(options: AutoscaledPoolOptions);
-    /**
-     * The governor backing this pool, as supplied to the constructor — exposed as the read-only
-     * {@link IConcurrencySystem} contract.
-     *
-     * This and the two getters below are telemetry only: concurrency is configured and tuned on the concrete
-     * {@link ConcurrencySystem} its owner holds, never through the pool.
-     */
-    get system(): IConcurrencySystem;
-    /** The estimated number of parallel tasks the governor can currently support. */
-    get desiredConcurrency(): number;
-    /**
-     * The number of parallel tasks currently booked against the governor. When it is shared, this counts every
-     * borrowing pool's tasks, not just this one's.
-     */
-    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.
-     *
-     * Throws if the {@link IConcurrencySystem|concurrency system} it borrows was never started — the pool assumes
-     * a running governor and cannot start one it does not own.
-     */
-    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).
-     *
-     * > *NOTE:* Pausing the pool does not suspend the (possibly shared) {@link ConcurrencySystem} — its
-     * autoscaling and resource monitoring keep running, since other pools borrowing it may still be active. To silence
-     * it during a long pause, its owner can `stop()` and `start()` it again.
-     */
-    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.
-     */
-    private maybeRunTask;
-    /**
-     * 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.
-     */
-    private maybeFinish;
-    /**
-     * Cleans up resources.
-     */
-    private destroy;
-}

package/autoscaling/autoscaled_pool.js

@@ -1,378 +0,0 @@
-import ow from 'ow';
-import { addTimeoutToPromise } from '@apify/timeout';
-import { betterClearInterval, betterSetInterval } from '@apify/utilities';
-import { CriticalError } from '../errors.js';
-import { serviceLocator } from '../service_locator.js';
-/**
- * Manages a pool of asynchronous resource-intensive tasks that are executed in parallel.
- * The pool only starts new tasks while its {@link IConcurrencySystem|concurrency system} reports free capacity —
- * that governor is what monitors CPU, memory and event loop load and autoscales the concurrency budget.
- *
- * Before running the pool, you need to implement the following three functions:
- * {@link AutoscaledPoolOptions.runTaskFunction|`runTaskFunction`},
- * {@link TaskLoopPredicates.isTaskReadyFunction|`isTaskReadyFunction`} and
- * {@link TaskLoopPredicates.isFinishedFunction|`isFinishedFunction`}.
- *
- * The auto-scaled pool is started by calling the {@link AutoscaledPool.run} function.
- * The pool periodically queries `isTaskReadyFunction` for more tasks, managing optimal concurrency, until the function
- * resolves to `false`. The pool then queries `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 concurrencySystem = new ConcurrencySystem({ maxConcurrency: 50 });
- * await concurrencySystem.start();
- *
- * const pool = new AutoscaledPool({
- *     concurrencySystem,
- *     consumer: { id: 'my-pool' },
- *     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
- *     }
- * });
- *
- * try {
- *     await pool.run();
- * } finally {
- *     await concurrencySystem.stop();
- * }
- * ```
- *
- * @internal
- */
-export class AutoscaledPool {
-    log;
-    // Configurable properties.
-    maybeRunIntervalMillis;
-    taskTimeoutMillis;
-    runTaskFunction;
-    isFinishedFunction;
-    isTaskReadyFunction;
-    concurrencySystem;
-    consumer;
-    // Internal properties.
-    isStopped = false;
-    resolve = null;
-    reject = null;
-    maybeRunInterval;
-    queryingIsTaskReady;
-    queryingIsFinished;
-    /**
-     * This pool's *own* in-flight task count, as opposed to {@link AutoscaledPool.currentConcurrency}, which is the
-     * (possibly shared) governor's total. `pause()` and `maybeFinish()` care only about this pool draining.
-     */
-    ownConcurrency = 0;
-    constructor(options) {
-        ow(options, ow.object.exactShape({
-            runTaskFunction: ow.function,
-            isFinishedFunction: ow.function,
-            isTaskReadyFunction: ow.function,
-            maybeRunIntervalSecs: ow.optional.number.greaterThan(0),
-            taskTimeoutSecs: ow.optional.number.greaterThanOrEqual(0),
-            log: ow.optional.object,
-            concurrencySystem: ow.object,
-            consumer: ow.object.partialShape({ id: ow.string.nonEmpty }),
-        }));
-        const { runTaskFunction, isFinishedFunction, isTaskReadyFunction, maybeRunIntervalSecs = 0.5, taskTimeoutSecs = 0, log = serviceLocator.getLogger(), concurrencySystem, consumer, } = options;
-        this.log = log.child({ prefix: 'AutoscaledPool' });
-        // Configurable properties.
-        this.maybeRunIntervalMillis = maybeRunIntervalSecs * 1000;
-        this.taskTimeoutMillis = taskTimeoutSecs * 1000;
-        this.runTaskFunction = runTaskFunction;
-        this.isFinishedFunction = isFinishedFunction;
-        this.isTaskReadyFunction = isTaskReadyFunction;
-        this.concurrencySystem = concurrencySystem;
-        this.consumer = consumer;
-        // Internal properties.
-        this.isStopped = false;
-        this.resolve = null;
-        this.reject = null;
-        this.maybeRunTask = this.maybeRunTask.bind(this);
-    }
-    /**
-     * The governor backing this pool, as supplied to the constructor — exposed as the read-only
-     * {@link IConcurrencySystem} contract.
-     *
-     * This and the two getters below are telemetry only: concurrency is configured and tuned on the concrete
-     * {@link ConcurrencySystem} its owner holds, never through the pool.
-     */
-    get system() {
-        return this.concurrencySystem;
-    }
-    /** The estimated number of parallel tasks the governor can currently support. */
-    get desiredConcurrency() {
-        return this.concurrencySystem.desiredConcurrency;
-    }
-    /**
-     * The number of parallel tasks currently booked against the governor. When it is shared, this counts every
-     * borrowing pool's tasks, not just this one's.
-     */
-    get currentConcurrency() {
-        return this.concurrencySystem.currentConcurrency;
-    }
-    /**
-     * Runs the auto-scaled pool. Returns a promise that gets resolved or rejected once
-     * all the tasks are finished or one of them fails.
-     *
-     * Throws if the {@link IConcurrencySystem|concurrency system} it borrows was never started — the pool assumes
-     * a running governor and cannot start one it does not own.
-     */
-    async run() {
-        // Checked here, on an awaited path — the capacity queries inside the task loop run from intervals and
-        // `setImmediate`, where a throw would become an unhandled rejection and hang `run()` forever.
-        if (!this.concurrencySystem.isRunning) {
-            throw new CriticalError('The ConcurrencySystem this AutoscaledPool borrows has not been started, so system load would not be ' +
-                'monitored and the concurrency would never be adjusted. Whoever creates a ConcurrencySystem owns ' +
-                'its lifecycle: call `await concurrencySystem.start()` before running the pools or crawlers that ' +
-                'use it, and `await concurrencySystem.stop()` once they are all done.');
-        }
-        const poolPromise = new Promise((resolve, reject) => {
-            this.resolve = resolve;
-            this.reject = reject;
-        });
-        // This is here because if we scale down to let's say 1, then after each promise is finished
-        // this.maybeRunTask() doesn't trigger another one. So if that 1 instance gets stuck it results
-        // in the crawler getting stuck and even after scaling up it never triggers another promise.
-        this.maybeRunInterval = betterSetInterval(this.maybeRunTask, this.maybeRunIntervalMillis);
-        try {
-            await poolPromise;
-        }
-        finally {
-            // If resolve is null, the pool is already destroyed.
-            if (this.resolve)
-                await this.destroy();
-        }
-    }
-    /**
-     * 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.
-     */
-    async abort() {
-        this.isStopped = true;
-        if (this.resolve) {
-            this.resolve();
-            await this.destroy();
-        }
-    }
-    /**
-     * 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).
-     *
-     * > *NOTE:* Pausing the pool does not suspend the (possibly shared) {@link ConcurrencySystem} — its
-     * autoscaling and resource monitoring keep running, since other pools borrowing it may still be active. To silence
-     * it during a long pause, its owner can `stop()` and `start()` it again.
-     */
-    async pause(timeoutSecs) {
-        if (this.isStopped)
-            return;
-        this.isStopped = true;
-        await new Promise((resolve, reject) => {
-            let timeout;
-            let interval;
-            if (timeoutSecs) {
-                timeout = setTimeout(() => {
-                    // Clean up the polling interval to prevent it from leaking on timeout.
-                    clearInterval(interval);
-                    const err = new Error("The pool's running tasks did not finish" +
-                        `in ${timeoutSecs} secs after pool.pause() invocation.`);
-                    reject(err);
-                }, timeoutSecs);
-            }
-            interval = setInterval(() => {
-                if (this.ownConcurrency <= 0) {
-                    // Clean up timeout and interval to prevent process hanging.
-                    if (timeout)
-                        clearTimeout(timeout);
-                    clearInterval(interval);
-                    resolve();
-                }
-            }, this.maybeRunIntervalMillis);
-        });
-    }
-    /**
-     * 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() {
-        this.isStopped = false;
-    }
-    /**
-     * 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.
-     */
-    async notify() {
-        setImmediate(this.maybeRunTask);
-    }
-    /**
-     * 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.
-     */
-    async maybeRunTask(intervalCallback) {
-        this.log.perf('Attempting to run a task.');
-        // Check if the function was invoked by the maybeRunInterval and use an empty function if not.
-        const done = intervalCallback || (() => { });
-        // Prevent starting a new task if:
-        // - the pool is paused or aborted
-        if (this.isStopped) {
-            this.log.perf('Task will not run. AutoscaledPool is stopped.');
-            return done();
-        }
-        // - we are already querying for a task.
-        if (this.queryingIsTaskReady) {
-            this.log.perf('Task will not run. Waiting for a ready task.');
-            return done();
-        }
-        // - the budget has room for us.
-        if (!this.concurrencySystem.hasCapacityForTask(this.consumer)) {
-            done();
-            // A shared governor's budget can stay saturated by another pool indefinitely, so we still have to be able
-            // to notice that *this* pool has run out of work — `maybeFinish()` is the only thing that ever resolves
-            // `run()`. It no-ops while this pool has tasks of its own in flight, which is every case in which an
-            // unshared governor reports no capacity.
-            return this.maybeFinish();
-        }
-        // - a task is ready.
-        this.queryingIsTaskReady = true;
-        let isTaskReady;
-        try {
-            this.log.perf('Checking for ready tasks.');
-            isTaskReady = await this.isTaskReadyFunction();
-        }
-        catch (e) {
-            const err = e;
-            this.log.perf('Checking for ready tasks failed.');
-            // We might have already rejected this promise.
-            if (this.reject) {
-                // No need to log all concurrent errors.
-                this.log.exception(err, 'isTaskReadyFunction failed');
-                this.reject(err);
-            }
-        }
-        finally {
-            this.queryingIsTaskReady = false;
-        }
-        if (!isTaskReady) {
-            this.log.perf('Task will not run. No tasks are ready.');
-            done();
-            // No tasks could mean that we're finished with all tasks.
-            return this.maybeFinish();
-        }
-        // - the budget still has room. Re-checked atomically, because another pool sharing the governor may have taken
-        // the last free slot while we awaited `isTaskReadyFunction` above.
-        if (!this.concurrencySystem.tryRegisterTaskStart(this.consumer)) {
-            return done();
-        }
-        this.ownConcurrency++;
-        try {
-            // Everything's fine. Run task.
-            // Try to run next task to build up concurrency,
-            // but defer it so it doesn't create a cycle.
-            setImmediate(this.maybeRunTask);
-            // We need to restart interval here, so that it doesn't get blocked by a stalled task.
-            done();
-            // Execute the current task.
-            this.log.perf('Running a task.');
-            if (this.taskTimeoutMillis > 0) {
-                await addTimeoutToPromise(async () => this.runTaskFunction(), this.taskTimeoutMillis, `runTaskFunction timed out after ${this.taskTimeoutMillis / 1000} seconds.`);
-            }
-            else {
-                await this.runTaskFunction();
-            }
-            this.log.perf('Task finished.');
-            // Run task after the previous one finished. Only on success: a failed task rejects the pool, and
-            // nudging the loop afterwards could start work on an already destroyed pool.
-            setImmediate(this.maybeRunTask);
-        }
-        catch (e) {
-            const err = e;
-            this.log.perf('Running a task failed.');
-            // We might have already rejected this promise.
-            if (this.reject) {
-                // No need to log all concurrent errors.
-                if (
-                // avoid reprinting the same critical error multiple times, as it will be printed by Nodejs at the end anyway
-                !(e instanceof CriticalError)) {
-                    this.log.exception(err, 'runTaskFunction failed.');
-                }
-                this.reject(err);
-            }
-        }
-        finally {
-            this.concurrencySystem.registerTaskEnd(this.consumer);
-            this.ownConcurrency--;
-        }
-        return undefined;
-    }
-    /**
-     * 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.
-     */
-    async maybeFinish() {
-        if (this.queryingIsFinished)
-            return;
-        if (this.ownConcurrency > 0)
-            return;
-        this.queryingIsFinished = true;
-        try {
-            const isFinished = await this.isFinishedFunction();
-            if (isFinished && this.resolve)
-                this.resolve();
-        }
-        catch (e) {
-            const err = e;
-            if (this.reject) {
-                // No need to log all concurrent errors.
-                this.log.exception(err, 'isFinishedFunction failed.');
-                this.reject(err);
-            }
-        }
-        finally {
-            this.queryingIsFinished = false;
-        }
-    }
-    /**
-     * Cleans up resources.
-     */
-    async destroy() {
-        this.resolve = null;
-        this.reject = null;
-        betterClearInterval(this.maybeRunInterval);
-    }
-}

package/autoscaling/client_load_signal.d.ts

@@ -1,59 +0,0 @@
-import type { LoadSignal, LoadSignalStartContext, LoadSnapshot } from './load_signal.js';
-/**
- * A snapshot produced by the built-in client (rate-limit) signal.
- * @internal
- */
-export interface ClientSnapshot extends LoadSnapshot {
-    rateLimitErrorCount: number;
-}
-/**
- * Tuning for the built-in **client** (rate-limit) load signal, as accepted both by {@link ClientLoadSignal} and by
- * the {@link LoadSignalsOptions.client|`client`} shorthand on {@link LoadSignalsOptions}.
- */
-export interface ClientLoadSignalOptions {
-    /**
-     * Defines the interval of checking the current state of the remote API client, in seconds.
-     * @default 1
-     */
-    snapshotIntervalSecs?: number;
-    /**
-     * Defines the maximum number of new rate limit errors within the given interval.
-     * @default 3
-     */
-    maxErrors?: number;
-    /**
-     * Maximum ratio of overloaded snapshots in a sample before the client counts as overloaded.
-     * @default 0.3
-     */
-    overloadedRatio?: number;
-}
-/**
- * Periodically checks the storage backend for rate-limit errors (HTTP 429) and reports overload when the error delta
- * exceeds a threshold.
- *
- * Built by default; construct one yourself only to wrap or adapt it — see {@link LoadSignal}.
- *
- * Switch it off entirely ({@link LoadSignalsOptions.client|`client: false`}) if the storage backend reports no
- * rate-limit statistics, since it otherwise polls it every second to no purpose.
- *
- * @category Scaling
- */
-export declare class ClientLoadSignal implements LoadSignal {
-    readonly name = "clientInfo";
-    readonly overloadedRatio: number;
-    private readonly store;
-    private readonly intervalMillis;
-    private readonly maxErrors;
-    private interval?;
-    private client?;
-    constructor(options?: ClientLoadSignalOptions);
-    start(context: LoadSignalStartContext): Promise<void>;
-    stop(): Promise<void>;
-    getSample(sampleDurationMillis?: number): LoadSnapshot[];
-    /**
-     * Records one snapshot, overloaded when rate-limit errors grew by more than the configured limit since the
-     * previous one.
-     * @internal Also lets tests drive the measurement without waiting on a timer.
-     */
-    handle(intervalCallback: () => unknown): void;
-}