apify-client 3.0.0-beta.4 → 3.0.0-beta.41

package/dist/resource_clients/run.js

@@ -1,33 +1,39 @@
 import { z } from 'zod';
 import { LEVELS, Log } from '@apify/log';
 import { ResourceClient } from '../base/resource_client.js';
-import { anyObjectSchema, cast, isNode, parseArgument, parseDateFields, pluckData } from '../utils.js';
+import * as schemas from '../schemas.js';
+import { optionalSignalSchema, optionalTimeoutSchema, timeoutOptionsSchema, timeoutOptionsShape } from '../timeouts.js';
+import { runtime } from '#runtime';
+import { anyObjectSchema, parseArgument, parseResponse } from '../utils.js';
 import { DatasetClient } from './dataset.js';
 import { KeyValueStoreClient } from './key_value_store.js';
 import { LogClient, LoggerActorRedirect, StreamedLog } from './log.js';
 import { RequestQueueClient } from './request_queue.js';
 const RUN_CHARGE_IDEMPOTENCY_HEADER = 'idempotency-key';
-const getOptionsSchema = z.strictObject({ waitForFinish: z.number().optional() });
-const abortOptionsSchema = z.strictObject({ gracefully: z.boolean().optional() });
+const getOptionsSchema = z.strictObject({ waitForFinish: z.number().optional(), ...timeoutOptionsShape });
+const abortOptionsSchema = z.strictObject({ gracefully: z.boolean().optional(), ...timeoutOptionsShape });
 const targetActorIdSchema = z.string();
 const metamorphOptionsSchema = z.strictObject({
     contentType: z.string().optional(),
     build: z.string().optional(),
+    ...timeoutOptionsShape,
 });
 const resurrectOptionsSchema = z.strictObject({
     build: z.string().optional(),
     memory: z.number().optional(),
-    timeout: z.number().optional(),
+    runTimeoutSecs: z.number().optional(),
     maxItems: z.number().optional(),
     maxTotalChargeUsd: z.number().optional(),
     restartOnError: z.boolean().optional(),
+    ...timeoutOptionsShape,
 });
 const chargeOptionsSchema = z.strictObject({
     eventName: z.string(),
     count: z.number().default(1),
     idempotencyKey: z.string().optional(),
+    ...timeoutOptionsShape,
 });
-const waitForFinishOptionsSchema = z.strictObject({ waitSecs: z.number().optional() });
+const waitForFinishOptionsSchema = z.strictObject({ waitSecs: z.number().optional(), ...timeoutOptionsShape });
 /**
  * Client for managing a specific Actor run.
  *
@@ -66,6 +72,8 @@ export class RunClient extends ResourceClient {
      *
      * @param options - Get options
      * @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.timeoutSecs - Timeout for the API request. Default is `'short'`, extended to cover `waitForFinish`
+     * when the API is asked to hold the response.
      * @returns The ActorRun object, or `undefined` if it does not exist
      * @see https://docs.apify.com/api/v2/actor-run-get
      *
@@ -80,14 +88,15 @@ export class RunClient extends ResourceClient {
      * ```
      */
     async get(options = {}) {
-        const parsed = parseArgument(options, getOptionsSchema, 'RunGetOptions');
-        return this._get(parsed);
+        const { timeoutSecs, signal, ...params } = parseArgument(options, getOptionsSchema, 'RunGetOptions');
+        return this.getResource(schemas.Run(), params, this.timeoutForWaitForFinish(timeoutSecs, 'short', params.waitForFinish), signal);
     }
     /**
      * Aborts the Actor run.
      *
      * @param options - Abort options
      * @param options.gracefully - If `true`, the Actor run will abort gracefully - it can send status messages and perform cleanup. Default is `false` (immediate abort).
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'medium'`.
      * @returns The updated ActorRun object with `ABORTING` or `ABORTED` status
      * @see https://docs.apify.com/api/v2/actor-run-abort-post
      *
@@ -101,22 +110,27 @@ export class RunClient extends ResourceClient {
      * ```
      */
     async abort(options = {}) {
-        const parsed = parseArgument(options, abortOptionsSchema, 'RunAbortOptions');
+        const { timeoutSecs = 'medium', signal, ...params } = parseArgument(options, abortOptionsSchema, 'RunAbortOptions');
         const response = await this.httpClient.call({
-            url: this._url('abort'),
+            url: this.buildUrl('abort'),
             method: 'POST',
-            params: this._params(parsed),
+            params: this.buildParams(params),
+            timeoutSecs,
+            signal,
         });
-        return cast(parseDateFields(pluckData(response.data)));
+        return parseResponse(response, schemas.Run());
     }
     /**
      * Deletes the Actor run.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @see https://docs.apify.com/api/v2/actor-run-delete
      * @since Added in 2.8.1
      */
-    async delete() {
-        return this._delete();
+    async delete(options = {}) {
+        const { timeoutSecs = 'short', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.deleteResource(timeoutSecs, signal);
     }
     /**
      * Transforms the Actor run into a run of another Actor (metamorph).
@@ -126,10 +140,11 @@ export class RunClient extends ResourceClient {
      * This is useful for chaining Actor executions or implementing complex workflows.
      *
      * @param targetActorId - ID or username/name of the target Actor
-     * @param input - Input for the target Actor. Can be any JSON-serializable value.
+     * @param input - Input for the target Actor: an object or array serialized to JSON, or raw bytes sent as they
+     *                are. Omit it to metamorph without input.
      * @param options - Metamorph options
      * @param options.build - Tag or number of the target Actor's build to run. Default is the target Actor's 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 `'medium'`.
      * @returns The metamorphed ActorRun object (same ID, but now running the target Actor)
      * @see https://docs.apify.com/api/v2/actor-run-metamorph-post
      *
@@ -145,23 +160,21 @@ export class RunClient extends ResourceClient {
      */
     async metamorph(targetActorId, input, options = {}) {
         parseArgument(targetActorId, targetActorIdSchema);
-        // input can be anything, pointless to validate
         const parsed = parseArgument(options, metamorphOptionsSchema, 'RunMetamorphOptions');
-        const safeTargetActorId = this._toSafeId(targetActorId);
+        const safeTargetActorId = this.toSafeId(targetActorId);
         const params = {
             targetActorId: safeTargetActorId,
             build: parsed.build,
         };
         const request = {
-            url: this._url('metamorph'),
+            url: this.buildUrl('metamorph'),
             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.
-            // TODO: remove this ts-expect-error once we have defined custom Apify axios configs
-            // @ts-expect-error Custom Apify property
+            params: this.buildParams(params),
+            // Actor input may carry page functions, which plain JSON serialization would drop.
             stringifyFunctions: true,
+            timeoutSecs: parsed.timeoutSecs ?? 'medium',
+            signal: parsed.signal,
         };
         if (parsed.contentType) {
             request.headers = {
@@ -169,7 +182,7 @@ export class RunClient extends ResourceClient {
             };
         }
         const response = await this.httpClient.call(request);
-        return cast(parseDateFields(pluckData(response.data)));
+        return parseResponse(response, schemas.Run());
     }
     /**
      * Reboots the Actor run.
@@ -178,6 +191,8 @@ export class RunClient extends ResourceClient {
      * This can be useful to recover from certain errors or to force the Actor to restart
      * with a fresh environment.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'medium'`.
      * @returns The updated ActorRun object
      * @see https://docs.apify.com/api/v2/actor-run-reboot-post
      *
@@ -187,13 +202,16 @@ export class RunClient extends ResourceClient {
      * ```
      * @since Added in 2.8.0
      */
-    async reboot() {
+    async reboot(options = {}) {
+        const { timeoutSecs = 'medium', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
         const request = {
-            url: this._url('reboot'),
+            url: this.buildUrl('reboot'),
             method: 'POST',
+            timeoutSecs,
+            signal,
         };
         const response = await this.httpClient.call(request);
-        return cast(parseDateFields(pluckData(response.data)));
+        return parseResponse(response, schemas.Run());
     }
     /**
      * Updates the Actor run with specified fields.
@@ -202,6 +220,8 @@ export class RunClient extends ResourceClient {
      * @param newFields.statusMessage - Custom status message to display (e.g., "Processing page 10/100")
      * @param newFields.isStatusMessageTerminal - If `true`, the status message is final and won't be overwritten. Default is `false`.
      * @param newFields.generalAccess - General resource access level ('FOLLOW_USER_SETTING', 'ANYONE_WITH_ID_CAN_READ' or 'RESTRICTED')
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The updated ActorRun object
      *
      * @example
@@ -213,9 +233,10 @@ export class RunClient extends ResourceClient {
      * ```
      * @since Added in 2.6.0
      */
-    async update(newFields) {
+    async update(newFields, options = {}) {
         parseArgument(newFields, anyObjectSchema);
-        return this._update(newFields);
+        const { timeoutSecs = 'short', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.updateResource(schemas.Run(), newFields, timeoutSecs, signal);
     }
     /**
      * Resurrects a finished Actor run, starting it again with the same settings.
@@ -226,10 +247,11 @@ export class RunClient extends ResourceClient {
      * @param options - Resurrection options (override original run settings)
      * @param options.build - Tag or number of the build to use. If not provided, uses the original run's build.
      * @param options.memory - Memory in megabytes. If not provided, uses the original run's memory.
-     * @param options.timeout - Timeout in seconds. If not provided, uses the original run's timeout.
+     * @param options.runTimeoutSecs - Timeout for the resurrected run in seconds. If not provided, uses the original run's timeout.
      * @param options.maxItems - Maximum number of dataset items (pay-per-result Actors).
      * @param options.maxTotalChargeUsd - Maximum cost in USD (pay-per-event Actors).
      * @param options.restartOnError - Whether to restart on error.
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'medium'`.
      * @returns The new (resurrected) ActorRun object
      * @see https://docs.apify.com/api/v2/post-resurrect-run
      *
@@ -241,13 +263,16 @@ export class RunClient extends ResourceClient {
      * ```
      */
     async resurrect(options = {}) {
-        const parsed = parseArgument(options, resurrectOptionsSchema, 'RunResurrectOptions');
+        const { timeoutSecs = 'medium', signal, runTimeoutSecs, ...params } = parseArgument(options, resurrectOptionsSchema, 'RunResurrectOptions');
         const response = await this.httpClient.call({
-            url: this._url('resurrect'),
+            url: this.buildUrl('resurrect'),
             method: 'POST',
-            params: this._params(parsed),
+            // The API's `timeout` parameter bounds the run, not the request.
+            params: this.buildParams({ ...params, timeout: runTimeoutSecs }),
+            timeoutSecs,
+            signal,
         });
-        return cast(parseDateFields(pluckData(response.data)));
+        return parseResponse(response, schemas.Run());
     }
     /**
      * Charges the Actor run for a specific event.
@@ -256,17 +281,18 @@ export class RunClient extends ResourceClient {
      * @param options.eventName - **Required.** Name of the event to charge for.
      * @param options.count - Number of times to charge the event. Default is 1.
      * @param options.idempotencyKey - Optional key to ensure the charge is not duplicated. If not provided, one is auto-generated.
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns Empty response object.
      * @see https://docs.apify.com/api/v2/post-charge-run
      * @since Added in 2.11.0
      */
     async charge(options) {
-        const { eventName, count, idempotencyKey: providedIdempotencyKey, } = parseArgument(options, chargeOptionsSchema, 'RunChargeOptions');
+        const { eventName, count, idempotencyKey: providedIdempotencyKey, timeoutSecs = 'short', signal, } = parseArgument(options, chargeOptionsSchema, 'RunChargeOptions');
         /** To avoid duplicates during the same milisecond, doesn't need to by crypto-secure. */
         const randomSuffix = (Math.random() + 1).toString(36).slice(3, 8);
         const idempotencyKey = providedIdempotencyKey ?? `${this.id}-${eventName}-${Date.now()}-${randomSuffix}`;
         const request = {
-            url: this._url('charge'),
+            url: this.buildUrl('charge'),
             method: 'POST',
             data: {
                 eventName,
@@ -275,6 +301,8 @@ export class RunClient extends ResourceClient {
             headers: {
                 [RUN_CHARGE_IDEMPOTENCY_HEADER]: idempotencyKey,
             },
+            timeoutSecs,
+            signal,
         };
         const response = await this.httpClient.call(request);
         return response;
@@ -292,7 +320,8 @@ export class RunClient extends ResourceClient {
      *
      * @param options - Wait options
      * @param options.waitSecs - Maximum time to wait for the run to finish, in seconds. If the limit is reached, the returned promise resolves to a run object that will have status `READY` or `RUNNING`. If omitted, waits indefinitely.
-     * @returns The ActorRun object (finished or still running if timeout was reached)
+     * @param options.timeoutSecs - Timeout for each polling API request. Default is `'noTimeout'`.
+     * @returns The ActorRun object (finished or still running if the timeout was reached)
      *
      * @example
      * ```javascript
@@ -309,11 +338,13 @@ export class RunClient extends ResourceClient {
      */
     async waitForFinish(options = {}) {
         const parsed = parseArgument(options, waitForFinishOptionsSchema, 'RunWaitForFinishOptions');
-        return this._waitForFinish(parsed);
+        return this.waitForJobFinish(schemas.Run(), parsed);
     }
     /**
      * Returns a client for the default dataset of this Actor run.
      *
+     * A 404 from this client throws an `ApifyApiError`, since the run itself may be what is missing.
+     *
      * @returns A client for accessing the run's default dataset
      * @see https://docs.apify.com/api/v2/actor-run-get
      *
@@ -324,13 +355,16 @@ export class RunClient extends ResourceClient {
      * ```
      */
     dataset() {
-        return new DatasetClient(this._subResourceOptions({
+        return new DatasetClient(this.subResourceOptions({
             resourcePath: 'dataset',
         }));
     }
     /**
      * Returns a client for the default key-value store of this Actor run.
      *
+     * `get()` and `delete()` throw an `ApifyApiError` on a 404, since the run itself may be what is missing. Record
+     * lookups such as `getRecord()` read a 404 as a missing record.
+     *
      * @returns A client for accessing the run's default key-value store
      * @see https://docs.apify.com/api/v2/actor-run-get
      *
@@ -341,13 +375,16 @@ export class RunClient extends ResourceClient {
      * ```
      */
     keyValueStore() {
-        return new KeyValueStoreClient(this._subResourceOptions({
+        return new KeyValueStoreClient(this.subResourceOptions({
             resourcePath: 'key-value-store',
         }));
     }
     /**
      * Returns a client for the default Request queue of this Actor run.
      *
+     * `get()` and `delete()` throw an `ApifyApiError` on a 404, since the run itself may be what is missing.
+     * `getRequest()` reads a 404 as a missing request.
+     *
      * @returns A client for accessing the run's default Request queue
      * @see https://docs.apify.com/api/v2/actor-run-get
      *
@@ -358,13 +395,15 @@ export class RunClient extends ResourceClient {
      * ```
      */
     requestQueue() {
-        return new RequestQueueClient(this._subResourceOptions({
+        return new RequestQueueClient(this.subResourceOptions({
             resourcePath: 'request-queue',
         }));
     }
     /**
      * Returns a client for accessing the log of this Actor run.
      *
+     * A 404 from this client throws an `ApifyApiError`, since the run itself may be what is missing.
+     *
      * @returns A client for accessing the run's log
      * @see https://docs.apify.com/api/v2/actor-run-get
      *
@@ -376,32 +415,40 @@ export class RunClient extends ResourceClient {
      * ```
      */
     log() {
-        return new LogClient(this._subResourceOptions({
+        return new LogClient(this.subResourceOptions({
             resourcePath: 'log',
         }));
     }
     /**
      * Get StreamedLog for convenient streaming of the run log and their redirection.
+     *
+     * @param options - Streaming options
+     * @param options.toLog - Log instance to redirect the run log to. Use `'default'` for a preconfigured one, or `null` to disable the redirection.
+     * @param options.fromStart - If `true`, the log is streamed from its beginning. Default is `true`.
+     * @param options.timeoutSecs - Timeout for the API requests that fetch the run and its Actor. Default is `'long'`.
      * @since Added in 2.20.0
      */
     async getStreamedLog(options = {}) {
-        const { fromStart = true } = options;
+        parseArgument(options.timeoutSecs, optionalTimeoutSchema);
+        parseArgument(options.signal, optionalSignalSchema);
+        const { fromStart = true, timeoutSecs = 'long', signal } = options;
         let { toLog } = options;
-        if (toLog === null || !isNode()) {
+        if (toLog === null || !runtime.isNode) {
             // Explicitly no logging or not in Node.js
             return undefined;
         }
         if (toLog === undefined || toLog === 'default') {
             // Create default StreamedLog
             // Get actor name and run id
-            const runData = await this.get();
+            const runData = await this.get({ timeoutSecs, signal });
             const runId = runData?.id ?? '';
             const actorId = runData?.actId ?? '';
-            const actorData = (await this.apifyClient.actor(actorId).get()) || { name: '' };
+            // `apifyClient.actor()` rejects an empty ID, which is what a run that could not be read leaves here.
+            const actorData = actorId ? await this.apifyClient.actor(actorId).get({ timeoutSecs, signal }) : undefined;
             const actorName = actorData?.name ?? '';
             const name = [actorName, `runId:${runId}`].filter(Boolean).join(' ');
             toLog = new Log({ level: LEVELS.DEBUG, prefix: `${name} -> `, logger: new LoggerActorRedirect() });
         }
-        return new StreamedLog({ logClient: this.log(), toLog, fromStart });
+        return new StreamedLog({ logClient: this.log(), toLog, fromStart, signal });
     }
 }

package/dist/resource_clients/run_collection.d.ts

@@ -1,6 +1,7 @@
 import { ACTOR_JOB_STATUSES } from '@apify/consts';
 import type { ApiClientOptionsWithOptionalResourcePath } from '../base/api_client.js';
 import { ResourceCollectionClient } from '../base/resource_collection_client.js';
+import type { TimeoutOptions } from '../timeouts.js';
 import type { PaginatedIterator, PaginationOptions } from '../utils.js';
 import type { ActorRunListItem } from './actor.js';
 /**
@@ -46,12 +47,13 @@ export declare class RunCollectionClient extends ResourceCollectionClient {
      * ```
      *
      * @param options - Pagination and filtering options.
+     * @param options.timeoutSecs - Timeout for each API request. Default is `'medium'`.
      * @returns A paginated iterator of Actor runs.
      * @see https://docs.apify.com/api/v2/actor-runs-get
      */
     list(options?: RunCollectionListOptions): PaginatedIterator<ActorRunListItem>;
 }
-export interface RunCollectionListOptions extends PaginationOptions {
+export interface RunCollectionListOptions extends PaginationOptions, TimeoutOptions {
     desc?: boolean;
     status?: (typeof ACTOR_JOB_STATUSES)[keyof typeof ACTOR_JOB_STATUSES] | (typeof ACTOR_JOB_STATUSES)[keyof typeof ACTOR_JOB_STATUSES][];
     /**

package/dist/resource_clients/run_collection.js

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import { ACTOR_JOB_STATUSES } from '@apify/consts';
 import { ResourceCollectionClient } from '../base/resource_collection_client.js';
+import * as schemas from '../schemas.js';
+import { timeoutOptionsShape } from '../timeouts.js';
 import { paginationOptionsShape, parseArgument } from '../utils.js';
 const jobStatusSchema = z.enum(ACTOR_JOB_STATUSES);
 const listOptionsSchema = z.strictObject({
@@ -9,6 +11,7 @@ const listOptionsSchema = z.strictObject({
     status: z.union([jobStatusSchema, z.array(jobStatusSchema)]).optional(),
     startedBefore: z.union([z.date(), z.string()]).optional(),
     startedAfter: z.union([z.date(), z.string()]).optional(),
+    ...timeoutOptionsShape,
 });
 /**
  * Client for managing the collection of Actor runs.
@@ -58,11 +61,12 @@ export class RunCollectionClient extends ResourceCollectionClient {
      * ```
      *
      * @param options - Pagination and filtering options.
+     * @param options.timeoutSecs - Timeout for each API request. Default is `'medium'`.
      * @returns A paginated iterator of Actor runs.
      * @see https://docs.apify.com/api/v2/actor-runs-get
      */
     list(options = {}) {
         const parsed = parseArgument(options, listOptionsSchema, 'RunCollectionListOptions');
-        return this._listPaginated(parsed);
+        return this.listResourcesPaginated(schemas.ListOfRuns(), parsed, 'medium');
     }
 }

package/dist/resource_clients/schedule.d.ts

@@ -1,8 +1,9 @@
 import type { ApiClientSubResourceOptions } from '../base/api_client.js';
 import { ResourceClient } from '../base/resource_client.js';
-import type { Schedule, ScheduleAction } from '../models.js';
+import type { Schedule, ScheduleAction, ScheduleInvoked } from '../models.js';
+import type { TimeoutOptions } from '../timeouts.js';
 import type { DistributiveOptional } from '../utils.js';
-export type { Schedule, ScheduleAction, ScheduleActionRunActor, ScheduleActionRunActorTask, ScheduledActorRunInput, ScheduledActorRunOptions, } from '../models.js';
+export type { Schedule, ScheduleAction, ScheduleActionRunActor, ScheduleActionRunActorTask, ScheduledActorRunInput, ScheduledActorRunOptions, ScheduleInvoked, } from '../models.js';
 export { ScheduleActions } from '../models.js';
 /**
  * Client for managing a specific Schedule.
@@ -35,31 +36,39 @@ export declare class ScheduleClient extends ResourceClient {
     /**
      * Retrieves the schedule.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The schedule object, or `undefined` if it does not exist.
      * @see https://docs.apify.com/api/v2/schedule-get
      */
-    get(): Promise<Schedule | undefined>;
+    get(options?: TimeoutOptions): Promise<Schedule | undefined>;
     /**
      * Updates the schedule with the specified fields.
      *
      * @param newFields - Fields to update.
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The updated schedule object.
      * @see https://docs.apify.com/api/v2/schedule-put
      */
-    update(newFields: ScheduleCreateOrUpdateData): Promise<Schedule>;
+    update(newFields: ScheduleCreateOrUpdateData, options?: TimeoutOptions): Promise<Schedule>;
     /**
      * Deletes the schedule.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @see https://docs.apify.com/api/v2/schedule-delete
      */
-    delete(): Promise<void>;
+    delete(options?: TimeoutOptions): Promise<void>;
     /**
      * Retrieves the schedule's log.
      *
-     * @returns The schedule log as a string, or `undefined` if it does not exist.
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'medium'`.
+     * @returns The schedule log, one entry per invocation.
      * @see https://docs.apify.com/api/v2/schedule-log-get
      */
-    getLog(): Promise<string | undefined>;
+    getLog(options?: TimeoutOptions): Promise<ScheduleInvoked[]>;
 }
 /**
  * Data for creating or updating a Schedule.

package/dist/resource_clients/schedule.js

@@ -1,6 +1,10 @@
+import { z } from 'zod';
 import { ResourceClient } from '../base/resource_client.js';
-import { anyObjectSchema, cast, catchNotFoundOrThrow, parseArgument, parseDateFields, pluckData } from '../utils.js';
+import * as schemas from '../schemas.js';
+import { timeoutOptionsSchema } from '../timeouts.js';
+import { anyObjectSchema, parseArgument, parseResponse } from '../utils.js';
 export { ScheduleActions } from '../models.js';
+const scheduleLogSchema = z.array(schemas.ScheduleInvoked());
 /**
  * Client for managing a specific Schedule.
  *
@@ -37,50 +41,57 @@ export class ScheduleClient extends ResourceClient {
     /**
      * Retrieves the schedule.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The schedule object, or `undefined` if it does not exist.
      * @see https://docs.apify.com/api/v2/schedule-get
      */
-    async get() {
-        return this._get();
+    async get(options = {}) {
+        const { timeoutSecs = 'short', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.getResource(schemas.Schedule(), {}, timeoutSecs, signal);
     }
     /**
      * Updates the schedule with the specified fields.
      *
      * @param newFields - Fields to update.
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The updated schedule object.
      * @see https://docs.apify.com/api/v2/schedule-put
      */
-    async update(newFields) {
+    async update(newFields, options = {}) {
         parseArgument(newFields, anyObjectSchema);
-        return this._update(newFields);
+        const { timeoutSecs = 'short', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.updateResource(schemas.Schedule(), newFields, timeoutSecs, signal);
     }
     /**
      * Deletes the schedule.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @see https://docs.apify.com/api/v2/schedule-delete
      */
-    async delete() {
-        return this._delete();
+    async delete(options = {}) {
+        const { timeoutSecs = 'short', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.deleteResource(timeoutSecs, signal);
     }
     /**
      * Retrieves the schedule's log.
      *
-     * @returns The schedule log as a string, or `undefined` if it does not exist.
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'medium'`.
+     * @returns The schedule log, one entry per invocation.
      * @see https://docs.apify.com/api/v2/schedule-log-get
      */
-    async getLog() {
-        const requestOpts = {
-            url: this._url('log'),
+    async getLog(options = {}) {
+        const { timeoutSecs = 'medium', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        const response = await this.httpClient.call({
+            url: this.buildUrl('log'),
             method: 'GET',
-            params: this._params(),
-        };
-        try {
-            const response = await this.httpClient.call(requestOpts);
-            return cast(parseDateFields(pluckData(response.data)));
-        }
-        catch (err) {
-            catchNotFoundOrThrow(err);
-        }
-        return undefined;
+            params: this.buildParams(),
+            timeoutSecs,
+            signal,
+        });
+        return parseResponse(response, scheduleLogSchema);
     }
 }

package/dist/resource_clients/schedule_collection.d.ts

@@ -1,5 +1,6 @@
 import type { ApiClientSubResourceOptions } from '../base/api_client.js';
 import { ResourceCollectionClient } from '../base/resource_collection_client.js';
+import type { TimeoutOptions } from '../timeouts.js';
 import type { PaginatedIterator, PaginationOptions } from '../utils.js';
 import type { Schedule, ScheduleCreateOrUpdateData } from './schedule.js';
 /**
@@ -48,6 +49,7 @@ export declare class ScheduleCollectionClient extends ResourceCollectionClient {
      * ```
      *
      * @param options - Pagination and sorting options.
+     * @param options.timeoutSecs - Timeout for each API request. Default is `'medium'`.
      * @returns A paginated iterator of schedules.
      * @see https://docs.apify.com/api/v2/schedules-get
      */
@@ -56,11 +58,13 @@ export declare class ScheduleCollectionClient extends ResourceCollectionClient {
      * Creates a new schedule.
      *
      * @param schedule - The schedule data.
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The created schedule object.
      * @see https://docs.apify.com/api/v2/schedules-post
      */
-    create(schedule?: ScheduleCreateOrUpdateData): Promise<Schedule>;
+    create(schedule?: ScheduleCreateOrUpdateData, options?: TimeoutOptions): Promise<Schedule>;
 }
-export interface ScheduleCollectionListOptions extends PaginationOptions {
+export interface ScheduleCollectionListOptions extends PaginationOptions, TimeoutOptions {
     desc?: boolean;
 }