@crawlee/utils 4.0.0-beta.23 → 4.0.0-beta.230

package/internals/iterables.d.ts

@@ -26,85 +26,6 @@ export declare function isIterable<T>(value: unknown): value is Iterable<T>;
  * ```
  */
 export declare function isAsyncIterable<T>(value: unknown): value is AsyncIterable<T>;
-/**
- * Converts any iterable or async iterable to an async iterable.
- * @internal
- *
- * @yields Each item from the input iterable
- *
- * **Example usage:**
- * ```ts
- * const syncArray = [1, 2, 3];
- * for await (const item of asyncifyIterable(syncArray)) {
- *   console.log(item); // 1, 2, 3
- * }
- * ```
- */
-export declare function asyncifyIterable<T>(iterable: Iterable<T> | AsyncIterable<T>): AsyncIterable<T>;
-/**
- * Lazily splits the input async iterable into chunks of specified size.
- * The last chunk may contain fewer items if the total number of items
- * is not evenly divisible by the chunk size.
- * @internal
- *
- * @yields Arrays of items, each containing up to chunkSize items
- *
- * **Example usage:**
- * ```ts
- * const numbers = async function* () {
- *   for (let i = 1; i <= 10; i++) yield i;
- * };
- *
- * for await (const chunk of chunkedAsyncIterable(numbers(), 3)) {
- *   console.log(chunk); // [1, 2, 3], [4, 5, 6], [7, 8, 9], [10]
- * }
- * ```
- */
-export declare function chunkedAsyncIterable<T>(iterable: AsyncIterable<T> | Iterable<T>, chunkSize: number): AsyncIterable<T[]>;
-/**
- * An async iterator that also supports peeking at the next value without consuming it.
- * Extends both AsyncIterator and AsyncIterable interfaces.
- * @internal
- */
-export interface PeekableAsyncIterator<T> extends AsyncIterator<T>, AsyncIterable<T> {
-    /**
-     * Peeks at the next value without consuming it from the iterator.
-     * Subsequent calls to peek() will return the same value until next() is called.
-     *
-     * @returns Promise that resolves to the next value, or undefined if the iterator is exhausted
-     */
-    peek(): Promise<T | undefined>;
-}
-/**
- * An async iterable that yields peekable async iterators.
- * @internal
- */
-export interface PeekableAsyncIterable<T> extends AsyncIterable<T> {
-    [Symbol.asyncIterator](): PeekableAsyncIterator<T>;
-}
-/**
- * Wraps an async iterable to provide peek functionality, allowing you to look at
- * the next value without consuming it from the iterator.
- * @internal
- *
- * @param iterable - The async iterable to make peekable
- *
- * **Example usage:**
- * ```ts
- * const numbers = async function* () {
- *   yield 1; yield 2; yield 3;
- * };
- *
- * const peekable = peekableAsyncIterable(numbers());
- * const iterator = peekable[Symbol.asyncIterator]();
- *
- * console.log(await iterator.peek()); // 1 (doesn't consume)
- * console.log(await iterator.peek()); // 1 (still doesn't consume)
- * console.log(await iterator.next()); // { value: 1, done: false } (now consumed)
- * console.log(await iterator.peek()); // 2 (next value)
- * ```
- */
-export declare function peekableAsyncIterable<T>(iterable: AsyncIterable<T> | Iterable<T>): PeekableAsyncIterable<T>;
 /**
  * Merges multiple async iterables into a single async iterable, yielding values concurrently.
  *
@@ -124,4 +45,3 @@ export declare function peekableAsyncIterable<T>(iterable: AsyncIterable<T> | It
  * ```
  */
 export declare function mergeAsyncIterables<T>(...iterables: AsyncIterable<T>[]): AsyncIterable<T>;
-//# sourceMappingURL=iterables.d.ts.map

package/internals/iterables.js

@@ -1,4 +1,3 @@
-import { inspect } from 'node:util';
 /**
  * Type guard that checks if a value is iterable (has Symbol.iterator).
  * @internal
@@ -40,130 +39,6 @@ export function isAsyncIterable(value) {
     }
     return typeof Object(value)[Symbol.asyncIterator] === 'function';
 }
-/**
- * Converts any iterable or async iterable to an async iterable.
- * @internal
- *
- * @yields Each item from the input iterable
- *
- * **Example usage:**
- * ```ts
- * const syncArray = [1, 2, 3];
- * for await (const item of asyncifyIterable(syncArray)) {
- *   console.log(item); // 1, 2, 3
- * }
- * ```
- */
-export async function* asyncifyIterable(iterable) {
-    yield* iterable;
-}
-/**
- * Lazily splits the input async iterable into chunks of specified size.
- * The last chunk may contain fewer items if the total number of items
- * is not evenly divisible by the chunk size.
- * @internal
- *
- * @yields Arrays of items, each containing up to chunkSize items
- *
- * **Example usage:**
- * ```ts
- * const numbers = async function* () {
- *   for (let i = 1; i <= 10; i++) yield i;
- * };
- *
- * for await (const chunk of chunkedAsyncIterable(numbers(), 3)) {
- *   console.log(chunk); // [1, 2, 3], [4, 5, 6], [7, 8, 9], [10]
- * }
- * ```
- */
-export async function* chunkedAsyncIterable(iterable, chunkSize) {
-    if (typeof chunkSize !== 'number' || chunkSize < 1) {
-        throw new Error(`Chunk size must be a positive number (${inspect(chunkSize)}) received`);
-    }
-    let chunk = [];
-    for await (const item of iterable) {
-        chunk.push(item);
-        if (chunk.length >= chunkSize) {
-            yield chunk;
-            chunk = [];
-        }
-    }
-    if (chunk.length) {
-        yield chunk;
-    }
-}
-/**
- * Wraps an async iterable to provide peek functionality, allowing you to look at
- * the next value without consuming it from the iterator.
- * @internal
- *
- * @param iterable - The async iterable to make peekable
- *
- * **Example usage:**
- * ```ts
- * const numbers = async function* () {
- *   yield 1; yield 2; yield 3;
- * };
- *
- * const peekable = peekableAsyncIterable(numbers());
- * const iterator = peekable[Symbol.asyncIterator]();
- *
- * console.log(await iterator.peek()); // 1 (doesn't consume)
- * console.log(await iterator.peek()); // 1 (still doesn't consume)
- * console.log(await iterator.next()); // { value: 1, done: false } (now consumed)
- * console.log(await iterator.peek()); // 2 (next value)
- * ```
- */
-export function peekableAsyncIterable(iterable) {
-    const iterator = asyncifyIterable(iterable)[Symbol.asyncIterator]();
-    let peekedValue;
-    let isExhausted = false;
-    const peekableIterator = {
-        async next() {
-            // If we have peeked a value, return it and clear the peek
-            if (peekedValue !== undefined) {
-                const result = peekedValue;
-                peekedValue = undefined;
-                if (result.done) {
-                    isExhausted = true;
-                    return { done: true, value: undefined };
-                }
-                return { done: false, value: result.value };
-            }
-            if (isExhausted) {
-                return { done: true, value: undefined };
-            }
-            const result = await iterator.next();
-            if (result.done) {
-                isExhausted = true;
-            }
-            return result;
-        },
-        async peek() {
-            if (peekedValue !== undefined) {
-                return peekedValue.done ? undefined : peekedValue.value;
-            }
-            if (isExhausted) {
-                return undefined;
-            }
-            const result = await iterator.next();
-            peekedValue = { done: result.done ?? false, value: result.value };
-            if (result.done) {
-                isExhausted = true;
-                return undefined;
-            }
-            return result.value;
-        },
-        [Symbol.asyncIterator]() {
-            return this;
-        },
-    };
-    return {
-        [Symbol.asyncIterator]() {
-            return peekableIterator;
-        },
-    };
-}
 // Source - https://stackoverflow.com/a/71288323
 /**
  * Merges multiple async iterables into a single async iterable, yielding values concurrently.
@@ -219,4 +94,3 @@ export async function* mergeAsyncIterables(...iterables) {
     }
     return results;
 }
-//# sourceMappingURL=iterables.js.map

package/internals/{open_graph_parser.d.ts → open-graph-parser.d.ts}

@@ -14,7 +14,6 @@ type OpenGraphResult = string | string[] | Dictionary<string | Dictionary>;
  * Currently existing properties are kept up to date.
  * @returns Scraped OpenGraph properties as an object.
  */
-export declare function parseOpenGraph(raw: string, additionalProperties?: OpenGraphProperty[]): Dictionary<OpenGraphResult>;
-export declare function parseOpenGraph($: CheerioAPI, additionalProperties?: OpenGraphProperty[]): Dictionary<OpenGraphResult>;
+export declare function parseOpenGraph(raw: string, additionalProperties?: OpenGraphProperty[]): Promise<Dictionary<OpenGraphResult>>;
+export declare function parseOpenGraph($: CheerioAPI, additionalProperties?: OpenGraphProperty[]): Promise<Dictionary<OpenGraphResult>>;
 export {};
-//# sourceMappingURL=open_graph_parser.d.ts.map

package/internals/{open_graph_parser.js → open-graph-parser.js}

@@ -1,4 +1,3 @@
-import { load } from 'cheerio';
 /**
  * To be used with the spread operator. Ensures that the item is defined, and is not empty.
  *
@@ -255,32 +254,32 @@ const OPEN_GRAPH_PROPERTIES = [
         outputName: 'articleInfo',
         children: [
             {
-                name: 'music:published_time',
+                name: 'article:published_time',
                 outputName: 'publishedTime',
                 children: [],
             },
             {
-                name: 'music:modified_time',
+                name: 'article:modified_time',
                 outputName: 'modifiedTime',
                 children: [],
             },
             {
-                name: 'music:expiration_time',
+                name: 'article:expiration_time',
                 outputName: 'expirationTime',
                 children: [],
             },
             {
-                name: 'music:author',
+                name: 'article:author',
                 outputName: 'author',
                 children: [],
             },
             {
-                name: 'music:section',
+                name: 'article:section',
                 outputName: 'section',
                 children: [],
             },
             {
-                name: 'music:tag',
+                name: 'article:tag',
                 outputName: 'tag',
                 children: [],
             },
@@ -366,7 +365,8 @@ const parseOpenGraphProperty = (property, $) => {
         }, {}),
     };
 };
-export function parseOpenGraph(item, additionalProperties) {
+export async function parseOpenGraph(item, additionalProperties) {
+    const { load } = await import('cheerio/slim');
     const $ = typeof item === 'string' ? load(item) : item;
     return [...(additionalProperties || []), ...OPEN_GRAPH_PROPERTIES].reduce((acc, curr) => {
         return {
@@ -375,4 +375,3 @@ export function parseOpenGraph(item, additionalProperties) {
         };
     }, {});
 }
-//# sourceMappingURL=open_graph_parser.js.map

package/internals/robots.d.ts

@@ -1,5 +1,15 @@
-import type { BaseHttpClient } from '@crawlee/types';
+import type { BaseHttpClient } from '@crawlee/http-client';
+import type { CrawleeLogger } from '@crawlee/types';
 import { Sitemap } from './sitemap.js';
+import { type EnqueueStrategy } from './url.js';
+export interface RobotsTxtFileSitemapsOptions {
+    /**
+     * Keep only sitemap URLs matching this strategy relative to the robots.txt host; non-`http(s)` schemes
+     * are always dropped. Pass `'all'` to disable host filtering.
+     * @default 'same-hostname'
+     */
+    enqueueStrategy?: EnqueueStrategy | `${EnqueueStrategy}`;
+}
 /**
  * Loads and queries information from a [robots.txt file](https://en.wikipedia.org/wiki/Robots.txt).
  *
@@ -19,17 +29,22 @@ import { Sitemap } from './sitemap.js';
  * ```
  */
 export declare class RobotsTxtFile {
-    private robots;
-    private proxyUrl?;
+    #private;
     private constructor();
     /**
      * Determine the location of a robots.txt file for a URL and fetch it.
      * @param url the URL to fetch robots.txt for
-     * @param [proxyUrl] a proxy to be used for fetching the robots.txt file
+     * @param [options] additional options
+     * @param [options.signal] an AbortSignal to cancel the request
+     * @param [options.timeoutMillis] timeout in milliseconds for the request
+     * @param [options.proxyUrl] a proxy to be used for fetching the robots.txt file
      */
     static find(url: string, options?: {
+        signal?: AbortSignal;
+        timeoutMillis?: number;
         proxyUrl?: string;
         httpClient?: BaseHttpClient;
+        logger?: CrawleeLogger;
     }): Promise<RobotsTxtFile>;
     /**
      * Allows providing the URL and robots.txt content explicitly instead of loading it from the target site.
@@ -38,10 +53,11 @@ export declare class RobotsTxtFile {
      * @param [proxyUrl] a proxy to be used for fetching the robots.txt file
      */
     static from(url: string, content: string, proxyUrl?: string): RobotsTxtFile;
-    protected static load(url: string, options?: {
-        proxyUrl?: string;
-        httpClient?: BaseHttpClient;
-    }): Promise<RobotsTxtFile>;
+    /**
+     * Get crawl delay for a given user agent.
+     * @param [userAgent] relevant user agent, default to `*`
+     */
+    getCrawlDelay(userAgent?: string): number | undefined;
     /**
      * Check if a URL should be crawled by robots.
      * @param url the URL to check against the rules in robots.txt
@@ -49,17 +65,19 @@ export declare class RobotsTxtFile {
      */
     isAllowed(url: string, userAgent?: string): boolean;
     /**
-     * Get URLs of sitemaps referenced in the robots file.
+     * Get URLs of sitemaps referenced in the robots file, filtered by `options.enqueueStrategy` relative to
+     * the robots.txt host (default `'same-hostname'`; pass `'all'` to disable). Non-`http(s)` schemes are
+     * always dropped.
      */
-    getSitemaps(): string[];
+    getSitemaps(options?: RobotsTxtFileSitemapsOptions): string[];
     /**
-     * Parse all the sitemaps referenced in the robots file.
+     * Parse all the sitemaps referenced in the robots file. `options` are forwarded to `getSitemaps`
+     * and the sitemap parser.
      */
-    parseSitemaps(): Promise<Sitemap>;
+    parseSitemaps(options?: RobotsTxtFileSitemapsOptions): Promise<Sitemap>;
     /**
      * Get all URLs from all the sitemaps referenced in the robots file. A shorthand for `(await robots.parseSitemaps()).urls`.
+     * `options` are forwarded to `parseSitemaps`.
      */
-    parseUrlsFromSitemaps(): Promise<string[]>;
+    parseUrlsFromSitemaps(options?: RobotsTxtFileSitemapsOptions): Promise<string[]>;
 }
-export { RobotsTxtFile as RobotsFile };
-//# sourceMappingURL=robots.d.ts.map

package/internals/robots.js

@@ -1,6 +1,7 @@
 import { FetchHttpClient } from '@crawlee/http-client';
 import robotsParser from 'robots-parser';
 import { Sitemap } from './sitemap.js';
+import { filterUrl } from './url.js';
 /**
  * Loads and queries information from a [robots.txt file](https://en.wikipedia.org/wiki/Robots.txt).
  *
@@ -20,22 +21,29 @@ import { Sitemap } from './sitemap.js';
  * ```
  */
 export class RobotsTxtFile {
-    robots;
-    proxyUrl;
-    constructor(robots, proxyUrl) {
-        this.robots = robots;
-        this.proxyUrl = proxyUrl;
+    #url;
+    #robots;
+    #proxyUrl;
+    #logger;
+    constructor(url, robots, proxyUrl, logger) {
+        this.#url = url;
+        this.#robots = robots;
+        this.#proxyUrl = proxyUrl;
+        this.#logger = logger;
     }
     /**
      * Determine the location of a robots.txt file for a URL and fetch it.
      * @param url the URL to fetch robots.txt for
-     * @param [proxyUrl] a proxy to be used for fetching the robots.txt file
+     * @param [options] additional options
+     * @param [options.signal] an AbortSignal to cancel the request
+     * @param [options.timeoutMillis] timeout in milliseconds for the request
+     * @param [options.proxyUrl] a proxy to be used for fetching the robots.txt file
      */
     static async find(url, options) {
         const robotsTxtFileUrl = new URL(url);
         robotsTxtFileUrl.pathname = '/robots.txt';
         robotsTxtFileUrl.search = '';
-        return RobotsTxtFile.load(robotsTxtFileUrl.toString(), options);
+        return RobotsTxtFile.#load(robotsTxtFileUrl.toString(), options);
     }
     /**
      * Allows providing the URL and robots.txt content explicitly instead of loading it from the target site.
@@ -45,28 +53,42 @@ export class RobotsTxtFile {
      */
     static from(url, content, proxyUrl) {
         // @ts-ignore
-        return new RobotsTxtFile(robotsParser(url, content), proxyUrl);
+        return new RobotsTxtFile(url, robotsParser(url, content), proxyUrl);
     }
-    static async load(url, options) {
-        const { proxyUrl, httpClient = new FetchHttpClient() } = options || {};
+    static async #load(url, options) {
+        const { proxyUrl, logger, httpClient = new FetchHttpClient() } = options || {};
         const response = await httpClient.sendRequest(new Request(url, { method: 'GET' }), {
             proxyUrl,
+            timeoutMillis: options?.timeoutMillis,
+            signal: options?.signal,
         });
-        if (response.status < 200 || response.status >= 300) {
-            throw new Error(`Failed to load robots.txt from ${url}: HTTP ${response.status}`);
-        }
-        if (response.status === 404) {
-            return new RobotsTxtFile({
+        // RFC 9309: an unavailable (4xx) robots.txt allows everything, an unreachable (5xx) one disallows everything.
+        if (response.status >= 400 && response.status < 600) {
+            const allowed = response.status < 500;
+            return new RobotsTxtFile(url, {
                 isAllowed() {
-                    return true;
+                    return allowed;
                 },
                 getSitemaps() {
                     return [];
                 },
-            }, proxyUrl);
+                getCrawlDelay() {
+                    return undefined;
+                },
+            }, proxyUrl, logger);
+        }
+        if (response.status < 200 || response.status >= 300) {
+            throw new Error(`Failed to load robots.txt from ${url}: HTTP ${response.status}`);
         }
         // @ts-ignore
-        return new RobotsTxtFile(robotsParser(url.toString(), await response.text()), proxyUrl);
+        return new RobotsTxtFile(url, robotsParser(url.toString(), await response.text()), proxyUrl, logger);
+    }
+    /**
+     * Get crawl delay for a given user agent.
+     * @param [userAgent] relevant user agent, default to `*`
+     */
+    getCrawlDelay(userAgent = '*') {
+        return this.#robots.getCrawlDelay(userAgent);
     }
     /**
      * Check if a URL should be crawled by robots.
@@ -74,27 +96,39 @@ export class RobotsTxtFile {
      * @param [userAgent] relevant user agent, default to `*`
      */
     isAllowed(url, userAgent = '*') {
-        return this.robots.isAllowed(url, userAgent) ?? true; // `undefined` means that there is no explicit rule for the requested URL - assume it's allowed
+        return this.#robots.isAllowed(url, userAgent) ?? true; // `undefined` means that there is no explicit rule for the requested URL - assume it's allowed
     }
     /**
-     * Get URLs of sitemaps referenced in the robots file.
+     * Get URLs of sitemaps referenced in the robots file, filtered by `options.enqueueStrategy` relative to
+     * the robots.txt host (default `'same-hostname'`; pass `'all'` to disable). Non-`http(s)` schemes are
+     * always dropped.
      */
-    getSitemaps() {
-        return this.robots.getSitemaps();
+    getSitemaps(options = {}) {
+        const { enqueueStrategy = 'same-hostname' } = options;
+        const sitemaps = [];
+        for (const sitemapUrl of this.#robots.getSitemaps()) {
+            // `filterUrl` tolerates an unparseable origin (returns not-allowed) rather than throwing.
+            const { allowed, reason } = filterUrl(sitemapUrl, this.#url, enqueueStrategy);
+            if (!allowed) {
+                this.#logger?.warning(`Skipping sitemap ${sitemapUrl} listed in robots.txt at ${this.#url}: ${reason}.`);
+                continue;
+            }
+            sitemaps.push(sitemapUrl);
+        }
+        return sitemaps;
     }
     /**
-     * Parse all the sitemaps referenced in the robots file.
+     * Parse all the sitemaps referenced in the robots file. `options` are forwarded to `getSitemaps`
+     * and the sitemap parser.
      */
-    async parseSitemaps() {
-        return Sitemap.load(this.robots.getSitemaps(), this.proxyUrl);
+    async parseSitemaps(options = {}) {
+        return Sitemap.load(this.getSitemaps(options), this.#proxyUrl, { ...options, logger: this.#logger });
     }
     /**
      * Get all URLs from all the sitemaps referenced in the robots file. A shorthand for `(await robots.parseSitemaps()).urls`.
+     * `options` are forwarded to `parseSitemaps`.
      */
-    async parseUrlsFromSitemaps() {
-        return (await this.parseSitemaps()).urls;
+    async parseUrlsFromSitemaps(options = {}) {
+        return (await this.parseSitemaps(options)).urls;
     }
 }
-// to stay backwards compatible
-export { RobotsTxtFile as RobotsFile };
-//# sourceMappingURL=robots.js.map

package/internals/schemas.d.ts

@@ -0,0 +1,114 @@
+import { BaseHttpClient } from '@crawlee/http-client';
+import type { Dictionary } from '@crawlee/types';
+import { z } from 'zod';
+/**
+ * Accepts any object (including arrays and functions).
+ * @internal
+ */
+export declare const anyObject: z.ZodCustom<Dictionary, Dictionary>;
+/**
+ * Accepts any array without validating its items (cheap for huge arrays).
+ * @internal
+ */
+export declare const anyArray: z.ZodCustom<unknown[], unknown[]>;
+/**
+ * Accepts any function.
+ * @internal
+ */
+export declare const anyFunction: z.ZodCustom<(...args: any[]) => unknown, (...args: any[]) => unknown>;
+/**
+ * Mirrors `ow.number`: `Infinity` is a valid number, `NaN` is not.
+ * @internal
+ */
+export declare const anyNumber: z.ZodCustom<number, number>;
+/**
+ * Accepts any object (including functions) that has all the given keys, own or inherited.
+ * @internal
+ */
+export declare function objectWithKeys(keys: string[], message?: string): z.ZodType<Dictionary>;
+/**
+ * Accepts only instances of {@link BaseHttpClient} (all Crawlee HTTP clients extend it).
+ * @internal
+ */
+export declare const httpClient: z.ZodInstanceOf<BaseHttpClient>;
+/**
+ * Accepts any object implementing the CrawleeLogger interface.
+ * @internal
+ */
+export declare const logger: z.ZodType<Dictionary, unknown, z.core.$ZodTypeInternals<Dictionary, unknown>>;
+/**
+ * Accepts any typed array (`Uint8Array`, `Float64Array`, ...), but not a `DataView`.
+ * @internal
+ */
+export declare const typedArray: z.ZodCustom<NodeJS.TypedArray<ArrayBufferLike>, NodeJS.TypedArray<ArrayBufferLike>>;
+/**
+ * Accepts any non-null, non-array object.
+ * @internal
+ */
+export declare const plainObject: z.ZodCustom<Record<string, unknown>, Record<string, unknown>>;
+/**
+ * Shape of a request stored in a request queue. Compiled: storage clients validate every request with it.
+ * @internal
+ */
+export declare const storageRequest: z.ZodObject<{
+    id: z.ZodString;
+    url: z.ZodURL;
+    uniqueKey: z.ZodString;
+    method: z.ZodOptional<z.ZodString>;
+    retryCount: z.ZodOptional<z.ZodNumber>;
+    handledAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
+}, z.core.$loose>;
+/**
+ * {@link storageRequest} before an id is assigned.
+ * @internal
+ */
+export declare const storageRequestWithoutId: z.ZodObject<{
+    url: z.ZodURL;
+    uniqueKey: z.ZodString;
+    method: z.ZodOptional<z.ZodString>;
+    retryCount: z.ZodOptional<z.ZodNumber>;
+    handledAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
+}, z.core.$loose>;
+/**
+ * `z.array(item)` whose top-level type error names the element type — ``expected an array of numbers`` —
+ * instead of zod's bare `expected array`. Element failures keep zod's per-index messages, and `elements`
+ * is a human-readable plural (`'numbers'`, `'URL patterns'`), since element types cannot be introspected.
+ * @internal
+ */
+export declare function arrayOf<TItem extends z.ZodType>(item: TItem, elements: string): z.ZodArray<TItem>;
+/**
+ * Batch of {@link storageRequestWithoutId}.
+ * @internal
+ */
+export declare const storageRequestBatch: z.ZodArray<z.ZodObject<{
+    url: z.ZodURL;
+    uniqueKey: z.ZodString;
+    method: z.ZodOptional<z.ZodString>;
+    retryCount: z.ZodOptional<z.ZodNumber>;
+    handledAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
+}, z.core.$loose>>;
+/**
+ * Options of request queue add/update operations.
+ * @internal
+ */
+export declare const requestQueueOperationOptions: z.ZodObject<{
+    forefront: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Options of key-value store `listKeys`.
+ * @internal
+ */
+export declare const keyValueStoreListKeysOptions: z.ZodObject<{
+    prefix: z.ZodOptional<z.ZodString>;
+    exclusiveStartKey: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Options of dataset item listing.
+ * @internal
+ */
+export declare const datasetListItemsOptions: z.ZodObject<{
+    desc: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;