@crawlee/core 4.0.0-beta.19 → 4.0.0-beta.190

package/iterables.js

@@ -0,0 +1,134 @@
+import { inspect } from 'node:util';
+/**
+ * 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) {
+    const getChunkSize = typeof chunkSize === 'function' ? chunkSize : () => chunkSize;
+    if (typeof chunkSize === 'number' && chunkSize < 1) {
+        throw new Error(`Chunk size must be a positive number (${inspect(chunkSize)}) received`);
+    }
+    const iterator = Symbol.asyncIterator in iterable
+        ? iterable[Symbol.asyncIterator]()
+        : iterable[Symbol.iterator]();
+    while (true) {
+        const currentSize = getChunkSize();
+        if (currentSize < 1)
+            break;
+        const chunk = [];
+        for (let i = 0; i < currentSize; i++) {
+            const next = await iterator.next();
+            if (next.done) {
+                break;
+            }
+            chunk.push(next.value);
+        }
+        if (chunk.length === 0)
+            break;
+        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;
+        },
+    };
+}

package/log.d.ts

@@ -1,5 +1,81 @@
+import type { CrawleeLogger, CrawleeLoggerOptions, LogOptions } from '@crawlee/types';
 import type { LoggerOptions } from '@apify/log';
 import log, { Log, Logger, LoggerJson, LoggerText, LogLevel } from '@apify/log';
+export type { CrawleeLogger, CrawleeLoggerOptions, LogOptions };
+/**
+ * Abstract base class for custom Crawlee logger implementations.
+ *
+ * Subclasses must implement two methods:
+ * - {@link BaseCrawleeLogger.logWithLevel} — the core logging dispatch
+ * - {@link BaseCrawleeLogger.createChild} — how to create a child logger instance
+ *
+ * All other `CrawleeLogger` methods (`error`, `warning`, `info`, `debug`, etc.)
+ * are derived automatically. Level filtering is entirely the responsibility of the
+ * underlying library — `logWithLevel()` is called for every message.
+ *
+ * **Example — Winston adapter:**
+ * ```typescript
+ * const CRAWLEE_TO_WINSTON = { 1: 'error', 2: 'warn', 3: 'warn', 4: 'info', 5: 'debug', 6: 'debug' };
+ *
+ * class WinstonAdapter extends BaseCrawleeLogger {
+ *     constructor(private logger: winston.Logger, options?: Partial<CrawleeLoggerOptions>) {
+ *         super(options);
+ *     }
+ *
+ *     logWithLevel(level: number, message: string, data?: Record<string, unknown>): void {
+ *         this.logger.log(CRAWLEE_TO_WINSTON[level] ?? 'info', message, data);
+ *     }
+ *
+ *     protected createChild(options: Partial<CrawleeLoggerOptions>): CrawleeLogger {
+ *         return new WinstonAdapter(this.logger.child({ prefix: options.prefix }), { ...this.getOptions(), ...options });
+ *     }
+ * }
+ * ```
+ */
+export declare abstract class BaseCrawleeLogger implements CrawleeLogger {
+    #private;
+    constructor(options?: Partial<CrawleeLoggerOptions>);
+    /**
+     * Core logging method. Subclasses must implement this to dispatch log messages
+     * to the underlying logger (Winston, Pino, console, etc.).
+     *
+     * Level filtering is the responsibility of the underlying library — this method
+     * is called for every message regardless of the current level.
+     *
+     * @param level Crawlee log level (use {@link LogLevel} constants)
+     * @param message The log message
+     * @param data Optional structured data to attach to the log entry
+     */
+    abstract logWithLevel(level: number, message: string, data?: Record<string, unknown>): void;
+    /**
+     * Creates a child logger instance. Subclasses must implement this to define
+     * how child loggers are created for the underlying logger.
+     */
+    protected abstract createChild(options: Partial<CrawleeLoggerOptions>): CrawleeLogger;
+    getOptions(): CrawleeLoggerOptions;
+    setOptions(options: Partial<CrawleeLoggerOptions>): void;
+    child(options: Partial<CrawleeLoggerOptions>): CrawleeLogger;
+    error(message: string, data?: Record<string, unknown>, options?: LogOptions): void;
+    exception(exception: Error, message: string, data?: Record<string, unknown>): void;
+    softFail(message: string, data?: Record<string, unknown>, options?: LogOptions): void;
+    warning(message: string, data?: Record<string, unknown>, options?: LogOptions): void;
+    warningOnce(message: string): void;
+    info(message: string, data?: Record<string, unknown>, options?: LogOptions): void;
+    debug(message: string, data?: Record<string, unknown>, options?: LogOptions): void;
+    perf(message: string, data?: Record<string, unknown>, options?: LogOptions): void;
+    deprecated(message: string): void;
+}
+/**
+ * Adapter that wraps `@apify/log`'s {@link Log} instance to implement the {@link CrawleeLogger} interface.
+ *
+ * This is the default logger used by Crawlee when no custom logger is configured.
+ * Users who want to use a different logging library should implement {@link BaseCrawleeLogger} directly.
+ */
+export declare class ApifyLogAdapter extends BaseCrawleeLogger {
+    #private;
+    constructor(apifyLog: Log, options?: Partial<CrawleeLoggerOptions>);
+    logWithLevel(level: number, message: string, data?: Record<string, unknown>): void;
+    protected createChild(options: Partial<CrawleeLoggerOptions>): CrawleeLogger;
+}
 export { log, Log, LogLevel, Logger, LoggerJson, LoggerText };
 export type { LoggerOptions };
-//# sourceMappingURL=log.d.ts.map

package/log.js

@@ -1,3 +1,136 @@
 import log, { Log, Logger, LoggerJson, LoggerText, LogLevel } from '@apify/log';
+/**
+ * Abstract base class for custom Crawlee logger implementations.
+ *
+ * Subclasses must implement two methods:
+ * - {@link BaseCrawleeLogger.logWithLevel} — the core logging dispatch
+ * - {@link BaseCrawleeLogger.createChild} — how to create a child logger instance
+ *
+ * All other `CrawleeLogger` methods (`error`, `warning`, `info`, `debug`, etc.)
+ * are derived automatically. Level filtering is entirely the responsibility of the
+ * underlying library — `logWithLevel()` is called for every message.
+ *
+ * **Example — Winston adapter:**
+ * ```typescript
+ * const CRAWLEE_TO_WINSTON = { 1: 'error', 2: 'warn', 3: 'warn', 4: 'info', 5: 'debug', 6: 'debug' };
+ *
+ * class WinstonAdapter extends BaseCrawleeLogger {
+ *     constructor(private logger: winston.Logger, options?: Partial<CrawleeLoggerOptions>) {
+ *         super(options);
+ *     }
+ *
+ *     logWithLevel(level: number, message: string, data?: Record<string, unknown>): void {
+ *         this.logger.log(CRAWLEE_TO_WINSTON[level] ?? 'info', message, data);
+ *     }
+ *
+ *     protected createChild(options: Partial<CrawleeLoggerOptions>): CrawleeLogger {
+ *         return new WinstonAdapter(this.logger.child({ prefix: options.prefix }), { ...this.getOptions(), ...options });
+ *     }
+ * }
+ * ```
+ */
+export class BaseCrawleeLogger {
+    // Note: If wrapping logger in a Proxy, unbound methods calling #-fields throw TypeError
+    // unless bound to the target (see createLogProxy in adaptive-playwright-crawler.ts).
+    #options;
+    #loggedOnce = new Set();
+    constructor(options = {}) {
+        this.#options = options;
+    }
+    getOptions() {
+        return this.#options;
+    }
+    setOptions(options) {
+        this.#options = { ...this.#options, ...options };
+    }
+    child(options) {
+        return this.createChild(options);
+    }
+    /**
+     * Whether `once` suppresses this message. Keyed by level as well as text, so that a message logged once as
+     * `info` does not swallow the same text logged as a `warning`.
+     *
+     * Handled here rather than in {@link BaseCrawleeLogger.logWithLevel} so that every logger gets it, instead
+     * of each implementation having to dedupe for itself.
+     */
+    #suppressedAsRepeat(level, message, options) {
+        if (!options?.once) {
+            return false;
+        }
+        const key = `${level}:${message}`;
+        if (this.#loggedOnce.has(key)) {
+            return true;
+        }
+        this.#loggedOnce.add(key);
+        return false;
+    }
+    error(message, data, options) {
+        if (this.#suppressedAsRepeat(LogLevel.ERROR, message, options))
+            return;
+        this.logWithLevel(LogLevel.ERROR, message, data);
+    }
+    exception(exception, message, data) {
+        this.logWithLevel(LogLevel.ERROR, `${message}: ${exception.message}`, {
+            ...data,
+            stack: exception.stack,
+            exception,
+        });
+    }
+    softFail(message, data, options) {
+        if (this.#suppressedAsRepeat(LogLevel.SOFT_FAIL, message, options))
+            return;
+        this.logWithLevel(LogLevel.SOFT_FAIL, message, data);
+    }
+    warning(message, data, options) {
+        if (this.#suppressedAsRepeat(LogLevel.WARNING, message, options))
+            return;
+        this.logWithLevel(LogLevel.WARNING, message, data);
+    }
+    warningOnce(message) {
+        // Gates before delegating, so that a suppressed repeat is not even a `warning()` call.
+        if (this.#suppressedAsRepeat(LogLevel.WARNING, message, { once: true }))
+            return;
+        this.warning(message);
+    }
+    info(message, data, options) {
+        if (this.#suppressedAsRepeat(LogLevel.INFO, message, options))
+            return;
+        this.logWithLevel(LogLevel.INFO, message, data);
+    }
+    debug(message, data, options) {
+        if (this.#suppressedAsRepeat(LogLevel.DEBUG, message, options))
+            return;
+        this.logWithLevel(LogLevel.DEBUG, message, data);
+    }
+    perf(message, data, options) {
+        if (this.#suppressedAsRepeat(LogLevel.PERF, message, options))
+            return;
+        this.logWithLevel(LogLevel.PERF, `[PERF] ${message}`, data);
+    }
+    deprecated(message) {
+        this.warningOnce(`[DEPRECATED] ${message}`);
+    }
+}
+/**
+ * Adapter that wraps `@apify/log`'s {@link Log} instance to implement the {@link CrawleeLogger} interface.
+ *
+ * This is the default logger used by Crawlee when no custom logger is configured.
+ * Users who want to use a different logging library should implement {@link BaseCrawleeLogger} directly.
+ */
+export class ApifyLogAdapter extends BaseCrawleeLogger {
+    #apifyLog;
+    constructor(apifyLog, options) {
+        super(options ?? {});
+        this.#apifyLog = apifyLog;
+    }
+    logWithLevel(level, message, data) {
+        this.#apifyLog.internal(level, message, data);
+    }
+    createChild(options) {
+        return new ApifyLogAdapter(this.#apifyLog.child({ prefix: options.prefix ?? null }), {
+            ...this.getOptions(),
+            ...options,
+        });
+    }
+}
 export { log, Log, LogLevel, Logger, LoggerJson, LoggerText };
-//# sourceMappingURL=log.js.map

package/memory-storage/consts.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Length of id property of a Request instance in characters.
+ */
+export declare const REQUEST_ID_LENGTH = 15;

package/memory-storage/consts.js

@@ -0,0 +1,4 @@
+/**
+ * Length of id property of a Request instance in characters.
+ */
+export const REQUEST_ID_LENGTH = 15;

package/memory-storage/index.d.ts

@@ -0,0 +1 @@
+export * from './memory-storage.js';

package/memory-storage/index.js

@@ -0,0 +1 @@
+export * from './memory-storage.js';

package/memory-storage/memory-storage.d.ts

@@ -0,0 +1,44 @@
+import type * as storage from '@crawlee/types';
+import type { CrawleeLogger } from '@crawlee/types';
+import { RequestQueueBackend } from './resource-clients/request-queue.js';
+export interface MemoryStorageOptions {
+    /**
+     * Optional logger for MemoryStorageBackend warnings.
+     */
+    logger?: CrawleeLogger;
+}
+export declare class MemoryStorageBackend implements storage.StorageBackend {
+    #private;
+    readonly logger?: CrawleeLogger;
+    constructor(options?: MemoryStorageOptions);
+    /**
+     * Return a per-instance unique cache key so that distinct `MemoryStorageBackend` instances get separate
+     * cache partitions in the storage backend cache.
+     */
+    getStorageBackendCacheKey(): string;
+    /**
+     * Evict a cached backend so that a dropped storage is no longer resolved by `createXBackend`,
+     * reported by `storageExists` or visited by `purge`. Returns whether the backend was cached, which
+     * tells the caller whether it still owns in-memory state worth clearing.
+     *
+     * The resource clients own their own entry's lifetime but must not reach into the caches directly.
+     * Because a client is only ever constructed by `createXBackend`, which caches it immediately, the
+     * entry matching `id` is always the caller itself.
+     * @internal
+     */
+    evictBackend(type: 'Dataset' | 'KeyValueStore' | 'RequestQueue', id: string): boolean;
+    createDatasetBackend(options?: storage.StorageIdentifier): Promise<storage.DatasetBackend>;
+    createKeyValueStoreBackend(options?: storage.StorageIdentifier): Promise<storage.KeyValueStoreBackend>;
+    createRequestQueueBackend(options?: storage.StorageIdentifier): Promise<RequestQueueBackend>;
+    storageExists(id: string, type: 'Dataset' | 'KeyValueStore' | 'RequestQueue'): Promise<boolean>;
+    /**
+     * Cleans up the run-scoped storages before the run starts. For the in-memory storage this simply
+     * resets the in-memory state of the cached backends.
+     */
+    purge(): Promise<void>;
+    /**
+     * This method should be called at the end of the process. The in-memory storage holds no resources
+     * that outlive the process (no file handles, no cross-process locks), so there is nothing to do.
+     */
+    teardown(): Promise<void>;
+}

package/memory-storage/memory-storage.js

@@ -0,0 +1,160 @@
+import { randomUUID } from 'node:crypto';
+import { DatasetBackend } from './resource-clients/dataset.js';
+import { KeyValueStoreBackend } from './resource-clients/key-value-store.js';
+import { RequestQueueBackend } from './resource-clients/request-queue.js';
+/** The alias the default (unnamed) storage is opened under. */
+const DEFAULT_STORAGE_ALIAS = '__default__';
+export class MemoryStorageBackend {
+    logger;
+    /**
+     * Unique per-instance cache partition key. Mirrors the way `FileSystemStorageBackend` partitions its
+     * cache by storage directory: two distinct `MemoryStorageBackend` instances must not share cached backends.
+     */
+    #instanceCacheKey = `MemoryStorageBackend:${randomUUID()}`;
+    #keyValueStoreBackendCache = [];
+    #datasetBackendCache = [];
+    #requestQueueBackendCache = [];
+    constructor(options = {}) {
+        this.logger = options.logger;
+    }
+    /**
+     * Return a per-instance unique cache key so that distinct `MemoryStorageBackend` instances get separate
+     * cache partitions in the storage backend cache.
+     */
+    getStorageBackendCacheKey() {
+        return this.#instanceCacheKey;
+    }
+    /**
+     * Evict a cached backend so that a dropped storage is no longer resolved by `createXBackend`,
+     * reported by `storageExists` or visited by `purge`. Returns whether the backend was cached, which
+     * tells the caller whether it still owns in-memory state worth clearing.
+     *
+     * The resource clients own their own entry's lifetime but must not reach into the caches directly.
+     * Because a client is only ever constructed by `createXBackend`, which caches it immediately, the
+     * entry matching `id` is always the caller itself.
+     * @internal
+     */
+    evictBackend(type, id) {
+        let cache;
+        switch (type) {
+            case 'Dataset':
+                cache = this.#datasetBackendCache;
+                break;
+            case 'KeyValueStore':
+                cache = this.#keyValueStoreBackendCache;
+                break;
+            case 'RequestQueue':
+                cache = this.#requestQueueBackendCache;
+                break;
+        }
+        const index = cache.findIndex((entry) => entry.id === id);
+        if (index === -1) {
+            return false;
+        }
+        cache.splice(index, 1);
+        return true;
+    }
+    static #resolveStorageKey(options) {
+        // No identifier at all means the default storage, which is opened under the reserved alias —
+        // same rule as `resolveStorageIdentifier` in the storage frontends, so that a backend used
+        // directly lands on the very storage the frontends would have opened.
+        const alias = options.alias || (!options.id && !options.name ? DEFAULT_STORAGE_ALIAS : undefined);
+        // `alias` covers the identifier-less case, so one of the three is always set.
+        const rawKey = alias ?? options.name ?? options.id;
+        // Normalize the internal __default__ alias to the user-facing 'default' name.
+        const cacheKey = rawKey === DEFAULT_STORAGE_ALIAS ? 'default' : rawKey;
+        return { isAlias: alias !== undefined, cacheKey };
+    }
+    async createDatasetBackend(options = {}) {
+        const { isAlias, cacheKey } = MemoryStorageBackend.#resolveStorageKey(options);
+        const found = this.#datasetBackendCache.find((store) => store.id === cacheKey ||
+            store.name?.toLowerCase() === cacheKey.toLowerCase() ||
+            store.cacheKey.toLowerCase() === cacheKey.toLowerCase());
+        if (found) {
+            return found;
+        }
+        const newStore = new DatasetBackend({
+            name: isAlias ? undefined : cacheKey,
+            cacheKey,
+            storageBackend: this,
+        });
+        this.#datasetBackendCache.push(newStore);
+        return newStore;
+    }
+    async createKeyValueStoreBackend(options = {}) {
+        const { isAlias, cacheKey } = MemoryStorageBackend.#resolveStorageKey(options);
+        const found = this.#keyValueStoreBackendCache.find((store) => store.id === cacheKey ||
+            store.name?.toLowerCase() === cacheKey.toLowerCase() ||
+            store.cacheKey.toLowerCase() === cacheKey.toLowerCase());
+        if (found) {
+            return found;
+        }
+        const newStore = new KeyValueStoreBackend({
+            name: isAlias ? undefined : cacheKey,
+            cacheKey,
+            storageBackend: this,
+        });
+        this.#keyValueStoreBackendCache.push(newStore);
+        return newStore;
+    }
+    async createRequestQueueBackend(options = {}) {
+        const { isAlias, cacheKey } = MemoryStorageBackend.#resolveStorageKey(options);
+        const found = this.#requestQueueBackendCache.find((queue) => queue.id === cacheKey ||
+            queue.name?.toLowerCase() === cacheKey.toLowerCase() ||
+            queue.cacheKey.toLowerCase() === cacheKey.toLowerCase());
+        if (found) {
+            return found;
+        }
+        const newStore = new RequestQueueBackend({
+            name: isAlias ? undefined : cacheKey,
+            cacheKey,
+            storageBackend: this,
+        });
+        this.#requestQueueBackendCache.push(newStore);
+        return newStore;
+    }
+    async storageExists(id, type) {
+        let backends;
+        switch (type) {
+            case 'Dataset':
+                backends = this.#datasetBackendCache;
+                break;
+            case 'KeyValueStore':
+                backends = this.#keyValueStoreBackendCache;
+                break;
+            case 'RequestQueue':
+                backends = this.#requestQueueBackendCache;
+                break;
+            default:
+                return false;
+        }
+        // In-memory storage only knows about backends in its cache.
+        return backends.some((store) => store.id === id);
+    }
+    /**
+     * Cleans up the run-scoped storages before the run starts. For the in-memory storage this simply
+     * resets the in-memory state of the cached backends.
+     */
+    async purge() {
+        // `#resolveStorageKey` leaves `name` unset for the default and alias-keyed storages, which is what
+        // marks them as run-scoped. `'default'` is the exception — it collapses onto the default storage.
+        const isRunScoped = (store) => store.name === undefined || store.name === 'default';
+        const isDefault = (store) => store.name === 'default' || store.cacheKey === 'default';
+        const purgeRunScoped = async (cache, purgeStore) => {
+            await Promise.all(cache.filter(isRunScoped).map(async (store) => purgeStore(store)));
+        };
+        await Promise.all([
+            // Only the default store holds the run input, so it is the only one that keeps `INPUT`.
+            purgeRunScoped(this.#keyValueStoreBackendCache, async (store) => isDefault(store) ? store.purgeExceptInput() : store.purge()),
+            purgeRunScoped(this.#datasetBackendCache, async (store) => store.purge()),
+            purgeRunScoped(this.#requestQueueBackendCache, async (store) => store.purge()),
+        ]);
+    }
+    /**
+     * This method should be called at the end of the process. The in-memory storage holds no resources
+     * that outlive the process (no file handles, no cross-process locks), so there is nothing to do.
+     */
+    async teardown() {
+        // Nothing to tear down for in-memory storage.
+    }
+}

package/memory-storage/resource-clients/common/base-client.d.ts

@@ -0,0 +1,4 @@
+export declare class BaseClient {
+    id: string;
+    constructor(id: string);
+}

package/memory-storage/resource-clients/common/base-client.js

@@ -0,0 +1,6 @@
+export class BaseClient {
+    id;
+    constructor(id) {
+        this.id = id;
+    }
+}

package/memory-storage/resource-clients/dataset.d.ts

@@ -0,0 +1,40 @@
+import type * as storage from '@crawlee/types';
+import type { Dictionary } from '@crawlee/types';
+import type { MemoryStorageBackend } from '../memory-storage.js';
+import { BaseClient } from './common/base-client.js';
+export interface DatasetBackendOptions {
+    id?: string;
+    name?: string;
+    /**
+     * The key used for cache lookup. When provided, takes precedence over `name` and `id`.
+     * This allows alias-opened storages to have a cache key that differs from their
+     * metadata `name` (which is `undefined` for unnamed storages).
+     */
+    cacheKey?: string;
+    storageBackend: MemoryStorageBackend;
+}
+export declare class DatasetBackend<Data extends Dictionary = Dictionary> extends BaseClient implements storage.DatasetBackend<Data> {
+    #private;
+    name?: string;
+    /**
+     * The key used for cache lookup. For named storages, this equals the name. For alias (unnamed)
+     * storages, this is the alias string. Falls back to id.
+     */
+    cacheKey: string;
+    createdAt: Date;
+    accessedAt: Date;
+    modifiedAt: Date;
+    itemCount: number;
+    private readonly storageBackend;
+    constructor(options: DatasetBackendOptions);
+    getMetadata(): Promise<storage.DatasetInfo>;
+    drop(): Promise<void>;
+    purge(): Promise<void>;
+    getData(options?: storage.DatasetBackendListOptions): Promise<storage.PaginatedList<Data>>;
+    private getDataPage;
+    pushData(items: Data[]): Promise<void>;
+    toDatasetInfo(): storage.DatasetInfo;
+    private generateLocalEntryName;
+    private getStartAndEndIndexes;
+    private updateTimestamps;
+}