apify-client 3.0.0-beta.2 → 3.0.0-beta.21

package/dist/resource_clients/actor.js

@@ -2,7 +2,9 @@ import { z } from 'zod';
 import { ACTOR_JOB_STATUSES, ACTOR_PERMISSION_LEVEL, META_ORIGINS } from '@apify/consts';
 import { Log } from '@apify/log';
 import { ResourceClient } from '../base/resource_client.js';
-import { anyObjectSchema, cast, parseArgument, parseDateFields, pluckData, stringifyWebhooksToBase64, } from '../utils.js';
+import * as schemas from '../schemas.js';
+import { timeoutOptionsSchema, timeoutOptionsShape } from '../timeouts.js';
+import { anyObjectSchema, parseArgument, parseResponse, stringifyWebhooksToBase64 } from '../utils.js';
 import { ActorVersionClient } from './actor_version.js';
 import { ActorVersionCollectionClient } from './actor_version_collection.js';
 import { BuildClient } from './build.js';
@@ -14,19 +16,20 @@ 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(),
+    ...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(),
@@ -34,18 +37,22 @@ 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(),
+    ...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(),
@@ -83,30 +90,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();
+    async get(options = {}) {
+        const { timeoutSecs = 'short' } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.getResource(schemas.Actor(), {}, timeoutSecs);
     }
     /**
      * 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(newFields);
+        const { timeoutSecs = 'short' } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.updateResource(schemas.Actor(), newFields, timeoutSecs);
     }
     /**
      * 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' } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.deleteResource(timeoutSecs);
     }
     /**
      * Starts the Actor and immediately returns the Run object.
@@ -115,17 +131,17 @@ 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, serialized to JSON. 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.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
      *
@@ -138,18 +154,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, timeoutSecs, } = parsed;
+        // The API's `timeout` parameter bounds the run, not the request.
         const params = {
             waitForFinish,
-            timeout,
+            timeout: runTimeoutSecs,
             memory,
             build,
             webhooks: stringifyWebhooksToBase64(parsed.webhooks),
@@ -159,13 +174,14 @@ export class ActorClient extends ResourceClient {
             forcePermissionLevel,
         };
         const request = {
-            url: this._url('runs'),
+            url: this.buildUrl('runs'),
             method: 'POST',
             data: input,
-            params: this._params(params),
+            params: this.buildParams(params),
             // Apify internal property. Tells the request serialization interceptor
             // to stringify functions to JSON, instead of omitting them.
             stringifyFunctions: true,
+            timeoutSecs: this.timeoutForWaitForFinish(timeoutSecs, 'medium', waitForFinish),
         };
         if (parsed.contentType) {
             request.headers = {
@@ -173,7 +189,7 @@ export class ActorClient extends ResourceClient {
             };
         }
         const response = await this.httpClient.call(request);
-        return cast(parseDateFields(pluckData(response.data)));
+        return parseResponse(response, schemas.Run());
     }
     /**
      * Starts the Actor and waits for it to finish before returning the Run object.
@@ -182,14 +198,14 @@ 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, serialized to JSON. 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.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
      *
@@ -213,11 +229,9 @@ 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', ...startOptions } = parsed;
+        const { id } = await this.start(input, { ...startOptions, timeoutSecs });
         // 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.
@@ -226,7 +240,7 @@ export class ActorClient extends ResourceClient {
         streamedLog?.start();
         return this.apifyClient
             .run(id)
-            .waitForFinish({ waitSecs })
+            .waitForFinish({ waitSecs, timeoutSecs })
             .finally(async () => {
             await streamedLog?.stop();
         });
@@ -239,13 +253,11 @@ 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, serialized to JSON.
      * @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
      *
@@ -263,17 +275,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 }),
+            params: this.buildParams({ build: parsed.build }),
             // Apify internal property. Tells the request serialization interceptor
             // to stringify functions to JSON, instead of omitting them.
             stringifyFunctions: true,
+            timeoutSecs: parsed.timeoutSecs ?? 'short',
         };
         if (parsed.contentType) {
             request.headers = {
@@ -295,6 +306,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
      *
@@ -314,16 +327,17 @@ export class ActorClient extends ResourceClient {
      */
     async build(versionNumber, options = {}) {
         parseArgument(versionNumber, versionNumberSchema);
-        const parsed = parseArgument(options, buildOptionsSchema, 'ActorBuildOptions');
+        const { timeoutSecs, ...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),
         });
-        return cast(parseDateFields(pluckData(response.data)));
+        return parseResponse(response, schemas.Build());
     }
     /**
      * Returns a client for the default build of this Actor.
@@ -334,6 +348,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
      *
@@ -351,12 +367,14 @@ export class ActorClient extends ResourceClient {
      * @since Added in 2.12.2
      */
     async defaultBuild(options = {}) {
+        const { timeoutSecs, ...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),
         });
-        const { id } = pluckData(response.data);
+        const { id } = parseResponse(response, schemas.Build());
         return new BuildClient({
             baseUrl: this.apifyClient.baseUrl,
             publicBaseUrl: this.apifyClient.publicBaseUrl,
@@ -384,9 +402,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',
         }));
     }
@@ -397,7 +415,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',
         }));
     }
@@ -408,7 +426,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',
         }));
     }
@@ -421,7 +439,7 @@ export class ActorClient extends ResourceClient {
      */
     version(versionNumber) {
         parseArgument(versionNumber, versionNumberSchema);
-        return new ActorVersionClient(this._subResourceOptions({
+        return new ActorVersionClient(this.subResourceOptions({
             id: versionNumber,
         }));
     }
@@ -432,7 +450,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.
@@ -441,6 +459,6 @@ 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());
     }
 }

package/dist/resource_clients/actor_collection.d.ts

@@ -2,6 +2,7 @@ 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 { 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';
@@ -51,6 +52,7 @@ 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
      */
@@ -59,25 +61,29 @@ export declare class ActorCollectionClient extends ResourceCollectionClient {
      * 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<Actor>;
 }
 /**
+ * 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 interface ActorCollectionCreateOptions {
@@ -100,8 +106,6 @@ export interface ActorCollectionCreateOptions {
     isDeprecated?: boolean;
     isPublic?: boolean;
     name?: string;
-    /** @deprecated Use defaultRunOptions.restartOnError instead */
-    restartOnError?: boolean;
     /**
      * @since Added in 2.8.6
      */

package/dist/resource_clients/actor_collection.js

@@ -1,5 +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();
 /**
@@ -52,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(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(actor);
+        const { timeoutSecs = 'medium' } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.createResource(schemas.Actor(), actor, timeoutSecs);
     }
 }
 /**
+ * Field to order a list of Actors by.
+ *
  * @since Added in 2.12.6
  */
 export var ActorListSortBy;
@@ -85,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,5 +1,6 @@
 import type { ApiClientSubResourceOptions } from '../base/api_client.js';
 import { ResourceClient } from '../base/resource_client.js';
+import type { TimeoutOptions } from '../timeouts.js';
 import type { ActorEnvironmentVariable } 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<ActorEnvironmentVariable | 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: ActorEnvironmentVariable, options?: TimeoutOptions): Promise<ActorEnvironmentVariable>;
     /**
      * 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,4 +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.
@@ -36,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();
+    async get(options = {}) {
+        const { timeoutSecs = 'short' } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.getResource(schemas.EnvVar(), {}, timeoutSecs);
     }
     /**
      * 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(actorEnvVar);
+        const { timeoutSecs = 'short' } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.updateResource(schemas.EnvVar(), actorEnvVar, timeoutSecs);
     }
     /**
      * 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' } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.deleteResource(timeoutSecs);
     }
 }

package/dist/resource_clients/actor_env_var_collection.d.ts

@@ -1,6 +1,7 @@
 import type { ApiClientSubResourceOptions } from '../base/api_client.js';
 import { ResourceCollectionClient } from '../base/resource_collection_client.js';
-import type { PaginatedList, PaginationOptions } from '../utils.js';
+import type { TimeoutOptions } from '../timeouts.js';
+import type { PaginatedList } from '../utils.js';
 import type { ActorEnvironmentVariable } from './actor_version.js';
 /**
  * Client for managing the collection of environment variables for an Actor version.
@@ -37,39 +38,34 @@ export declare class ActorEnvVarCollectionClient extends ResourceCollectionClien
     /**
      * Lists all environment variables of this Actor version.
      *
-     * Awaiting the return value (as you would with a Promise) will result in a single API call. The amount of fetched
-     * items in a single API call is limited.
+     * The endpoint returns every environment variable in one response, so awaiting the return value (as you would
+     * with a Promise) gets the whole list.
      * ```javascript
-     * const paginatedList = await client.list();
-     *```
+     * const { items } = await client.list();
+     * ```
      *
-     * Asynchronous iteration is also supported. This will fetch additional pages if needed until all items are
-     * retrieved.
+     * Asynchronous iteration is also supported, and yields the environment variables one by one.
      *
      * ```javascript
      * for await (const singleItem of client.list()) {...}
      * ```
      *
-     * @returns A paginated iterator of environment variables.
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
+     * @returns The environment variables, awaitable as a whole list or iterable one by one.
      * @see https://docs.apify.com/api/v2/act-version-env-vars-get
      */
-    list(_options?: ActorEnvVarCollectionListOptions): Promise<ActorEnvVarListResult> & AsyncIterable<ActorEnvironmentVariable>;
+    list(options?: TimeoutOptions): Promise<ActorEnvVarListResult> & AsyncIterable<ActorEnvironmentVariable>;
     /**
      * Creates a new environment variable for this Actor version.
      *
      * @param actorEnvVar - The environment variable data.
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The created environment variable object.
      * @see https://docs.apify.com/api/v2/act-version-env-vars-post
      */
-    create(actorEnvVar: ActorEnvironmentVariable): Promise<ActorEnvironmentVariable>;
-}
-/**
- * @deprecated No options are used in the current API implementation.
- * https://github.com/apify/apify-client-js/issues/799
- * @since Added in 2.1.0
- */
-export interface ActorEnvVarCollectionListOptions extends PaginationOptions {
-    desc?: boolean;
+    create(actorEnvVar: ActorEnvironmentVariable, options?: TimeoutOptions): Promise<ActorEnvironmentVariable>;
 }
 /**
  * @since Added in 2.1.0