apify-client 3.0.0-beta.8 → 3.0.0-rc.0

package/dist/resource_clients/webhook.js

@@ -1,6 +1,7 @@
 import { ResourceClient } from '../base/resource_client.js';
 import * as schemas from '../schemas.js';
-import { anyObjectSchema, catchNotFoundOrThrow, parseArgument, parseResponse } from '../utils.js';
+import { timeoutOptionsSchema } from '../timeouts.js';
+import { anyObjectSchema, parseArgument, parseResponse } from '../utils.js';
 import { WebhookDispatchCollectionClient } from './webhook_dispatch_collection.js';
 /**
  * Client for managing a specific webhook.
@@ -43,51 +44,58 @@ export class WebhookClient extends ResourceClient {
     /**
      * Retrieves the webhook.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The webhook object, or `undefined` if it does not exist.
      * @see https://docs.apify.com/api/v2/webhook-get
      */
-    async get() {
-        return this._get(schemas.Webhook());
+    async get(options = {}) {
+        const { timeoutSecs = 'short', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.getResource(schemas.WebhookResource(), {}, timeoutSecs, signal);
     }
     /**
      * Updates the webhook with the specified fields.
      *
      * @param newFields - Fields to update.
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The updated webhook object.
      * @see https://docs.apify.com/api/v2/webhook-put
      */
-    async update(newFields) {
+    async update(newFields, options = {}) {
         parseArgument(newFields, anyObjectSchema);
-        return this._update(schemas.Webhook(), newFields);
+        const { timeoutSecs = 'short', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.updateResource(schemas.WebhookResource(), newFields, timeoutSecs, signal);
     }
     /**
      * Deletes the webhook.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @see https://docs.apify.com/api/v2/webhook-delete
      */
-    async delete() {
-        return this._delete();
+    async delete(options = {}) {
+        const { timeoutSecs = 'short', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.deleteResource(timeoutSecs, signal);
     }
     /**
      * Tests the webhook by dispatching a test event.
      *
-     * @returns The webhook dispatch object, or `undefined` if the test fails.
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'medium'`.
+     * @returns The webhook dispatch object.
      * @see https://docs.apify.com/api/v2/webhook-test-post
      */
-    async test() {
-        const request = {
-            url: this._url('test'),
+    async test(options = {}) {
+        const { timeoutSecs = 'medium', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        const response = await this.httpClient.call({
+            url: this.buildUrl('test'),
             method: 'POST',
-            params: this._params(),
-        };
-        try {
-            const response = await this.httpClient.call(request);
-            return parseResponse(response, schemas.WebhookDispatch());
-        }
-        catch (err) {
-            catchNotFoundOrThrow(err);
-        }
-        return undefined;
+            params: this.buildParams(),
+            timeoutSecs,
+            signal,
+        });
+        return parseResponse(response, schemas.WebhookDispatch());
     }
     /**
      * Returns a client for the dispatches of this webhook.
@@ -96,7 +104,7 @@ export class WebhookClient extends ResourceClient {
      * @see https://docs.apify.com/api/v2/webhook-webhook-dispatches-get
      */
     dispatches() {
-        return new WebhookDispatchCollectionClient(this._subResourceOptions({
+        return new WebhookDispatchCollectionClient(this.subResourceOptions({
             resourcePath: 'dispatches',
         }));
     }

package/dist/resource_clients/webhook_collection.d.ts

@@ -1,7 +1,8 @@
 import type { ApiClientSubResourceOptions } from '../base/api_client.js';
 import { ResourceCollectionClient } from '../base/resource_collection_client.js';
+import type { TimeoutOptions } from '../timeouts.js';
 import type { PaginatedIterator, PaginationOptions } from '../utils.js';
-import type { Webhook, WebhookUpdateData } from './webhook.js';
+import type { WebhookResource, WebhookUpdateData } from './webhook.js';
 /**
  * Client for managing the collection of Webhooks.
  *
@@ -47,19 +48,22 @@ export declare class WebhookCollectionClient extends ResourceCollectionClient {
      * ```
      *
      * @param options - Pagination and sorting options.
+     * @param options.timeoutSecs - Timeout for each API request. Default is `'medium'`.
      * @returns A paginated iterator of webhooks.
      * @see https://docs.apify.com/api/v2/webhooks-get
      */
-    list(options?: WebhookCollectionListOptions): PaginatedIterator<Omit<Webhook, 'payloadTemplate' | 'headersTemplate'>>;
+    list(options?: WebhookCollectionListOptions): PaginatedIterator<Omit<WebhookResource, 'payloadTemplate' | 'headersTemplate'>>;
     /**
      * Creates a new webhook.
      *
      * @param webhook - The webhook data.
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The created webhook object.
      * @see https://docs.apify.com/api/v2/webhooks-post
      */
-    create(webhook?: WebhookUpdateData): Promise<Webhook>;
+    create(webhook?: WebhookUpdateData, options?: TimeoutOptions): Promise<WebhookResource>;
 }
-export interface WebhookCollectionListOptions extends PaginationOptions {
+export interface WebhookCollectionListOptions extends PaginationOptions, TimeoutOptions {
     desc?: boolean;
 }

package/dist/resource_clients/webhook_collection.js

@@ -1,10 +1,12 @@
 import { z } from 'zod';
 import { ResourceCollectionClient } from '../base/resource_collection_client.js';
 import * as schemas from '../schemas.js';
+import { timeoutOptionsSchema, timeoutOptionsShape } from '../timeouts.js';
 import { anyObjectSchema, paginationOptionsShape, parseArgument } from '../utils.js';
 const listOptionsSchema = z.strictObject({
     ...paginationOptionsShape,
     desc: z.boolean().optional(),
+    ...timeoutOptionsShape,
 });
 const webhookCreateSchema = anyObjectSchema.optional();
 /**
@@ -57,22 +59,26 @@ export class WebhookCollectionClient extends ResourceCollectionClient {
      * ```
      *
      * @param options - Pagination and sorting options.
+     * @param options.timeoutSecs - Timeout for each API request. Default is `'medium'`.
      * @returns A paginated iterator of webhooks.
      * @see https://docs.apify.com/api/v2/webhooks-get
      */
     list(options = {}) {
         const parsed = parseArgument(options, listOptionsSchema, 'WebhookCollectionListOptions');
-        return this._listPaginated(schemas.ListOfWebhooks(), parsed);
+        return this.listResourcesPaginated(schemas.ListOfWebhooks(), parsed, 'medium');
     }
     /**
      * Creates a new webhook.
      *
      * @param webhook - The webhook data.
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The created webhook object.
      * @see https://docs.apify.com/api/v2/webhooks-post
      */
-    async create(webhook) {
+    async create(webhook, options = {}) {
         parseArgument(webhook, webhookCreateSchema);
-        return this._create(schemas.Webhook(), webhook);
+        const { timeoutSecs = 'short', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.createResource(schemas.WebhookResource(), webhook, timeoutSecs, signal);
     }
 }

package/dist/resource_clients/webhook_dispatch.d.ts

@@ -1,6 +1,7 @@
 import type { ApiClientSubResourceOptions } from '../base/api_client.js';
 import { ResourceClient } from '../base/resource_client.js';
 import type { WebhookDispatch } from '../models.js';
+import type { TimeoutOptions } from '../timeouts.js';
 export type { WebhookDispatch, WebhookDispatchCall, WebhookDispatchEventData, WebhookDispatchWebhookSummary, } from '../models.js';
 export { WebhookDispatchStatus } from '../models.js';
 /**
@@ -29,8 +30,10 @@ export declare class WebhookDispatchClient extends ResourceClient {
     /**
      * Retrieves the webhook dispatch.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The webhook dispatch object, or `undefined` if it does not exist.
      * @see https://docs.apify.com/api/v2/webhook-dispatch-get
      */
-    get(): Promise<WebhookDispatch | undefined>;
+    get(options?: TimeoutOptions): Promise<WebhookDispatch | undefined>;
 }

package/dist/resource_clients/webhook_dispatch.js

@@ -1,5 +1,7 @@
 import { ResourceClient } from '../base/resource_client.js';
 import * as schemas from '../schemas.js';
+import { timeoutOptionsSchema } from '../timeouts.js';
+import { parseArgument } from '../utils.js';
 export { WebhookDispatchStatus } from '../models.js';
 /**
  * Client for managing a specific webhook dispatch.
@@ -32,10 +34,13 @@ export class WebhookDispatchClient extends ResourceClient {
     /**
      * Retrieves the webhook dispatch.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The webhook dispatch object, or `undefined` if it does not exist.
      * @see https://docs.apify.com/api/v2/webhook-dispatch-get
      */
-    async get() {
-        return this._get(schemas.WebhookDispatch());
+    async get(options = {}) {
+        const { timeoutSecs = 'short', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.getResource(schemas.WebhookDispatch(), {}, timeoutSecs, signal);
     }
 }

package/dist/resource_clients/webhook_dispatch_collection.d.ts

@@ -1,5 +1,6 @@
 import type { ApiClientSubResourceOptions } from '../base/api_client.js';
 import { ResourceCollectionClient } from '../base/resource_collection_client.js';
+import type { TimeoutOptions } from '../timeouts.js';
 import type { PaginatedIterator, PaginationOptions } from '../utils.js';
 import type { WebhookDispatch } from './webhook_dispatch.js';
 /**
@@ -42,11 +43,12 @@ export declare class WebhookDispatchCollectionClient extends ResourceCollectionC
      * ```
      *
      * @param options - Pagination and sorting options.
+     * @param options.timeoutSecs - Timeout for each API request. Default is `'medium'`.
      * @returns A paginated iterator of webhook dispatches.
      * @see https://docs.apify.com/api/v2/webhook-dispatches-get
      */
     list(options?: WebhookDispatchCollectionListOptions): PaginatedIterator<WebhookDispatch>;
 }
-export interface WebhookDispatchCollectionListOptions extends PaginationOptions {
+export interface WebhookDispatchCollectionListOptions extends PaginationOptions, TimeoutOptions {
     desc?: boolean;
 }

package/dist/resource_clients/webhook_dispatch_collection.js

@@ -1,10 +1,12 @@
 import { z } from 'zod';
 import { ResourceCollectionClient } from '../base/resource_collection_client.js';
 import * as schemas from '../schemas.js';
+import { timeoutOptionsShape } from '../timeouts.js';
 import { paginationOptionsShape, parseArgument } from '../utils.js';
 const listOptionsSchema = z.strictObject({
     ...paginationOptionsShape,
     desc: z.boolean().optional(),
+    ...timeoutOptionsShape,
 });
 /**
  * Client for managing the collection of webhook dispatches.
@@ -51,11 +53,12 @@ export class WebhookDispatchCollectionClient extends ResourceCollectionClient {
      * ```
      *
      * @param options - Pagination and sorting options.
+     * @param options.timeoutSecs - Timeout for each API request. Default is `'medium'`.
      * @returns A paginated iterator of webhook dispatches.
      * @see https://docs.apify.com/api/v2/webhook-dispatches-get
      */
     list(options = {}) {
         const parsed = parseArgument(options, listOptionsSchema, 'WebhookDispatchCollectionListOptions');
-        return this._listPaginated(schemas.ListOfWebhookDispatches(), parsed);
+        return this.listResourcesPaginated(schemas.ListOfWebhookDispatches(), parsed, 'medium');
     }
 }

package/dist/runtime/node.d.ts

@@ -0,0 +1,6 @@
+import type { Runtime } from './types.js';
+/**
+ * The Node.js implementation of {@link Runtime}. Deno and Bun resolve the `node` condition too and
+ * provide the built-ins it uses.
+ */
+export declare const runtime: Runtime;

package/dist/runtime/node.js

@@ -0,0 +1,49 @@
+import os from 'node:os';
+import { brotliCompress, constants, gzip } from 'node:zlib';
+/**
+ * The Node.js implementation of {@link Runtime}. Deno and Bun resolve the `node` condition too and
+ * provide the built-ins it uses.
+ */
+export const runtime = {
+    isNode: true,
+    platform: `${os.platform()}; Node/${process.version}`,
+    async compress(data, { algorithm, quality }) {
+        return new Promise((resolve, reject) => {
+            const done = (error, result) => (error ? reject(error) : resolve(result));
+            if (algorithm === 'br') {
+                brotliCompress(data, { params: { [constants.BROTLI_PARAM_QUALITY]: quality } }, done);
+            }
+            else {
+                gzip(data, { level: quality }, done);
+            }
+        });
+    },
+    async createHttpAgents({ timeoutMillis }) {
+        // Loaded on the first request rather than with the client: the proxy support pulls in a sizeable
+        // dependency tree that a client which never sends a request should not pay for.
+        const { ProxyAgent } = await import('proxy-agent');
+        // We want to keep sockets alive for better performance.
+        const agentOptions = {
+            keepAlive: true,
+            // Timeout for inactive sockets
+            // Prevents socket leaks from idle connections
+            timeout: timeoutMillis,
+            // Keep alive timeout for free sockets (15 seconds)
+            // Node.js will close unused sockets after this period
+            keepAliveMsecs: 15_000,
+            // Maximum number of sockets per host
+            maxSockets: 256,
+            maxFreeSockets: 256,
+            // LIFO scheduling - reuse most recently used sockets for better performance
+            scheduling: 'lifo',
+        };
+        // ProxyAgent picks the proxy up from the environment variables and supports CONNECT tunneling.
+        const agent = new ProxyAgent(agentOptions);
+        // Disable Nagle's algorithm for lower latency
+        // This sends data immediately instead of buffering small packets
+        agent.on('socket', (socket) => {
+            socket.setNoDelay(true);
+        });
+        return { httpAgent: agent, httpsAgent: agent };
+    },
+};

package/dist/runtime/types.d.ts

@@ -0,0 +1,52 @@
+import type http from 'node:http';
+import type https from 'node:https';
+/**
+ * What to compress a request body with, as the built-in `HttpCompressor` implementations ask for it.
+ * @internal
+ */
+export interface CompressionOptions {
+    /** Algorithm to compress with, named by the `Content-Encoding` value it produces. */
+    algorithm: 'br' | 'gzip';
+    /** Compression level, in the range the algorithm defines. */
+    quality: number;
+}
+/**
+ * The agents axios's Node.js adapter sends requests through.
+ * @internal
+ */
+export interface HttpAgents {
+    httpAgent: http.Agent;
+    httpsAgent: https.Agent;
+}
+/**
+ * The runtime-specific part of the client. `#runtime` resolves to the Node.js implementation under the `node`
+ * condition and to the Web API one everywhere else (see the `imports` field of `package.json`), so a bundler
+ * targeting a browser or an edge runtime never sees the Node.js built-ins the Node.js one uses.
+ * @internal
+ */
+export interface Runtime {
+    /**
+     * Whether the Node.js implementation was selected, which the `node` condition settles when `#runtime` is
+     * resolved - so a Node.js application bundled for a browser or a neutral target reports `false`. Log
+     * streaming, the `stream` record option and request body compression are gated on it.
+     */
+    isNode: boolean;
+    /**
+     * The platform part of the `User-Agent` header, or `undefined` where the runtime does not let a client
+     * set that header (browsers).
+     */
+    platform: string | undefined;
+    /**
+     * Compresses a request body. The built-in compressors go through it, so a bundle for a browser or an edge
+     * runtime carries no `node:zlib`. Throws where the runtime has no compression, which the client never
+     * reaches, since it compresses only where {@link isNode} holds.
+     */
+    compress(data: Uint8Array, options: CompressionOptions): Promise<Buffer>;
+    /**
+     * Creates the agents axios's Node.js adapter sends requests through, or resolves to `undefined` where
+     * axios does not use agents.
+     */
+    createHttpAgents(options: {
+        timeoutMillis: number;
+    }): Promise<HttpAgents | undefined>;
+}

package/dist/runtime/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/web.d.ts

@@ -0,0 +1,5 @@
+import type { Runtime } from './types.js';
+/**
+ * The {@link Runtime} for browsers and edge runtimes, built on Web APIs only.
+ */
+export declare const runtime: Runtime;

package/dist/runtime/web.js

@@ -0,0 +1,18 @@
+/**
+ * The {@link Runtime} for browsers and edge runtimes, built on Web APIs only.
+ */
+export const runtime = {
+    isNode: false,
+    // Browsers do not let a page set the `User-Agent` header.
+    platform: undefined,
+    // No request compression: brotli and gzip have no Web API, and a `content-encoding` request header is not
+    // on the list of headers the Apify API allows in a cross-origin request, so a browser would fail the
+    // preflight. The client compresses in Node.js alone, so nothing reaches this.
+    async compress() {
+        throw new Error('Request body compression is only available in Node.js.');
+    },
+    // The XHR and fetch adapters of axios do not use agents.
+    async createHttpAgents() {
+        return undefined;
+    },
+};

package/dist/schemas.d.ts

@@ -6,7 +6,7 @@
  * documented deviation never sends a resource client reaching into `./generated` directly. An override
  * declared here shadows the generated export of the same name and takes the same form, a `lazySchema()` thunk
  * built on the generated schema it replaces. Every schema that embeds an overridden one has to be rebuilt on
- * top of it, and `spec_guards.ts` checks that each override still accepts what the specification describes,
+ * top of it, and `spec_guards.ts` checks that each override still produces what the specification describes,
  * so one cannot narrow by accident.
  *
  * Spec gaps need no override: the generated objects are loose, so a field the specification omits passes

package/dist/schemas.js

@@ -6,7 +6,7 @@
  * documented deviation never sends a resource client reaching into `./generated` directly. An override
  * declared here shadows the generated export of the same name and takes the same form, a `lazySchema()` thunk
  * built on the generated schema it replaces. Every schema that embeds an overridden one has to be rebuilt on
- * top of it, and `spec_guards.ts` checks that each override still accepts what the specification describes,
+ * top of it, and `spec_guards.ts` checks that each override still produces what the specification describes,
  * so one cannot narrow by accident.
  *
  * Spec gaps need no override: the generated objects are loose, so a field the specification omits passes

package/dist/statistics.d.ts

@@ -1,4 +1,5 @@
 export declare class Statistics {
+    #private;
     /**
      * Number of Apify client function calls
      */
@@ -13,10 +14,4 @@ export declare class Statistics {
      */
     rateLimitErrors: number[];
     addRateLimitError(attempt: number): void;
-    /**
-     * Removes the necessity to pre-initialize array with correct
-     * number of zeroes by dynamically filling the empty indexes
-     * when necessary.
-     */
-    private _fillBlanksWithZeroes;
 }

package/dist/statistics.js

@@ -20,7 +20,7 @@ export class Statistics {
         // attempt is never 0,
         // but we don't want index 0 empty
         const index = attempt - 1;
-        this._fillBlanksWithZeroes(index);
+        this.#fillBlanksWithZeroes(index);
         this.rateLimitErrors[index]++;
     }
     /**
@@ -28,7 +28,7 @@ export class Statistics {
      * number of zeroes by dynamically filling the empty indexes
      * when necessary.
      */
-    _fillBlanksWithZeroes(inclusiveIndex) {
+    #fillBlanksWithZeroes(inclusiveIndex) {
         if (this.rateLimitErrors.length <= inclusiveIndex) {
             for (let k = 0; k <= inclusiveIndex; k++) {
                 if (typeof this.rateLimitErrors[k] !== 'number') {

package/dist/timeouts.d.ts

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+/** Default duration of the `short` timeout tier, in seconds. */
+export declare const DEFAULT_TIMEOUT_SHORT_SECS = 5;
+/** Default duration of the `medium` timeout tier, in seconds. */
+export declare const DEFAULT_TIMEOUT_MEDIUM_SECS = 30;
+/** Default duration of the `long` timeout tier, in seconds. */
+export declare const DEFAULT_TIMEOUT_LONG_SECS = 360;
+/** Default cap on the timeout of a single request attempt, in seconds. */
+export declare const DEFAULT_TIMEOUT_MAX_SECS = 360;
+/**
+ * Preconfigured timeout tiers. Every client method picks the tier that fits the expected duration of its
+ * request: `short` for simple metadata reads and writes, `medium` for listing, batch and trigger operations,
+ * `long` for downloads, uploads and streaming. The duration of each tier is set on the {@link ApifyClient}
+ * constructor.
+ */
+export type TimeoutTier = 'short' | 'medium' | 'long';
+/**
+ * Timeout of a single API request.
+ *
+ * A tier name picks the duration configured for that tier on the {@link ApifyClient} constructor, a number is
+ * an exact duration in seconds, and `'noTimeout'` lets the request run for as long as it takes. A tier or an
+ * explicit duration above `timeoutMaxSecs` is capped at it, and the client logs a warning when that happens.
+ * The timeout applies to each attempt separately, and doubles with every retry up to the same cap.
+ *
+ * With `'noTimeout'` the client never aborts the request, so a connection that stalls is not retried either.
+ */
+export type Timeout = TimeoutTier | 'noTimeout' | number;
+/**
+ * Options shared by every method that sends a request to the API.
+ */
+export interface TimeoutOptions {
+    /**
+     * Timeout for the API request: a tier name (`'short'`, `'medium'`, `'long'`), a number of seconds, or
+     * `'noTimeout'`. Defaults to the tier the method is assigned, which its documentation names.
+     */
+    timeoutSecs?: Timeout;
+    /**
+     * Aborts the method. Once the signal aborts, the request in flight is ended, no retry or further poll
+     * follows, and the method rejects with the signal's `reason`.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Schema of {@link Timeout}, optional, for the methods that validate `timeoutSecs` on its own.
+ * @internal
+ */
+export declare const optionalTimeoutSchema: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+    long: "long";
+    medium: "medium";
+    noTimeout: "noTimeout";
+    short: "short";
+}>, z.ZodNumber]>>;
+/**
+ * Schema of {@link TimeoutOptions.signal}, for the methods that validate `signal` on its own.
+ * @internal
+ */
+export declare const optionalSignalSchema: z.ZodOptional<z.ZodInstanceOf<AbortSignal>>;
+/**
+ * Schema shape of {@link TimeoutOptions}, to spread into the option schema of every method that sends a
+ * request. One copy stops it drifting from the interface.
+ * @internal
+ */
+export declare const timeoutOptionsShape: {
+    timeoutSecs: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        long: "long";
+        medium: "medium";
+        noTimeout: "noTimeout";
+        short: "short";
+    }>, z.ZodNumber]>>;
+    signal: z.ZodOptional<z.ZodInstanceOf<AbortSignal>>;
+};
+/**
+ * Schema of {@link TimeoutOptions}, for the methods that take no other option.
+ * @internal
+ */
+export declare const timeoutOptionsSchema: z.ZodObject<{
+    timeoutSecs: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        long: "long";
+        medium: "medium";
+        noTimeout: "noTimeout";
+        short: "short";
+    }>, z.ZodNumber]>>;
+    signal: z.ZodOptional<z.ZodInstanceOf<AbortSignal>>;
+}, z.core.$strict>;

package/dist/timeouts.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+/** Default duration of the `short` timeout tier, in seconds. */
+export const DEFAULT_TIMEOUT_SHORT_SECS = 5;
+/** Default duration of the `medium` timeout tier, in seconds. */
+export const DEFAULT_TIMEOUT_MEDIUM_SECS = 30;
+/** Default duration of the `long` timeout tier, in seconds. */
+export const DEFAULT_TIMEOUT_LONG_SECS = 360;
+/** Default cap on the timeout of a single request attempt, in seconds. */
+export const DEFAULT_TIMEOUT_MAX_SECS = 360;
+/**
+ * Schema of {@link Timeout}. Zero is rejected on purpose - `'noTimeout'` is the explicit way to run without one.
+ */
+const timeoutSchema = z.union([z.enum(['short', 'medium', 'long', 'noTimeout']), z.number().positive()]);
+/**
+ * Schema of {@link Timeout}, optional, for the methods that validate `timeoutSecs` on its own.
+ * @internal
+ */
+export const optionalTimeoutSchema = timeoutSchema.optional();
+/**
+ * Schema of {@link TimeoutOptions.signal}, for the methods that validate `signal` on its own.
+ * @internal
+ */
+export const optionalSignalSchema = z.instanceof(AbortSignal).optional();
+/**
+ * Schema shape of {@link TimeoutOptions}, to spread into the option schema of every method that sends a
+ * request. One copy stops it drifting from the interface.
+ * @internal
+ */
+export const timeoutOptionsShape = {
+    timeoutSecs: optionalTimeoutSchema,
+    signal: optionalSignalSchema,
+};
+/**
+ * Schema of {@link TimeoutOptions}, for the methods that take no other option.
+ * @internal
+ */
+export const timeoutOptionsSchema = z.strictObject(timeoutOptionsShape);