apify-client 3.0.0-beta.9 → 3.0.0-beta.90

package/dist/resource_clients/actor.js

@@ -3,7 +3,10 @@ import { ACTOR_JOB_STATUSES, ACTOR_PERMISSION_LEVEL, META_ORIGINS } from '@apify
 import { Log } from '@apify/log';
 import { ResourceClient } from '../base/resource_client.js';
 import * as schemas from '../schemas.js';
-import { anyObjectSchema, parseArgument, parseResponse, stringifyWebhooksToBase64 } from '../utils.js';
+import { timeoutOptionsSchema, timeoutOptionsShape } from '../timeouts.js';
+import { anyObjectSchema, isStream, parseArgument, parseResponse, stringifyWebhooksToBase64 } from '../utils.js';
+import { startWaitingForResources } from '../wait_for_resources.js';
+import { ActorServerClient } from './actor_server.js';
 import { ActorVersionClient } from './actor_version.js';
 import { ActorVersionCollectionClient } from './actor_version_collection.js';
 import { BuildClient } from './build.js';
@@ -15,19 +18,21 @@ const startOptionsSchema = z.strictObject({
     build: z.string().optional(),
     contentType: z.string().optional(),
     memory: z.number().optional(),
-    timeout: z.number().optional(),
+    runTimeoutSecs: z.number().min(0).optional(),
     waitForFinish: z.number().optional(),
     webhooks: z.array(anyObjectSchema).optional(),
     maxItems: z.number().min(0).optional(),
     maxTotalChargeUsd: z.number().min(0).optional(),
     restartOnError: z.boolean().optional(),
     forcePermissionLevel: z.enum(ACTOR_PERMISSION_LEVEL).optional(),
+    waitForResources: z.union([z.boolean(), z.number().min(0)]).optional(),
+    ...timeoutOptionsShape,
 });
 const callOptionsSchema = z.strictObject({
     build: z.string().optional(),
     contentType: z.string().optional(),
     memory: z.number().optional(),
-    timeout: z.number().min(0).optional(),
+    runTimeoutSecs: z.number().min(0).optional(),
     waitSecs: z.number().min(0).optional(),
     webhooks: z.array(anyObjectSchema).optional(),
     maxItems: z.number().min(0).optional(),
@@ -35,18 +40,23 @@ const callOptionsSchema = z.strictObject({
     log: z.union([z.null(), z.instanceof(Log), z.literal('default')]).optional(),
     restartOnError: z.boolean().optional(),
     forcePermissionLevel: z.enum(ACTOR_PERMISSION_LEVEL).optional(),
+    waitForResources: z.union([z.boolean(), z.number().min(0)]).optional(),
+    ...timeoutOptionsShape,
 });
 const validateInputOptionsSchema = z.strictObject({
     build: z.string().optional(),
     contentType: z.string().optional(),
+    ...timeoutOptionsShape,
 });
-const versionNumberSchema = z.string();
+const versionNumberSchema = z.string().min(1);
 const buildOptionsSchema = z.strictObject({
     betaPackages: z.boolean().optional(),
     tag: z.string().optional(),
     useCache: z.boolean().optional(),
     waitForFinish: z.number().optional(),
+    ...timeoutOptionsShape,
 });
+const defaultBuildOptionsSchema = z.strictObject({ waitForFinish: z.number().optional(), ...timeoutOptionsShape });
 const lastRunOptionsSchema = z.strictObject({
     status: z.enum(ACTOR_JOB_STATUSES).optional(),
     origin: z.enum(META_ORIGINS).optional(),
@@ -72,6 +82,7 @@ const lastRunOptionsSchema = z.strictObject({
  * @see https://docs.apify.com/platform/actors
  */
 export class ActorClient extends ResourceClient {
+    #serverClient;
     /**
      * @hidden
      */
@@ -84,30 +95,39 @@ export 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
      */
-    async get() {
-        return this._get(schemas.Actor());
+    async get(options = {}) {
+        const { timeoutSecs = 'short', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.getResource(schemas.ActorResource(), {}, timeoutSecs, signal);
     }
     /**
      * 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
      */
-    async update(newFields) {
+    async update(newFields, options = {}) {
         parseArgument(newFields, anyObjectSchema);
-        return this._update(schemas.Actor(), newFields);
+        const { timeoutSecs = 'short', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.updateResource(schemas.ActorResource(), newFields, timeoutSecs, signal);
     }
     /**
      * 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
      */
-    async delete() {
-        return this._delete();
+    async delete(options = {}) {
+        const { timeoutSecs = 'short', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.deleteResource(timeoutSecs, signal);
     }
     /**
      * Starts the Actor and immediately returns the Run object.
@@ -116,17 +136,20 @@ export 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
      *
@@ -139,18 +162,17 @@ export 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 }
      * );
      * ```
      */
     async start(input, options = {}) {
-        // input can be anything, so no point in validating it. E.g. if you set content-type to application/pdf
-        // then it will process input as a buffer.
         const parsed = parseArgument(options, startOptionsSchema, 'ActorStartOptions');
-        const { waitForFinish, timeout, memory, build, maxItems, maxTotalChargeUsd, restartOnError, forcePermissionLevel, } = parsed;
+        const { waitForFinish, runTimeoutSecs, memory, build, maxItems, maxTotalChargeUsd, restartOnError, forcePermissionLevel, waitForResources, timeoutSecs, signal, } = parsed;
+        // The API's `timeout` parameter bounds the run, not the request.
         const params = {
             waitForFinish,
-            timeout,
+            timeout: runTimeoutSecs,
             memory,
             build,
             webhooks: stringifyWebhooksToBase64(parsed.webhooks),
@@ -160,20 +182,22 @@ export class ActorClient extends ResourceClient {
             forcePermissionLevel,
         };
         const request = {
-            url: this._url('runs'),
+            url: this.buildUrl('runs'),
             method: 'POST',
             data: input,
-            params: this._params(params),
-            // Apify internal property. Tells the request serialization interceptor
-            // to stringify functions to JSON, instead of omitting them.
+            params: this.buildParams(params),
+            // Actor input may carry page functions, which plain JSON serialization would drop.
             stringifyFunctions: true,
+            timeoutSecs: this.timeoutForWaitForFinish(timeoutSecs, 'medium', waitForFinish),
+            signal,
         };
         if (parsed.contentType) {
             request.headers = {
                 'content-type': parsed.contentType,
             };
         }
-        const response = await this.httpClient.call(request);
+        // A `Readable` input is consumed by the first attempt, so a retry would start the run with an empty input.
+        const response = await startWaitingForResources(async () => this.httpClient.call(request), isStream(input) ? false : waitForResources, this.httpClient.logger, signal);
         return parseResponse(response, schemas.Run());
     }
     /**
@@ -183,14 +207,18 @@ export 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
      *
@@ -214,20 +242,18 @@ export class ActorClient extends ResourceClient {
      * ```
      */
     async call(input, options = {}) {
-        // input can be anything, so no point in validating it. E.g. if you set content-type to application/pdf
-        // then it will process input as a buffer.
         const parsed = parseArgument(options, callOptionsSchema, 'ActorCallOptions');
-        const { waitSecs, log, ...startOptions } = parsed;
-        const { id } = await this.start(input, startOptions);
+        const { waitSecs, log, timeoutSecs = 'noTimeout', signal, ...startOptions } = parsed;
+        const { id } = await this.start(input, { ...startOptions, timeoutSecs, signal });
         // Calling root client because we need access to top level API.
         // Creating a new instance of RunClient here would only allow
         // setting it up as a nested route under actor API.
         const newRunClient = this.apifyClient.run(id);
-        const streamedLog = await newRunClient.getStreamedLog({ toLog: log });
+        const streamedLog = await newRunClient.getStreamedLog({ toLog: log, signal });
         streamedLog?.start();
         return this.apifyClient
             .run(id)
-            .waitForFinish({ waitSecs })
+            .waitForFinish({ waitSecs, timeoutSecs, signal })
             .finally(async () => {
             await streamedLog?.stop();
         });
@@ -240,13 +266,12 @@ export 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
      *
@@ -264,17 +289,16 @@ export class ActorClient extends ResourceClient {
      * @since Added in 2.24.0
      */
     async validateInput(input, options = {}) {
-        // input can be anything, so no point in validating it. E.g. if you set content-type to application/pdf
-        // then it will process input as a buffer.
         const parsed = parseArgument(options, validateInputOptionsSchema, 'ActorValidateInputOptions');
         const request = {
-            url: this._url('validate-input'),
+            url: this.buildUrl('validate-input'),
             method: 'POST',
             data: input,
-            params: this._params({ build: parsed.build }),
-            // Apify internal property. Tells the request serialization interceptor
-            // to stringify functions to JSON, instead of omitting them.
+            params: this.buildParams({ build: parsed.build }),
+            // Actor input may carry page functions, which plain JSON serialization would drop.
             stringifyFunctions: true,
+            timeoutSecs: parsed.timeoutSecs ?? 'short',
+            signal: parsed.signal,
         };
         if (parsed.contentType) {
             request.headers = {
@@ -296,6 +320,8 @@ export 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
      *
@@ -315,14 +341,16 @@ export class ActorClient extends ResourceClient {
      */
     async build(versionNumber, options = {}) {
         parseArgument(versionNumber, versionNumberSchema);
-        const parsed = parseArgument(options, buildOptionsSchema, 'ActorBuildOptions');
+        const { timeoutSecs, signal, ...params } = parseArgument(options, buildOptionsSchema, 'ActorBuildOptions');
         const response = await this.httpClient.call({
-            url: this._url('builds'),
+            url: this.buildUrl('builds'),
             method: 'POST',
-            params: this._params({
+            params: this.buildParams({
                 version: versionNumber,
-                ...parsed,
+                ...params,
             }),
+            timeoutSecs: this.timeoutForWaitForFinish(timeoutSecs, 'medium', params.waitForFinish),
+            signal,
         });
         return parseResponse(response, schemas.Build());
     }
@@ -335,6 +363,8 @@ export 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
      *
@@ -352,10 +382,13 @@ export class ActorClient extends ResourceClient {
      * @since Added in 2.12.2
      */
     async defaultBuild(options = {}) {
+        const { timeoutSecs, signal, ...params } = parseArgument(options, defaultBuildOptionsSchema, 'BuildClientGetOptions');
         const response = await this.httpClient.call({
-            url: this._url('builds/default'),
+            url: this.buildUrl('builds/default'),
             method: 'GET',
-            params: this._params(options),
+            params: this.buildParams(params),
+            timeoutSecs: this.timeoutForWaitForFinish(timeoutSecs, 'short', params.waitForFinish),
+            signal,
         });
         const { id } = parseResponse(response, schemas.Build());
         return new BuildClient({
@@ -385,9 +418,9 @@ export class ActorClient extends ResourceClient {
      */
     lastRun(options = {}) {
         const parsed = parseArgument(options, lastRunOptionsSchema, 'ActorLastRunOptions');
-        return new RunClient(this._subResourceOptions({
+        return new RunClient(this.subResourceOptions({
             id: 'last',
-            params: this._params(parsed),
+            params: this.buildParams(parsed),
             resourcePath: 'runs',
         }));
     }
@@ -398,7 +431,7 @@ export class ActorClient extends ResourceClient {
      * @see https://docs.apify.com/api/v2/act-builds-get
      */
     builds() {
-        return new BuildCollectionClient(this._subResourceOptions({
+        return new BuildCollectionClient(this.subResourceOptions({
             resourcePath: 'builds',
         }));
     }
@@ -409,7 +442,7 @@ export class ActorClient extends ResourceClient {
      * @see https://docs.apify.com/api/v2/act-runs-get
      */
     runs() {
-        return new RunCollectionClient(this._subResourceOptions({
+        return new RunCollectionClient(this.subResourceOptions({
             resourcePath: 'runs',
         }));
     }
@@ -422,7 +455,7 @@ export class ActorClient extends ResourceClient {
      */
     version(versionNumber) {
         parseArgument(versionNumber, versionNumberSchema);
-        return new ActorVersionClient(this._subResourceOptions({
+        return new ActorVersionClient(this.subResourceOptions({
             id: versionNumber,
         }));
     }
@@ -433,7 +466,7 @@ export class ActorClient extends ResourceClient {
      * @see https://docs.apify.com/api/v2/act-versions-get
      */
     versions() {
-        return new ActorVersionCollectionClient(this._subResourceOptions());
+        return new ActorVersionCollectionClient(this.subResourceOptions());
     }
     /**
      * Returns a client for managing webhooks associated with this Actor.
@@ -442,6 +475,47 @@ export class ActorClient extends ResourceClient {
      * @see https://docs.apify.com/api/v2/act-webhooks-get
      */
     webhooks() {
-        return new WebhookCollectionClient(this._subResourceOptions());
+        return new WebhookCollectionClient(this.subResourceOptions());
+    }
+    /**
+     * Returns a client for the server interface of this Actor.
+     *
+     * A Server Actor runs a web server, its server interface, that is called over HTTP without starting a run for
+     * each call. Server Actors were formerly called Actor Standby, and {@link standby} is a deprecated alias of this
+     * method. Every call returns the same client, so the server URL it fetches is reused.
+     *
+     * @returns The client for the server interface of this Actor
+     * @see https://docs.apify.com/platform/actors/running/standby
+     *
+     * @example
+     * ```javascript
+     * const response = await client.actor('username/actor-name').server().request('/search', {
+     *     params: { q: 'apify' },
+     * });
+     * ```
+     */
+    server() {
+        this.#serverClient ??= new ActorServerClient({
+            baseUrl: this.baseUrl,
+            publicBaseUrl: this.publicBaseUrl,
+            apifyClient: this.apifyClient,
+            httpClient: this.httpClient,
+            id: this.id,
+            params: this.params,
+        });
+        return this.#serverClient;
+    }
+    /**
+     * Returns a client for the server interface of this Actor in Standby mode.
+     *
+     * Named after Actor Standby, the former name of Server Actors.
+     *
+     * @deprecated Use {@link server} instead. Will be removed in v4.
+     * @returns The client for the server interface of this Actor
+     * @see https://docs.apify.com/platform/actors/running/standby
+     */
+    standby() {
+        this.httpClient.logger.deprecated('`standby()` is deprecated and will be removed in v4. Use `server()` instead.');
+        return this.server();
     }
 }

package/dist/resource_clients/actor_collection.d.ts

@@ -1,11 +1,12 @@
 import type { ACTOR_PERMISSION_LEVEL } from '@apify/consts';
 import type { ApiClientSubResourceOptions } from '../base/api_client.js';
 import { ResourceCollectionClient } from '../base/resource_collection_client.js';
-import type { ActorCollectionListItem } from '../models.js';
+import type { ActorListItem } from '../models.js';
+import type { TimeoutOptions } from '../timeouts.js';
 import type { PaginatedIterator, PaginatedList, PaginationOptions } from '../utils.js';
-import type { Actor, ActorDefaultRunOptions, ActorExampleRunInput, ActorStandby } from './actor.js';
-import type { ActorVersion } from './actor_version.js';
-export type { ActorCollectionListItem } from '../models.js';
+import type { ActorResource, ActorStandby, DefaultRunOptions, ExampleRunInput } from './actor.js';
+import type { Version } from './actor_version.js';
+export type { ActorListItem } from '../models.js';
 /**
  * Client for managing the collection of Actors in your account.
  *
@@ -51,35 +52,40 @@ export declare class ActorCollectionClient extends ResourceCollectionClient {
      * ```
      *
      * @param options - Pagination options.
+     * @param options.timeoutSecs - Timeout for each API request. Default is `'medium'`.
      * @returns A paginated iterator of Actors.
      * @see https://docs.apify.com/api/v2/acts-get
      */
-    list(options?: ActorCollectionListOptions): PaginatedIterator<ActorCollectionListItem>;
+    list(options?: ActorCollectionListOptions): PaginatedIterator<ActorListItem>;
     /**
      * Creates a new Actor.
      *
      * @param actor - The Actor data.
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'medium'`.
      * @returns The created Actor object.
      * @see https://docs.apify.com/api/v2/acts-post
      */
-    create(actor: ActorCollectionCreateOptions): Promise<Actor>;
+    create(actor: ActorCollectionCreateOptions, options?: TimeoutOptions): Promise<ActorResource>;
 }
 /**
+ * Field to order a list of Actors by.
+ *
  * @since Added in 2.12.6
  */
 export declare enum ActorListSortBy {
     CREATED_AT = "createdAt",
     LAST_RUN_STARTED_AT = "stats.lastRunStartedAt"
 }
-export interface ActorCollectionListOptions extends PaginationOptions {
+export interface ActorCollectionListOptions extends PaginationOptions, TimeoutOptions {
     my?: boolean;
     desc?: boolean;
     /**
      * @since Added in 2.12.6
      */
-    sortBy?: ActorListSortBy;
+    sortBy?: `${ActorListSortBy}`;
 }
-export type ActorCollectionListResult = PaginatedList<ActorCollectionListItem>;
+export type ActorCollectionListResult = PaginatedList<ActorListItem>;
 export interface ActorCollectionCreateOptions {
     /**
      * @since Added in 2.8.6
@@ -88,12 +94,12 @@ export interface ActorCollectionCreateOptions {
     /**
      * @since Added in 2.8.6
      */
-    defaultRunOptions?: ActorDefaultRunOptions;
+    defaultRunOptions?: DefaultRunOptions;
     description?: string;
     /**
      * @since Added in 2.8.6
      */
-    exampleRunInput?: ActorExampleRunInput;
+    exampleRunInput?: ExampleRunInput;
     /**
      * @since Added in 2.8.6
      */
@@ -109,7 +115,7 @@ export interface ActorCollectionCreateOptions {
      */
     seoDescription?: string;
     title?: string;
-    versions?: ActorVersion[];
+    versions?: Version[];
     /**
      * @since Added in 2.9.5
      */

package/dist/resource_clients/actor_collection.js

@@ -1,6 +1,7 @@
 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 actorCreateSchema = anyObjectSchema.optional();
 /**
@@ -53,26 +54,32 @@ export class ActorCollectionClient extends ResourceCollectionClient {
      * ```
      *
      * @param options - Pagination options.
+     * @param options.timeoutSecs - Timeout for each API request. Default is `'medium'`.
      * @returns A paginated iterator of Actors.
      * @see https://docs.apify.com/api/v2/acts-get
      */
     list(options = {}) {
         const parsed = parseArgument(options, listOptionsSchema, 'ActorCollectionListOptions');
-        return this._listPaginated(schemas.ListOfActors(), parsed);
+        return this.listResourcesPaginated(schemas.ListOfActors(), parsed, 'medium');
     }
     /**
      * Creates a new Actor.
      *
      * @param actor - The Actor data.
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'medium'`.
      * @returns The created Actor object.
      * @see https://docs.apify.com/api/v2/acts-post
      */
-    async create(actor) {
+    async create(actor, options = {}) {
         parseArgument(actor, actorCreateSchema);
-        return this._create(schemas.Actor(), actor);
+        const { timeoutSecs = 'medium', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.createResource(schemas.ActorResource(), actor, timeoutSecs, signal);
     }
 }
 /**
+ * Field to order a list of Actors by.
+ *
  * @since Added in 2.12.6
  */
 export var ActorListSortBy;
@@ -86,4 +93,5 @@ const listOptionsSchema = z.strictObject({
     ...paginationOptionsShape,
     desc: z.boolean().optional(),
     sortBy: z.enum(ActorListSortBy).optional(),
+    ...timeoutOptionsShape,
 });

package/dist/resource_clients/actor_env_var.d.ts

@@ -1,6 +1,7 @@
 import type { ApiClientSubResourceOptions } from '../base/api_client.js';
 import { ResourceClient } from '../base/resource_client.js';
-import type { ActorEnvironmentVariable } from './actor_version.js';
+import type { TimeoutOptions } from '../timeouts.js';
+import type { EnvVar } from './actor_version.js';
 /**
  * Client for managing a specific Actor environment variable.
  *
@@ -32,22 +33,28 @@ export declare class ActorEnvVarClient extends ResourceClient {
     /**
      * Retrieves the environment variable.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The environment variable object, or `undefined` if it does not exist.
      * @see https://docs.apify.com/api/v2/act-version-env-var-get
      */
-    get(): Promise<ActorEnvironmentVariable | undefined>;
+    get(options?: TimeoutOptions): Promise<EnvVar | undefined>;
     /**
      * Updates the environment variable.
      *
      * @param actorEnvVar - The updated environment variable data.
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The updated environment variable object.
      * @see https://docs.apify.com/api/v2/act-version-env-var-put
      */
-    update(actorEnvVar: ActorEnvironmentVariable): Promise<ActorEnvironmentVariable>;
+    update(actorEnvVar: EnvVar, options?: TimeoutOptions): Promise<EnvVar>;
     /**
      * Deletes the environment variable.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @see https://docs.apify.com/api/v2/act-version-env-var-delete
      */
-    delete(): Promise<void>;
+    delete(options?: TimeoutOptions): Promise<void>;
 }

package/dist/resource_clients/actor_env_var.js

@@ -1,5 +1,6 @@
 import { ResourceClient } from '../base/resource_client.js';
 import * as schemas from '../schemas.js';
+import { timeoutOptionsSchema } from '../timeouts.js';
 import { anyObjectSchema, parseArgument } from '../utils.js';
 /**
  * Client for managing a specific Actor environment variable.
@@ -37,29 +38,38 @@ export class ActorEnvVarClient extends ResourceClient {
     /**
      * Retrieves the environment variable.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The environment variable object, or `undefined` if it does not exist.
      * @see https://docs.apify.com/api/v2/act-version-env-var-get
      */
-    async get() {
-        return this._get(schemas.EnvVar());
+    async get(options = {}) {
+        const { timeoutSecs = 'short', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.getResource(schemas.EnvVar(), {}, timeoutSecs, signal);
     }
     /**
      * Updates the environment variable.
      *
      * @param actorEnvVar - The updated environment variable data.
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The updated environment variable object.
      * @see https://docs.apify.com/api/v2/act-version-env-var-put
      */
-    async update(actorEnvVar) {
+    async update(actorEnvVar, options = {}) {
         parseArgument(actorEnvVar, anyObjectSchema);
-        return this._update(schemas.EnvVar(), actorEnvVar);
+        const { timeoutSecs = 'short', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.updateResource(schemas.EnvVar(), actorEnvVar, timeoutSecs, signal);
     }
     /**
      * Deletes the environment variable.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @see https://docs.apify.com/api/v2/act-version-env-var-delete
      */
-    async delete() {
-        return this._delete();
+    async delete(options = {}) {
+        const { timeoutSecs = 'short', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.deleteResource(timeoutSecs, signal);
     }
 }