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

package/dist/http_compressors/brotli.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { runtime } from '#runtime';
+import { parseArgument } from '../utils.js';
+/** Lowest valid brotli quality, the fastest with the least compression. */
+const MIN_QUALITY = 0;
+/** Highest valid brotli quality, the slowest with the best compression. */
+const MAX_QUALITY = 11;
+/** Middle of the range, where brotli already beats gzip at a comparable CPU cost. */
+const DEFAULT_QUALITY = 6;
+const optionsSchema = z.strictObject({
+    quality: z.int().min(MIN_QUALITY).max(MAX_QUALITY).default(DEFAULT_QUALITY),
+});
+/**
+ * Compresses request bodies using brotli.
+ *
+ * Built on the `node:zlib` module, so it works wherever the client runs on Node.js.
+ *
+ * @example
+ * ```javascript
+ * import { ApifyClient, BrotliHttpCompressor } from 'apify-client';
+ *
+ * const client = new ApifyClient({ token: 'my-token', compression: new BrotliHttpCompressor({ quality: 11 }) });
+ * ```
+ */
+export class BrotliHttpCompressor {
+    contentEncoding = 'br';
+    #quality;
+    /**
+     * @param options - Compressor options.
+     * @throws {ArgumentValidationError} If `quality` is out of the valid range.
+     */
+    constructor(options = {}) {
+        const { quality } = parseArgument(options, optionsSchema, 'BrotliHttpCompressorOptions');
+        this.#quality = quality;
+    }
+    async compress(data) {
+        return runtime.compress(data, { algorithm: 'br', quality: this.#quality });
+    }
+}

package/dist/http_compressors/gzip.d.ts

@@ -0,0 +1,33 @@
+import type { HttpCompressor } from './base.js';
+/**
+ * Compresses request bodies using gzip.
+ *
+ * Built on the `node:zlib` module, so it works wherever the client runs on Node.js.
+ *
+ * @example
+ * ```javascript
+ * import { ApifyClient, GzipHttpCompressor } from 'apify-client';
+ *
+ * const client = new ApifyClient({ token: 'my-token', compression: new GzipHttpCompressor({ quality: 1 }) });
+ * ```
+ */
+export declare class GzipHttpCompressor implements HttpCompressor {
+    #private;
+    readonly contentEncoding = "gzip";
+    /**
+     * @param options - Compressor options.
+     * @throws {ArgumentValidationError} If `quality` is out of the valid range.
+     */
+    constructor(options?: GzipHttpCompressorOptions);
+    compress(data: Buffer): Promise<Buffer>;
+}
+/**
+ * Options for {@link GzipHttpCompressor}.
+ */
+export interface GzipHttpCompressorOptions {
+    /**
+     * Compression level, from `1` (the fastest) to `9` (the best compression).
+     * @default 6
+     */
+    quality?: number;
+}

package/dist/http_compressors/gzip.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { runtime } from '#runtime';
+import { parseArgument } from '../utils.js';
+/** Lowest valid gzip quality, the fastest with the least compression. */
+const MIN_QUALITY = 1;
+/** Highest valid gzip quality, the slowest with the best compression. */
+const MAX_QUALITY = 9;
+/** zlib's own default. The levels above it roughly double the CPU cost for about a percent fewer bytes. */
+const DEFAULT_QUALITY = 6;
+const optionsSchema = z.strictObject({
+    quality: z.int().min(MIN_QUALITY).max(MAX_QUALITY).default(DEFAULT_QUALITY),
+});
+/**
+ * Compresses request bodies using gzip.
+ *
+ * Built on the `node:zlib` module, so it works wherever the client runs on Node.js.
+ *
+ * @example
+ * ```javascript
+ * import { ApifyClient, GzipHttpCompressor } from 'apify-client';
+ *
+ * const client = new ApifyClient({ token: 'my-token', compression: new GzipHttpCompressor({ quality: 1 }) });
+ * ```
+ */
+export class GzipHttpCompressor {
+    contentEncoding = 'gzip';
+    #quality;
+    /**
+     * @param options - Compressor options.
+     * @throws {ArgumentValidationError} If `quality` is out of the valid range.
+     */
+    constructor(options = {}) {
+        const { quality } = parseArgument(options, optionsSchema, 'GzipHttpCompressorOptions');
+        this.#quality = quality;
+    }
+    async compress(data) {
+        return runtime.compress(data, { algorithm: 'gzip', quality: this.#quality });
+    }
+}

package/dist/http_compressors/index.d.ts

@@ -0,0 +1,6 @@
+export type { HttpCompressor } from './base.js';
+export { BrotliHttpCompressor } from './brotli.js';
+export type { BrotliHttpCompressorOptions } from './brotli.js';
+export { GzipHttpCompressor } from './gzip.js';
+export type { GzipHttpCompressorOptions } from './gzip.js';
+export type { HttpCompressionAlgorithm } from './resolve.js';

package/dist/http_compressors/index.js

@@ -0,0 +1,2 @@
+export { BrotliHttpCompressor } from './brotli.js';
+export { GzipHttpCompressor } from './gzip.js';

package/dist/http_compressors/resolve.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import type { HttpCompressor } from './base.js';
+/**
+ * Compression algorithms the `compression` option of {@link ApifyClient} accepts by name. Each name selects the
+ * matching built-in compressor with its default quality: `'brotli'` a {@link BrotliHttpCompressor}, `'gzip'` a
+ * {@link GzipHttpCompressor}. The Apify API also accepts `deflate` and `identity`, which a custom
+ * {@link HttpCompressor} covers.
+ */
+export type HttpCompressionAlgorithm = 'brotli' | 'gzip';
+/**
+ * Schema of the `compression` option: an algorithm name or an {@link HttpCompressor}.
+ * @internal
+ */
+export declare const compressionSchema: z.ZodUnion<readonly [z.ZodEnum<{
+    brotli: "brotli";
+    gzip: "gzip";
+}>, z.ZodCustom<HttpCompressor, HttpCompressor>]>;
+/**
+ * Turns the `compression` option into a ready-to-use {@link HttpCompressor}: a name into the matching built-in
+ * compressor with its default quality, a compressor into itself.
+ * @internal
+ */
+export declare function resolveCompressor(compression: HttpCompressionAlgorithm | HttpCompressor): HttpCompressor;

package/dist/http_compressors/resolve.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { httpCompressorSchema } from './base.js';
+import { BrotliHttpCompressor } from './brotli.js';
+import { GzipHttpCompressor } from './gzip.js';
+/**
+ * Schema of the `compression` option: an algorithm name or an {@link HttpCompressor}.
+ * @internal
+ */
+export const compressionSchema = z.union([
+    z.enum(['brotli', 'gzip']),
+    httpCompressorSchema,
+]);
+/**
+ * Turns the `compression` option into a ready-to-use {@link HttpCompressor}: a name into the matching built-in
+ * compressor with its default quality, a compressor into itself.
+ * @internal
+ */
+export function resolveCompressor(compression) {
+    if (typeof compression !== 'string')
+        return compression;
+    switch (compression) {
+        case 'gzip':
+            return new GzipHttpCompressor();
+        case 'brotli':
+            return new BrotliHttpCompressor();
+    }
+}

package/dist/index.d.ts

@@ -29,5 +29,8 @@ export * from './resource_clients/webhook_dispatch_collection.js';
 export * from './apify_api_error.js';
 export { ArgumentValidationError } from '@apify/validations';
 export * from './response_validation_error.js';
-export { InvalidResponseBodyError } from './interceptors.js';
+export * from './invalid_response_body_error.js';
+export * from './http_clients/index.js';
+export * from './http_compressors/index.js';
 export type { PaginatedList, Dictionary } from './utils.js';
+export type { Timeout, TimeoutOptions, TimeoutTier } from './timeouts.js';

package/dist/index.js

@@ -29,4 +29,6 @@ export * from './resource_clients/webhook_dispatch_collection.js';
 export * from './apify_api_error.js';
 export { ArgumentValidationError } from '@apify/validations';
 export * from './response_validation_error.js';
-export { InvalidResponseBodyError } from './interceptors.js';
+export * from './invalid_response_body_error.js';
+export * from './http_clients/index.js';
+export * from './http_compressors/index.js';

package/dist/invalid_response_body_error.d.ts

@@ -0,0 +1,13 @@
+import type { HttpResponse } from './http_clients/base.js';
+/**
+ * Thrown when a response body does not parse as its content type claims, typically a JSON document cut short by a
+ * connection dropped mid-response. The client retries such requests, so the error surfaces once the retries are
+ * exhausted.
+ */
+export declare class InvalidResponseBodyError extends Error {
+    code: string;
+    /** The response whose body did not parse, with the body as the transport returned it. */
+    response: HttpResponse;
+    cause: Error;
+    constructor(response: HttpResponse, cause: Error);
+}

package/dist/invalid_response_body_error.js

@@ -0,0 +1,17 @@
+/**
+ * Thrown when a response body does not parse as its content type claims, typically a JSON document cut short by a
+ * connection dropped mid-response. The client retries such requests, so the error surfaces once the retries are
+ * exhausted.
+ */
+export class InvalidResponseBodyError extends Error {
+    code;
+    /** The response whose body did not parse, with the body as the transport returned it. */
+    response;
+    constructor(response, cause) {
+        super(`Response body could not be parsed.\nCause:${cause.message}`);
+        this.name = this.constructor.name;
+        this.code = 'invalid-response-body';
+        this.response = response;
+        this.cause = cause;
+    }
+}

package/dist/models.d.ts

@@ -48,6 +48,12 @@ export declare enum WebhookDispatchStatus {
     Succeeded = "SUCCEEDED",
     Failed = "FAILED"
 }
+/**
+ * Machine-readable type of an error returned by the Apify API, carried by `ApifyApiError.type`.
+ *
+ * Declared here, next to the other spec-derived types, and re-exported from `./apify_api_error`.
+ */
+export type ApifyApiErrorType = Schemas['ErrorType'];
 /**
  * Fields the API returns on a dataset that the OpenAPI spec does not describe yet.
  *
@@ -213,7 +219,7 @@ export interface ActorVersionRePointed {
     envVars?: ActorEnvironmentVariable[] | null;
 }
 export interface ActorVersionClientNarrowings {
-    sourceType: ActorSourceType;
+    sourceType: `${ActorSourceType}`;
 }
 /**
  * Fields every Actor version carries, whatever its source type.
@@ -222,26 +228,26 @@ export interface ActorVersionClientNarrowings {
  * keeps a union discriminated on `sourceType` instead, because that narrows the source location down
  * to the single field which applies -- so the four are dropped here and reinstated per variant.
  */
-export interface BaseActorVersion<SourceType extends ActorSourceType> extends Omit<GeneratedVersion, keyof ActorVersionClientNarrowings | keyof ActorVersionRePointed | ActorVersionSourceLocation>, ActorVersionRePointed {
+export interface BaseActorVersion<SourceType extends `${ActorSourceType}`> extends Omit<GeneratedVersion, keyof ActorVersionClientNarrowings | keyof ActorVersionRePointed | ActorVersionSourceLocation>, ActorVersionRePointed {
     sourceType: SourceType;
 }
 /**
  * An Actor version whose source code is stored on the Apify platform.
  * @since Added in 2.6.1
  */
-export interface ActorVersionSourceFiles extends BaseActorVersion<ActorSourceType.SourceFiles> {
+export interface ActorVersionSourceFiles extends BaseActorVersion<`${ActorSourceType.SourceFiles}`> {
     sourceFiles: (ActorVersionSourceFile | ActorVersionSourceFolder)[];
 }
 /** An Actor version built from a Git repository. */
-export interface ActorVersionGitRepo extends BaseActorVersion<ActorSourceType.GitRepo> {
+export interface ActorVersionGitRepo extends BaseActorVersion<`${ActorSourceType.GitRepo}`> {
     gitRepoUrl: NonNullable<GeneratedVersion['gitRepoUrl']>;
 }
 /** An Actor version built from a downloadable tarball or ZIP archive. */
-export interface ActorVersionTarball extends BaseActorVersion<ActorSourceType.Tarball> {
+export interface ActorVersionTarball extends BaseActorVersion<`${ActorSourceType.Tarball}`> {
     tarballUrl: NonNullable<GeneratedVersion['tarballUrl']>;
 }
 /** An Actor version built from a GitHub Gist. */
-export interface ActorVersionGitHubGist extends BaseActorVersion<ActorSourceType.GitHubGist> {
+export interface ActorVersionGitHubGist extends BaseActorVersion<`${ActorSourceType.GitHubGist}`> {
     gitHubGistUrl: NonNullable<GeneratedVersion['gitHubGistUrl']>;
 }
 /**
@@ -250,7 +256,7 @@ export interface ActorVersionGitHubGist extends BaseActorVersion<ActorSourceType
  * It carries no source location of its own, so it adds nothing to `BaseActorVersion`; the variant
  * exists so that `SOURCE_CODE`, which both the spec and `@apify/consts` list, is representable.
  */
-export interface ActorVersionSourceCode extends BaseActorVersion<ActorSourceType.SourceCode> {
+export interface ActorVersionSourceCode extends BaseActorVersion<`${ActorSourceType.SourceCode}`> {
 }
 /** A version of an Actor, discriminated on where its source code comes from. */
 export type ActorVersion = ActorVersionSourceFiles | ActorVersionGitRepo | ActorVersionTarball | ActorVersionGitHubGist | ActorVersionSourceCode;
@@ -583,14 +589,6 @@ export interface TaskOptions extends GeneratedTaskOptions {
  */
 export interface TaskPublicConfig extends GeneratedTaskPublicConfig {
 }
-/**
- * Fields the API returns on a task that the OpenAPI spec does not describe yet.
- *
- * TODO: Remove once the spec covers it.
- */
-export interface TaskSpecGaps {
-    description?: string;
-}
 export interface TaskRePointed {
     stats?: TaskStats | null;
     options?: TaskOptions | null;
@@ -604,7 +602,7 @@ export interface TaskRePointed {
  * Tasks are saved Actor configurations with input and settings that can be executed
  * repeatedly without having to specify the full input each time.
  */
-export interface Task extends Omit<Schemas['Task'], keyof TaskRePointed>, TaskRePointed, TaskSpecGaps {
+export interface Task extends Omit<Schemas['Task'], keyof TaskRePointed>, TaskRePointed {
 }
 export interface TaskListRePointed {
     stats?: TaskStats | null;
@@ -612,7 +610,7 @@ export interface TaskListRePointed {
 /**
  * Fields the API returns on a listed task that the OpenAPI spec does not describe yet.
  *
- * `description` is deliberately not here, although `TaskSpecGaps` claims it on the full resource: the
+ * `description` is deliberately not here, although the spec has it on the full `Task` resource: the
  * list endpoint publishes a smaller set of fields, and that is one of the fields it leaves out.
  *
  * TODO: Remove once the spec covers it.
@@ -733,7 +731,7 @@ export interface ScheduledActorRunInput extends GeneratedScheduleActionRunInput
 export interface ScheduledActorRunOptions extends GeneratedTaskOptions {
 }
 export interface ScheduleActionRunActorRePointed {
-    type: ScheduleActions.RunActor;
+    type: `${ScheduleActions.RunActor}`;
     runInput?: ScheduledActorRunInput | null;
     runOptions?: ScheduledActorRunOptions | null;
 }
@@ -741,7 +739,7 @@ export interface ScheduleActionRunActorRePointed {
 export interface ScheduleActionRunActor extends Omit<Schemas['ScheduleActionRunActor'], keyof ScheduleActionRunActorRePointed>, ScheduleActionRunActorRePointed {
 }
 export interface ScheduleActionRunActorTaskRePointed {
-    type: ScheduleActions.RunActorTask;
+    type: `${ScheduleActions.RunActorTask}`;
 }
 /** Scheduled action to run an Actor task. */
 export interface ScheduleActionRunActorTask extends Omit<Schemas['ScheduleActionRunActorTask'], keyof ScheduleActionRunActorTaskRePointed>, ScheduleActionRunActorTaskRePointed {
@@ -929,15 +927,14 @@ export interface RequestQueueStats extends GeneratedRequestQueueStats {
 /**
  * Fields the API returns on a request queue that the OpenAPI spec does not describe yet.
  *
- * The spec does carry `username` and `expireAt` on `RequestQueueShort`, the listing shape, and simply
- * omits both from the full `RequestQueue` schema. `title` is absent from either.
+ * The spec does carry `username` on `RequestQueueShort`, the listing shape, and simply omits it from the
+ * full `RequestQueue` schema. `title` is absent from either.
  *
  * TODO: Remove once the spec covers them.
  */
 export interface RequestQueueSpecGaps {
     title?: string;
     username?: string;
-    expireAt?: Date;
 }
 export interface RequestQueueRePointed {
     stats?: RequestQueueStats;

package/dist/resource_clients/actor.d.ts

@@ -3,6 +3,8 @@ import { Log } from '@apify/log';
 import type { ApiClientSubResourceOptions } from '../base/api_client.js';
 import { ResourceClient } from '../base/resource_client.js';
 import type { Actor, ActorRun } from '../models.js';
+import type { TimeoutOptions } from '../timeouts.js';
+import type { Dictionary } from '../utils.js';
 import { ActorVersionClient } from './actor_version.js';
 import { ActorVersionCollectionClient } from './actor_version_collection.js';
 import type { Build, BuildClientGetOptions } from './build.js';
@@ -42,24 +44,30 @@ export declare class ActorClient extends ResourceClient {
     /**
      * Gets the Actor object from the Apify API.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The Actor object, or `undefined` if it does not exist
      * @see https://docs.apify.com/api/v2/act-get
      */
-    get(): Promise<Actor | undefined>;
+    get(options?: TimeoutOptions): Promise<Actor | undefined>;
     /**
      * Updates the Actor with specified fields.
      *
      * @param newFields - Fields to update in the Actor
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The updated Actor object
      * @see https://docs.apify.com/api/v2/act-put
      */
-    update(newFields: ActorUpdateOptions): Promise<Actor>;
+    update(newFields: ActorUpdateOptions, options?: TimeoutOptions): Promise<Actor>;
     /**
      * Deletes the Actor.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @see https://docs.apify.com/api/v2/act-delete
      */
-    delete(): Promise<void>;
+    delete(options?: TimeoutOptions): Promise<void>;
     /**
      * Starts the Actor and immediately returns the Run object.
      *
@@ -67,17 +75,20 @@ export declare class ActorClient extends ResourceClient {
      * asynchronously and this method returns immediately without waiting for completion.
      * Use the {@link call} method if you want to wait for the Actor to finish.
      *
-     * @param input - Input for the Actor. Can be any JSON-serializable value (object, array, string, number).
-     *                If `contentType` is specified in options, input should be a string or Buffer.
+     * @param input - Input for the Actor: an object or array serialized to JSON, or raw bytes sent as they are.
+     *                Omit it to run the Actor without input.
      * @param options - Run configuration options
      * @param options.build - Tag or number of the build to run (e.g., `'beta'` or `'1.2.345'`). If not provided, uses the default build.
      * @param options.memory - Memory in megabytes allocated for the run. If not provided, uses the Actor's default memory setting.
-     * @param options.timeout - Timeout for the run in seconds. Zero means no timeout. If not provided, uses the Actor's default timeout.
+     * @param options.runTimeoutSecs - Timeout for the run in seconds. Zero means no timeout. If not provided, uses the Actor's default timeout.
      * @param options.waitForFinish - Maximum time to wait (in seconds, max 60s) for the run to finish on the API side before returning. Default is 0 (returns immediately).
      * @param options.webhooks - Webhooks to trigger when the Actor run reaches a specific state (e.g., `SUCCEEDED`, `FAILED`).
      * @param options.maxItems - Maximum number of dataset items that will be charged (only for pay-per-result Actors).
      * @param options.maxTotalChargeUsd - Maximum cost in USD (only for pay-per-event Actors).
-     * @param options.contentType - Content type of the input. If specified, input must be a string or Buffer.
+     * @param options.waitForResources - Retry the start while the account lacks the memory or a concurrent-run slot for
+     * the run. `true` retries until the run starts, a number stops retrying after that many seconds.
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'medium'`, extended to cover `waitForFinish`
+     * when the API is asked to hold the response.
      * @returns The Actor run object with status, usage, and storage IDs
      * @see https://docs.apify.com/api/v2/act-runs-post
      *
@@ -90,11 +101,11 @@ export declare class ActorClient extends ResourceClient {
      * // Start Actor with specific build and memory
      * const run = await client.actor('my-actor').start(
      *   { url: 'https://example.com' },
-     *   { build: '0.1.2', memory: 512, timeout: 300 }
+     *   { build: '0.1.2', memory: 512, runTimeoutSecs: 300 }
      * );
      * ```
      */
-    start(input?: unknown, options?: ActorStartOptions): Promise<ActorRun>;
+    start(input?: ActorInput, options?: ActorStartOptions): Promise<ActorRun>;
     /**
      * Starts the Actor and waits for it to finish before returning the Run object.
      *
@@ -102,14 +113,18 @@ export declare class ActorClient extends ResourceClient {
      * by polling the run status. It optionally streams logs to the console or a custom Log instance.
      * By default, it waits indefinitely unless the `waitSecs` option is provided.
      *
-     * @param input - Input for the Actor. Can be any JSON-serializable value (object, array, string, number).
-     *                If `contentType` is specified in options, input should be a string or Buffer.
+     * @param input - Input for the Actor: an object or array serialized to JSON, or raw bytes sent as they are.
+     *                Omit it to run the Actor without input.
      * @param options - Run configuration options (extends all options from {@link start})
      * @param options.waitSecs - Maximum time to wait for the run to finish, in seconds. If omitted, waits indefinitely.
      * @param options.log - Log instance for streaming run logs. Use `'default'` for console output, `null` to disable logging, or provide a custom Log instance.
      * @param options.build - Tag or number of the build to run (e.g., `'beta'` or `'1.2.345'`).
      * @param options.memory - Memory in megabytes allocated for the run.
-     * @param options.timeout - Maximum run duration in seconds.
+     * @param options.runTimeoutSecs - Maximum run duration in seconds.
+     * @param options.waitForResources - Retry the start while the account lacks the memory or a concurrent-run slot for
+     * the run. `true` retries until the run starts, a number stops retrying after that many seconds. The time spent
+     * retrying doesn't count toward `waitSecs`.
+     * @param options.timeoutSecs - Timeout for each API request, the start and every poll alike. Default is `'noTimeout'`.
      * @returns The finished Actor run object with final status (`SUCCEEDED`, `FAILED`, `ABORTED`, or `TIMED-OUT`)
      * @see https://docs.apify.com/api/v2/act-runs-post
      *
@@ -132,7 +147,7 @@ export declare class ActorClient extends ResourceClient {
      * const run = await client.actor('my-actor').call({ url: 'https://example.com' }, { log });
      * ```
      */
-    call(input?: unknown, options?: ActorCallOptions): Promise<ActorRun>;
+    call(input?: ActorInput, options?: ActorCallOptions): Promise<ActorRun>;
     /**
      * Validates the provided input for the Actor against its input schema.
      *
@@ -141,13 +156,12 @@ export declare class ActorClient extends ResourceClient {
      * invalid, the API responds with an error that is thrown as an `ApifyApiError` describing the
      * validation problem.
      *
-     * @param input - Input to validate against the Actor's input schema. Can be any JSON-serializable
-     *                value (object, array, string, number). If `contentType` is specified in options,
-     *                input should be a string or Buffer.
+     * @param input - Input to validate against the Actor's input schema: an object or array serialized to JSON, or
+     *                raw bytes sent as they are.
      * @param options - Validation options
      * @param options.build - Tag or number of the build whose input schema the input is validated against
      *                         (e.g., `'latest'` or `'1.2.345'`). If not provided, uses the default build.
-     * @param options.contentType - Content type of the input. If specified, input must be a string or Buffer.
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns `true` if the input is valid. Invalid input causes the underlying API call to throw an `ApifyApiError`.
      * @see https://docs.apify.com/api/v2/act-validate-input-post
      *
@@ -164,7 +178,7 @@ export declare class ActorClient extends ResourceClient {
      * ```
      * @since Added in 2.24.0
      */
-    validateInput(input?: unknown, options?: ActorValidateInputOptions): Promise<boolean>;
+    validateInput(input?: ActorInput, options?: ActorValidateInputOptions): Promise<boolean>;
     /**
      * Builds the Actor.
      *
@@ -177,6 +191,8 @@ export declare class ActorClient extends ResourceClient {
      * @param options.tag - Tag to be applied to the build (e.g., `'latest'`, `'beta'`). Existing tag with the same name will be replaced.
      * @param options.useCache - If `false`, Docker build cache will be ignored. Default is `true`.
      * @param options.waitForFinish - Maximum time to wait (in seconds, max 60s) for the build to finish on the API side before returning. Default is 0 (returns immediately).
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'medium'`, extended to cover `waitForFinish`
+     * when the API is asked to hold the response.
      * @returns The Build object with status and build details
      * @see https://docs.apify.com/api/v2/act-builds-post
      *
@@ -204,6 +220,8 @@ export declare class ActorClient extends ResourceClient {
      *
      * @param options - Options for getting the default build
      * @param options.waitForFinish - Maximum time to wait (in seconds, max 60s) for the build to finish on the API side before returning. Default is 0 (returns immediately).
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`, extended to cover `waitForFinish`
+     * when the API is asked to hold the response.
      * @returns A client for the default build
      * @see https://docs.apify.com/api/v2/act-build-default-get
      *
@@ -279,18 +297,27 @@ export declare class ActorClient extends ResourceClient {
 /**
  * Fields that can be updated when modifying an Actor.
  */
-export type ActorUpdateOptions = Partial<Pick<Actor, 'name' | 'description' | 'isPublic' | 'isDeprecated' | 'seoTitle' | 'seoDescription' | 'title' | 'restartOnError' | 'versions' | 'categories' | 'defaultRunOptions' | 'actorStandby' | 'actorPermissionLevel' | 'taggedBuilds'>>;
-export interface ActorStartOptions {
+export type ActorUpdateOptions = Partial<Pick<Actor, 'name' | 'description' | 'isPublic' | 'isDeprecated' | 'seoTitle' | 'seoDescription' | 'title' | 'versions' | 'categories' | 'defaultRunOptions' | 'actorStandby' | 'actorPermissionLevel' | 'taggedBuilds'>>;
+/**
+ * Input for an Actor run, as taken by {@link ActorClient.start}, {@link ActorClient.call},
+ * {@link ActorClient.validateInput} and {@link RunClient.metamorph}.
+ *
+ * A plain object or an array of plain objects, serialized into the request body, or raw bytes
+ * (a `Uint8Array` such as a `Buffer`, or an `ArrayBuffer`) sent as they are, typically with a
+ * `contentType`. An input typed as an `interface` or a class needs a spread (`{ ...input }`), or for
+ * an interface a `type` alias, to compile.
+ */
+export type ActorInput = Dictionary | readonly Dictionary[] | Uint8Array | ArrayBuffer;
+export interface ActorStartOptions extends TimeoutOptions {
     /**
      * Tag or number of the Actor build to run (e.g. `beta` or `1.2.345`).
      * If not provided, the run uses build tag or number from the default Actor run configuration (typically `latest`).
      */
     build?: string;
     /**
-     * Content type for the `input`. If not specified,
-     * `input` is expected to be an object that will be stringified to JSON and content type set to
-     * `application/json; charset=utf-8`. If `options.contentType` is specified, then `input` must be a
-     * `String` or `Buffer`.
+     * Content type of the request body, which becomes the content type of the run's `INPUT` record.
+     * Without it, an input is serialized to JSON and sent as `application/json`. Pairing an object
+     * with `application/x-www-form-urlencoded` form-encodes it instead.
      */
     contentType?: string;
     /**
@@ -300,9 +327,9 @@ export interface ActorStartOptions {
     memory?: number;
     /**
      * Timeout for the Actor run in seconds. Zero value means there is no timeout.
-     * If not provided, the run uses timeout of the default Actor run configuration.
+     * If not provided, the run uses the timeout of the default Actor run configuration.
      */
-    timeout?: number;
+    runTimeoutSecs?: number;
     /**
      * Maximum time to wait for the Actor run to finish, in seconds.
      * If the limit is reached, the returned promise is resolved to a run object that will have
@@ -345,6 +372,20 @@ export interface ActorStartOptions {
      * @since Added in 2.17.0
      */
     forcePermissionLevel?: ACTOR_PERMISSION_LEVEL;
+    /**
+     * Retry the start while the account lacks the resources for the run, that is while the API rejects it with an
+     * `ApifyApiError` of type `actor-memory-limit-exceeded` or `concurrent-runs-limit-exceeded`. Both clear as
+     * other runs or builds finish. The start is retried every 10 seconds, and any other error is thrown right away.
+     *
+     * `true` retries until the run starts. A number stops retrying after that many seconds and throws the last
+     * error. Omitted or `false`, the first rejection is thrown.
+     *
+     * A run that requests more memory than the whole memory limit of the account is rejected with
+     * `actor-memory-limit-exceeded` as well and never starts, so `true` retries it forever.
+     *
+     * A `Readable` input can't be sent twice, so its start is never retried and the first rejection is thrown.
+     */
+    waitForResources?: boolean | number;
 }
 /**
  * Options for calling an Actor and waiting for it to finish.
@@ -369,24 +410,23 @@ export interface ActorCallOptions extends Omit<ActorStartOptions, 'waitForFinish
  * Options for validating an Actor input.
  * @since Added in 2.24.0
  */
-export interface ActorValidateInputOptions {
+export interface ActorValidateInputOptions extends TimeoutOptions {
     /**
      * Tag or number of the Actor build whose input schema the input is validated against
      * (e.g. `beta` or `1.2.345`). If not provided, the default build is used.
      */
     build?: string;
     /**
-     * Content type for the `input`. If not specified,
-     * `input` is expected to be an object that will be stringified to JSON and content type set to
-     * `application/json; charset=utf-8`. If `options.contentType` is specified, then `input` must be a
-     * `String` or `Buffer`.
+     * Content type of the request body carrying the input to validate. Without it, the input is
+     * serialized to JSON and sent as `application/json`. Pairing an object with
+     * `application/x-www-form-urlencoded` form-encodes it instead.
      */
     contentType?: string;
 }
 /**
  * Options for building an Actor.
  */
-export interface ActorBuildOptions {
+export interface ActorBuildOptions extends TimeoutOptions {
     betaPackages?: boolean;
     tag?: string;
     useCache?: boolean;