apify-client 3.0.0-beta.5 → 3.0.0-beta.50

package/dist/apify_client.js

@@ -1,7 +1,9 @@
 import { z } from 'zod';
 import { ACTOR_ENV_VARS, ME_USER_NAME_PLACEHOLDER } from '@apify/consts';
 import logger from '@apify/log';
-import { HttpClient } from './http_client.js';
+import { AxiosHttpClient } from './http_clients/axios.js';
+import { DEFAULT_MAX_RETRIES, DEFAULT_MIN_DELAY_BETWEEN_RETRIES_MILLIS, HttpClient, httpClientOptionsShape, } from './http_clients/base.js';
+import { compressionSchema } from './http_compressors/resolve.js';
 import { ActorClient } from './resource_clients/actor.js';
 import { ActorCollectionClient } from './resource_clients/actor_collection.js';
 import { BuildClient } from './resource_clients/build.js';
@@ -26,22 +28,40 @@ import { WebhookCollectionClient } from './resource_clients/webhook_collection.j
 import { WebhookDispatchClient } from './resource_clients/webhook_dispatch.js';
 import { WebhookDispatchCollectionClient } from './resource_clients/webhook_dispatch_collection.js';
 import { Statistics } from './statistics.js';
-import { parseArgument } from './utils.js';
-const DEFAULT_TIMEOUT_SECS = 360;
+import { DEFAULT_TIMEOUT_LONG_SECS, DEFAULT_TIMEOUT_MAX_SECS, DEFAULT_TIMEOUT_MEDIUM_SECS, DEFAULT_TIMEOUT_SHORT_SECS, } from './timeouts.js';
+import { getEnv, parseArgument } from './utils.js';
+const DEFAULT_API_URL = 'https://api.apify.com';
+const API_VERSION_PATH = '/v2';
+function toApiBaseUrl(url) {
+    const parsed = new URL(url);
+    const path = parsed.pathname.replace(/\/+$/, '');
+    parsed.pathname = path.endsWith(API_VERSION_PATH) ? path : `${path}${API_VERSION_PATH}`;
+    return parsed.href;
+}
 const clientOptionsSchema = z.strictObject({
-    baseUrl: z.string().default('https://api.apify.com'),
-    publicBaseUrl: z.string().default('https://api.apify.com'),
-    maxRetries: z.number().default(8),
-    minDelayBetweenRetriesMillis: z.number().default(500),
-    requestInterceptors: z.array(z.unknown()).default([]),
-    timeoutSecs: z.number().default(DEFAULT_TIMEOUT_SECS),
+    baseUrl: z.string().default(DEFAULT_API_URL),
+    compression: compressionSchema.default('brotli'),
+    headers: z.record(z.string(), z.string()).optional(),
+    publicBaseUrl: z.string().default(DEFAULT_API_URL),
+    maxRetries: httpClientOptionsShape.maxRetries.default(DEFAULT_MAX_RETRIES),
+    minDelayBetweenRetriesMillis: httpClientOptionsShape.minDelayBetweenRetriesMillis.default(DEFAULT_MIN_DELAY_BETWEEN_RETRIES_MILLIS),
+    timeoutShortSecs: httpClientOptionsShape.timeoutShortSecs.default(DEFAULT_TIMEOUT_SHORT_SECS),
+    timeoutMediumSecs: httpClientOptionsShape.timeoutMediumSecs.default(DEFAULT_TIMEOUT_MEDIUM_SECS),
+    timeoutLongSecs: httpClientOptionsShape.timeoutLongSecs.default(DEFAULT_TIMEOUT_LONG_SECS),
+    timeoutMaxSecs: httpClientOptionsShape.timeoutMaxSecs.default(DEFAULT_TIMEOUT_MAX_SECS),
     token: z.string().optional(),
     userAgentSuffix: z.union([z.string(), z.array(z.string())]).optional(),
 });
+const customHttpClientOptionsSchema = z.strictObject({
+    baseUrl: z.string().default(DEFAULT_API_URL),
+    publicBaseUrl: z.string().default(DEFAULT_API_URL),
+    token: z.string().optional(),
+    httpClient: z.instanceof(HttpClient),
+});
 const resourceIdSchema = z.string().min(1);
 const requestQueueOptionsSchema = z.strictObject({
     clientKey: z.string().min(1).optional(),
-    timeoutSecs: z.number().optional(),
+    timeoutSecs: z.number().positive().optional(),
 });
 /**
  * The official JavaScript client for the Apify API.
@@ -71,33 +91,98 @@ export class ApifyClient {
      */
     publicBaseUrl;
     token;
+    /**
+     * Statistics of the API calls made through the client. With a custom HTTP client, this is the client's own
+     * `stats` object, so it only reflects what that client records.
+     */
     stats;
     logger;
-    httpClient;
+    #httpClient;
+    /** Configuration of the default HTTP client, applied when no custom one is set. */
+    #httpClientOptions;
+    /**
+     * Creates a client that sends its requests through the built-in {@link AxiosHttpClient}, configured from
+     * `options`: the API token, retries, the timeout tiers, request compression and default headers. The HTTP
+     * client itself is created when {@link httpClient} is first read. To send the requests through a custom HTTP
+     * client, use {@link ApifyClient.withCustomHttpClient} instead.
+     *
+     * @param options - Configuration of the client and of its HTTP client.
+     * @throws {ArgumentValidationError} When an option is unknown or has an invalid value.
+     */
     constructor(options = {}) {
         const parsed = parseArgument(options, clientOptionsSchema, 'ApifyClientOptions');
-        const { baseUrl, publicBaseUrl, maxRetries, minDelayBetweenRetriesMillis, requestInterceptors, timeoutSecs, token, } = parsed;
-        const tempBaseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, baseUrl.length - 1) : baseUrl;
-        this.baseUrl = `${tempBaseUrl}/v2`;
-        const tempPublicBaseUrl = publicBaseUrl.endsWith('/')
-            ? publicBaseUrl.slice(0, publicBaseUrl.length - 1)
-            : publicBaseUrl;
-        this.publicBaseUrl = `${tempPublicBaseUrl}/v2`;
+        const { baseUrl, compression, headers, publicBaseUrl, maxRetries, minDelayBetweenRetriesMillis, timeoutShortSecs, timeoutMediumSecs, timeoutLongSecs, timeoutMaxSecs, token, } = parsed;
+        this.baseUrl = toApiBaseUrl(baseUrl);
+        this.publicBaseUrl = toApiBaseUrl(publicBaseUrl);
         this.token = token;
         this.stats = new Statistics();
         this.logger = logger.child({ prefix: 'ApifyClient' });
-        this.httpClient = new HttpClient({
-            apifyClientStats: this.stats,
+        this.#httpClientOptions = {
+            stats: this.stats,
             maxRetries,
             minDelayBetweenRetriesMillis,
-            requestInterceptors,
-            timeoutSecs,
+            compression,
+            headers,
+            timeoutShortSecs,
+            timeoutMediumSecs,
+            timeoutLongSecs,
+            timeoutMaxSecs,
             logger: this.logger,
             token: this.token,
             userAgentSuffix: parsed.userAgentSuffix,
-        });
+        };
+    }
+    /**
+     * Creates an `ApifyClient` that sends its requests through a custom HTTP client.
+     *
+     * The custom client owns its transport configuration: retries, timeouts, default headers and whatever its
+     * transport needs are set on the client itself. This is also how the built-in {@link AxiosHttpClient} is
+     * configured beyond what the constructor options offer, for example with axios request interceptors. The
+     * token is set as the client's `Authorization` header, unless the client already has one configured.
+     *
+     * @param options - The token, the API URLs and the HTTP client to use.
+     * @returns A client whose {@link httpClient} is the given one.
+     *
+     * @example
+     * ```javascript
+     * import { ApifyClient, HttpClient } from 'apify-client';
+     *
+     * class MyHttpClient extends HttpClient {
+     *     async sendRequest({ method, url, headers, body, timeoutMillis, stream, signal }) {
+     *         // Send the request with the HTTP library of your choice and return { status, headers, body }.
+     *     }
+     * }
+     *
+     * const client = ApifyClient.withCustomHttpClient({ token: 'my-token', httpClient: new MyHttpClient() });
+     * ```
+     */
+    static withCustomHttpClient(options) {
+        const { httpClient, ...rest } = parseArgument(options, customHttpClientOptionsSchema, 'ApifyClientCustomHttpClientOptions');
+        const client = new ApifyClient(rest);
+        client.httpClient = httpClient;
+        return client;
+    }
+    /**
+     * The HTTP client the requests go through: the custom one when set through
+     * {@link ApifyClient.withCustomHttpClient}, and otherwise an {@link AxiosHttpClient} configured from the
+     * constructor options, created on first access. Assigning a client applies {@link token} to it through
+     * {@link HttpClient.setDefaultAuthorization} and points {@link stats} at its statistics, so the counters keep
+     * tracking the calls the client actually makes. Resource clients hold on to the HTTP client they were created
+     * with, so assign before reaching for them. Assigning does not close the client it replaces. A default client
+     * that already sent a request keeps its keep-alive agents open until {@link HttpClient.close} is called on it,
+     * so close it yourself, or assign before the first request.
+     */
+    get httpClient() {
+        this.#httpClient ??= new AxiosHttpClient(this.#httpClientOptions);
+        return this.#httpClient;
+    }
+    set httpClient(httpClient) {
+        if (this.token)
+            httpClient.setDefaultAuthorization(this.token);
+        this.#httpClient = httpClient;
+        this.stats = httpClient.stats;
     }
-    _options() {
+    #subClientOptions() {
         return {
             baseUrl: this.baseUrl,
             publicBaseUrl: this.publicBaseUrl,
@@ -114,7 +199,7 @@ export class ApifyClient {
      * @see https://docs.apify.com/api/v2/acts-get
      */
     actors() {
-        return new ActorCollectionClient(this._options());
+        return new ActorCollectionClient(this.#subClientOptions());
     }
     /**
      * Returns a client for a specific Actor.
@@ -136,7 +221,7 @@ export class ApifyClient {
         parseArgument(id, resourceIdSchema);
         return new ActorClient({
             id,
-            ...this._options(),
+            ...this.#subClientOptions(),
         });
     }
     /**
@@ -148,7 +233,7 @@ export class ApifyClient {
      * @see https://docs.apify.com/api/v2/actor-builds-get
      */
     builds() {
-        return new BuildCollectionClient(this._options());
+        return new BuildCollectionClient(this.#subClientOptions());
     }
     /**
      * Returns a client for a specific Actor build.
@@ -163,7 +248,7 @@ export class ApifyClient {
         parseArgument(id, resourceIdSchema);
         return new BuildClient({
             id,
-            ...this._options(),
+            ...this.#subClientOptions(),
         });
     }
     /**
@@ -175,7 +260,7 @@ export class ApifyClient {
      * @see https://docs.apify.com/api/v2/datasets-get
      */
     datasets() {
-        return new DatasetCollectionClient(this._options());
+        return new DatasetCollectionClient(this.#subClientOptions());
     }
     /**
      * Returns a client for a specific dataset.
@@ -204,7 +289,7 @@ export class ApifyClient {
         parseArgument(id, resourceIdSchema);
         return new DatasetClient({
             id,
-            ...this._options(),
+            ...this.#subClientOptions(),
         });
     }
     /**
@@ -216,7 +301,7 @@ export class ApifyClient {
      * @see https://docs.apify.com/api/v2/key-value-stores-get
      */
     keyValueStores() {
-        return new KeyValueStoreCollectionClient(this._options());
+        return new KeyValueStoreCollectionClient(this.#subClientOptions());
     }
     /**
      * Returns a client for a specific key-value store.
@@ -241,7 +326,7 @@ export class ApifyClient {
         parseArgument(id, resourceIdSchema);
         return new KeyValueStoreClient({
             id,
-            ...this._options(),
+            ...this.#subClientOptions(),
         });
     }
     /**
@@ -255,7 +340,7 @@ export class ApifyClient {
         parseArgument(buildOrRunId, resourceIdSchema);
         return new LogClient({
             id: buildOrRunId,
-            ...this._options(),
+            ...this.#subClientOptions(),
         });
     }
     /**
@@ -267,7 +352,7 @@ export class ApifyClient {
      * @see https://docs.apify.com/api/v2/request-queues-get
      */
     requestQueues() {
-        return new RequestQueueCollectionClient(this._options());
+        return new RequestQueueCollectionClient(this.#subClientOptions());
     }
     /**
      * Returns a client for a specific request queue.
@@ -295,7 +380,7 @@ export class ApifyClient {
         const parsed = parseArgument(options, requestQueueOptionsSchema, 'RequestQueueUserOptions');
         const apiClientOptions = {
             id,
-            ...this._options(),
+            ...this.#subClientOptions(),
         };
         return new RequestQueueClient(apiClientOptions, parsed);
     }
@@ -309,7 +394,7 @@ export class ApifyClient {
      */
     runs() {
         return new RunCollectionClient({
-            ...this._options(),
+            ...this.#subClientOptions(),
             resourcePath: 'actor-runs',
         });
     }
@@ -336,7 +421,7 @@ export class ApifyClient {
         parseArgument(id, resourceIdSchema);
         return new RunClient({
             id,
-            ...this._options(),
+            ...this.#subClientOptions(),
         });
     }
     /**
@@ -348,7 +433,7 @@ export class ApifyClient {
      * @see https://docs.apify.com/api/v2/actor-tasks-get
      */
     tasks() {
-        return new TaskCollectionClient(this._options());
+        return new TaskCollectionClient(this.#subClientOptions());
     }
     /**
      * Returns a client for a specific Actor task.
@@ -369,7 +454,7 @@ export class ApifyClient {
         parseArgument(id, resourceIdSchema);
         return new TaskClient({
             id,
-            ...this._options(),
+            ...this.#subClientOptions(),
         });
     }
     /**
@@ -381,7 +466,7 @@ export class ApifyClient {
      * @see https://docs.apify.com/api/v2/schedules-get
      */
     schedules() {
-        return new ScheduleCollectionClient(this._options());
+        return new ScheduleCollectionClient(this.#subClientOptions());
     }
     /**
      * Returns a client for a specific schedule.
@@ -396,7 +481,7 @@ export class ApifyClient {
         parseArgument(id, resourceIdSchema);
         return new ScheduleClient({
             id,
-            ...this._options(),
+            ...this.#subClientOptions(),
         });
     }
     /**
@@ -412,7 +497,7 @@ export class ApifyClient {
         parseArgument(id, resourceIdSchema);
         return new UserClient({
             id,
-            ...this._options(),
+            ...this.#subClientOptions(),
         });
     }
     /**
@@ -424,7 +509,7 @@ export class ApifyClient {
      * @see https://docs.apify.com/api/v2/webhooks-get
      */
     webhooks() {
-        return new WebhookCollectionClient(this._options());
+        return new WebhookCollectionClient(this.#subClientOptions());
     }
     /**
      * Returns a client for a specific webhook.
@@ -439,7 +524,7 @@ export class ApifyClient {
         parseArgument(id, resourceIdSchema);
         return new WebhookClient({
             id,
-            ...this._options(),
+            ...this.#subClientOptions(),
         });
     }
     /**
@@ -451,7 +536,7 @@ export class ApifyClient {
      * @see https://docs.apify.com/api/v2/webhook-dispatches-get
      */
     webhookDispatches() {
-        return new WebhookDispatchCollectionClient(this._options());
+        return new WebhookDispatchCollectionClient(this.#subClientOptions());
     }
     /**
      * Returns a client for a specific webhook dispatch.
@@ -464,7 +549,7 @@ export class ApifyClient {
         parseArgument(id, resourceIdSchema);
         return new WebhookDispatchClient({
             id,
-            ...this._options(),
+            ...this.#subClientOptions(),
         });
     }
     /**
@@ -476,7 +561,7 @@ export class ApifyClient {
      * @see https://docs.apify.com/api/v2/store-get
      */
     store() {
-        return new StoreCollectionClient(this._options());
+        return new StoreCollectionClient(this.#subClientOptions());
     }
     /**
      * Sets a status message for the current Actor run.
@@ -490,7 +575,7 @@ export class ApifyClient {
      * @since Added in 2.7.0
      */
     async setStatusMessage(message, options) {
-        const runId = process.env[ACTOR_ENV_VARS.RUN_ID];
+        const runId = getEnv(ACTOR_ENV_VARS.RUN_ID);
         if (!runId) {
             throw new Error(`Environment variable ${ACTOR_ENV_VARS.RUN_ID} is not set!`);
         }

package/dist/base/api_client.d.ts

@@ -1,5 +1,5 @@
 import type { ApifyClient } from '../apify_client.js';
-import type { HttpClient } from '../http_client.js';
+import type { HttpClient } from '../http_clients/index.js';
 import type { PaginatedResponse, PaginationOptions } from '../utils.js';
 /** @private */
 export interface ApiClientOptions {
@@ -30,15 +30,15 @@ export declare abstract class ApiClient {
     httpClient: HttpClient;
     params?: Record<string, unknown>;
     constructor(options: ApiClientOptions);
-    protected _subResourceOptions<T>(moreOptions?: T): BaseOptions & T;
-    protected _url(path?: string | string[]): string;
-    protected _publicUrl(path?: string | string[]): string;
-    protected _params<T>(endpointParams?: T): Record<string, unknown>;
-    protected _toSafeId(id: string): string;
+    protected subResourceOptions<T>(moreOptions?: T): BaseOptions & T;
+    protected buildUrl(path?: string | string[]): string;
+    protected buildPublicUrl(path?: string | string[]): string;
+    protected buildParams<T>(endpointParams?: T): Record<string, unknown>;
+    protected toSafeId(id: string): string;
     /**
      * Returns async iterator to iterate through all items and Promise that can be awaited to get first page of results.
      */
-    protected _listPaginatedFromCallback<T extends PaginationOptions, Data, R extends PaginatedResponse<Data>>(getPaginatedList: (options?: T) => Promise<R>, options?: T): AsyncIterable<Data> & Promise<R>;
+    protected listPaginatedFromCallback<T extends PaginationOptions, Data, R extends PaginatedResponse<Data>>(getPaginatedList: (options?: T) => Promise<R>, options?: T): AsyncIterable<Data> & Promise<R>;
 }
 export interface BaseOptions {
     baseUrl: string;

package/dist/base/api_client.js

@@ -1,4 +1,4 @@
-import { toPath, toPathSegment } from '../utils.js';
+import { SCANNED_COUNT, toPath, toPathSegment } from '../utils.js';
 /** @private */
 export class ApiClient {
     id;
@@ -16,7 +16,7 @@ export class ApiClient {
     constructor(options) {
         const { baseUrl, publicBaseUrl, apifyClient, httpClient, resourcePath, id, params = {} } = options;
         this.id = id;
-        this.safeId = id && this._toSafeId(id);
+        this.safeId = id && this.toSafeId(id);
         this.baseUrl = baseUrl;
         this.publicBaseUrl = publicBaseUrl;
         this.resourcePath = resourcePath;
@@ -25,35 +25,35 @@ export class ApiClient {
         this.httpClient = httpClient;
         this.params = params;
     }
-    _subResourceOptions(moreOptions) {
+    subResourceOptions(moreOptions) {
         const baseOptions = {
-            baseUrl: this._url(),
+            baseUrl: this.buildUrl(),
             publicBaseUrl: this.publicBaseUrl,
             apifyClient: this.apifyClient,
             httpClient: this.httpClient,
-            params: this._params(),
+            params: this.buildParams(),
         };
         return { ...baseOptions, ...moreOptions };
     }
-    _url(path) {
+    buildUrl(path) {
         return path ? `${this.url}/${toPath(path)}` : this.url;
     }
-    _publicUrl(path) {
+    buildPublicUrl(path) {
         const url = this.id
             ? `${this.publicBaseUrl}/${this.resourcePath}/${toPathSegment(this.safeId)}`
             : `${this.publicBaseUrl}/${this.resourcePath}`;
         return path ? `${url}/${toPath(path)}` : url;
     }
-    _params(endpointParams) {
+    buildParams(endpointParams) {
         return { ...this.params, ...endpointParams };
     }
-    _toSafeId(id) {
+    toSafeId(id) {
         return id.replaceAll('/', '~');
     }
     /**
      * Returns async iterator to iterate through all items and Promise that can be awaited to get first page of results.
      */
-    _listPaginatedFromCallback(getPaginatedList, options = {}) {
+    listPaginatedFromCallback(getPaginatedList, options = {}) {
         const minForLimitParam = (a, b) => {
             // API treats 0 as undefined for limit parameter
             if (a === 0)
@@ -67,30 +67,42 @@ export class ApiClient {
             return Math.min(a, b);
         };
         // `chunkSize` only sizes this loop's requests; it is not an API parameter, so it must not reach
-        // `_params()` and the query string.
+        // `buildParams()` and the query string. The same goes for `timeoutSecs` and `signal`, which callers take out
+        // before calling this, since they also apply to every page request.
         const { chunkSize, ...listOptions } = options;
-        const paginatedListPromise = getPaginatedList({
-            ...listOptions,
-            limit: minForLimitParam(options.limit, chunkSize),
-        });
+        const firstPageLimit = minForLimitParam(options.limit, chunkSize);
+        const paginatedListPromise = getPaginatedList({ ...listOptions, limit: firstPageLimit });
+        // A page can return more or fewer items than the rows it scanned (see `SCANNED_COUNT`). The next offset and
+        // the stop condition follow the scanned rows: advancing by `items.length` would re-scan rows after a filter
+        // dropped some and skip rows after `unwind` multiplied them, and stopping at an empty page would end the
+        // iteration in front of rows a filter hid. The scanned number is derived from a dataset's item count, which
+        // lags a fresh push, so the larger of it and `items.length` is taken, capped at the rows the request asked for
+        // so that an unwound page does not advance past rows the next request would then never read.
+        const scannedRows = (page, requestedLimit) => {
+            const scanned = Math.max(page[SCANNED_COUNT] ?? 0, page.items.length);
+            return requestedLimit ? Math.min(scanned, requestedLimit) : scanned;
+        };
+        // `total` is not consulted, as it changes when the listed resource grows during the iteration.
         async function* asyncGenerator() {
             let currentPage = await paginatedListPromise;
             yield* currentPage.items;
-            const offset = options.offset ?? 0;
-            const limit = Math.min(options.limit || currentPage.total, currentPage.total);
-            let currentOffset = offset + currentPage.items.length;
-            let remainingItems = Math.min(currentPage.total - offset, limit) - currentPage.items.length;
-            while (currentPage.items.length > 0 && // Continue only if at least some items were returned in the last page.
-                remainingItems > 0) {
+            let pageScanned = scannedRows(currentPage, firstPageLimit);
+            let currentOffset = (options.offset ?? 0) + pageScanned;
+            let remainingItems = options.limit ? options.limit - pageScanned : undefined;
+            while (pageScanned > 0 && // Continue only if the last page scanned some rows.
+                (remainingItems === undefined || remainingItems > 0)) {
+                const requestedLimit = minForLimitParam(remainingItems, chunkSize);
                 const newOptions = {
                     ...listOptions,
-                    limit: minForLimitParam(remainingItems, chunkSize),
+                    limit: requestedLimit,
                     offset: currentOffset,
                 };
                 currentPage = await getPaginatedList(newOptions);
                 yield* currentPage.items;
-                currentOffset += currentPage.items.length;
-                remainingItems -= currentPage.items.length;
+                pageScanned = scannedRows(currentPage, requestedLimit);
+                currentOffset += pageScanned;
+                if (remainingItems !== undefined)
+                    remainingItems -= pageScanned;
             }
         }
         return Object.defineProperty(paginatedListPromise, Symbol.asyncIterator, {

package/dist/base/resource_client.d.ts

@@ -1,25 +1,38 @@
 import type { ACT_JOB_STATUSES } from '@apify/consts';
 import type { z } from 'zod';
+import type { Timeout, TimeoutOptions, TimeoutTier } from '../timeouts.js';
 import { ApiClient } from './api_client.js';
-export declare const SMALL_TIMEOUT_MILLIS: number;
-export declare const MEDIUM_TIMEOUT_MILLIS: number;
-export declare const DEFAULT_TIMEOUT_MILLIS: number;
 /**
  * Resource client.
  * @private
  */
 export declare class ResourceClient extends ApiClient {
-    protected _get<T, R>(schema: z.ZodType, options?: T, timeoutMillis?: number): Promise<R | undefined>;
-    protected _update<T, R>(schema: z.ZodType, newFields: T, timeoutMillis?: number): Promise<R>;
-    protected _delete(timeoutMillis?: number): Promise<void>;
+    /**
+     * Picks the timeout of a request that asks the API to hold its response with `waitForFinish`. The request
+     * gets the hold the caller asked for plus the round trip its tier allows, so the client does not abort a
+     * request while the API is still holding it - which for `start()` and `build()` would retry a call that
+     * creates a resource. An explicit per-call `timeoutSecs` is used as given.
+     */
+    protected timeoutForWaitForFinish(timeoutSecs: Timeout | undefined, tier: TimeoutTier, waitForFinishSecs: number | undefined): Timeout;
+    /**
+     * A 404 resolves to `undefined` only when the client names its resource by ID. A chained client without one, such
+     * as `run.dataset()`, throws it instead (see `catchNotFoundForResourceOrThrow()`).
+     */
+    protected getResource<T, R>(schema: z.ZodType, options: T, timeoutSecs: Timeout, signal?: AbortSignal): Promise<R | undefined>;
+    protected updateResource<T, R>(schema: z.ZodType, newFields: T, timeoutSecs: Timeout, signal?: AbortSignal): Promise<R>;
+    /**
+     * A 404 is swallowed, keeping the DELETE idempotent, only when the client names its resource by ID. A chained client
+     * without one throws it instead (see `catchNotFoundForResourceOrThrow()`).
+     */
+    protected deleteResource(timeoutSecs: Timeout, signal?: AbortSignal): Promise<void>;
     /**
      * This function is used in Build and Run endpoints so it's kept
      * here to stay DRY.
      */
-    protected _waitForFinish<R extends {
+    protected waitForJobFinish<R extends {
         status: (typeof ACT_JOB_STATUSES)[keyof typeof ACT_JOB_STATUSES];
     }>(schema: z.ZodType, options?: WaitForFinishOptions): Promise<R>;
 }
-export interface WaitForFinishOptions {
+export interface WaitForFinishOptions extends TimeoutOptions {
     waitSecs?: number;
 }