@crawlee/core 4.0.0-beta.99 → 4.0.0-rc.1

package/events/system_info.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Represents the current status of the system.
+ */
+export interface SystemInfo {
+    /** If false, system is being overloaded. */
+    isSystemIdle: boolean;
+    memInfo: LoadSignalInfo;
+    eventLoopInfo: LoadSignalInfo;
+    cpuInfo: LoadSignalInfo;
+    storageBackendInfo: LoadSignalInfo;
+    memTotalBytes?: number;
+    memCurrentBytes?: number;
+    /**
+     * Platform only property
+     * @internal
+     */
+    cpuCurrentUsage?: number;
+    /**
+     * Platform only property
+     * @internal
+     */
+    isCpuOverloaded?: boolean;
+    /**
+     * Platform only property
+     * @internal
+     */
+    createdAt?: Date;
+    /**
+     * Status of additional load signals beyond the built-in four.
+     * Keys are `LoadSignal.name` values, values are overload info.
+     */
+    loadSignalInfo?: Record<string, LoadSignalInfo>;
+}
+export interface LoadSignalInfo {
+    isOverloaded: boolean;
+    limitRatio: number;
+    actualRatio: number;
+}

package/index.d.ts

@@ -1,22 +1,16 @@
 export * from './debug.js';
 export * from './errors.js';
-export * from './autoscaling/index.js';
 export * from './configuration.js';
 export * from './service_locator.js';
-export * from './crawlers/index.js';
-export * from './enqueue_links/index.js';
 export * from './events/index.js';
 export * from './log.js';
 export * from './owned_or_injected.js';
 export * from './proxy_configuration.js';
 export * from './request.js';
-export * from './router.js';
 export * from './serialization.js';
-export * from './session_pool/index.js';
 export * from './storages/index.js';
 export * from './memory-storage/index.js';
-export * from './validators.js';
-export * from './cookie_utils.js';
+export { ArgumentValidationError, validators } from './validators.js';
 export * from './recoverable_state.js';
-export { PseudoUrl } from '@apify/pseudo_url';
 export type { StorageBackend } from '@crawlee/types';
+export { EnqueueStrategy } from '@crawlee/utils';

package/index.js

@@ -1,21 +1,17 @@
 export * from './debug.js';
 export * from './errors.js';
-export * from './autoscaling/index.js';
 export * from './configuration.js';
 export * from './service_locator.js';
-export * from './crawlers/index.js';
-export * from './enqueue_links/index.js';
 export * from './events/index.js';
 export * from './log.js';
 export * from './owned_or_injected.js';
 export * from './proxy_configuration.js';
 export * from './request.js';
-export * from './router.js';
 export * from './serialization.js';
-export * from './session_pool/index.js';
 export * from './storages/index.js';
 export * from './memory-storage/index.js';
-export * from './validators.js';
-export * from './cookie_utils.js';
+// Not `export *`: the rest of the module re-exports `@crawlee/utils/internal` symbols, which carry no
+// semver guarantees and must not reach the public surface. Internal consumers import them directly.
+export { ArgumentValidationError, validators } from './validators.js';
 export * from './recoverable_state.js';
-export { PseudoUrl } from '@apify/pseudo_url';
+export { EnqueueStrategy } from '@crawlee/utils';

package/internal.d.ts

@@ -0,0 +1,8 @@
+export * from './iterables.js';
+export * from './storages/batched_adds.js';
+export { joinRequestSourceStatuses } from './storages/request_loader.js';
+export * from './system-info/cpu-info.js';
+export * from './system-info/memory-info.js';
+export * from './system-info/ps-tree.js';
+export * from './system-info/runtime.js';
+export * from './url.js';

package/internal.js

@@ -0,0 +1,9 @@
+// Not part of the public API: internals that other Crawlee packages need but that carry no semver guarantees.
+export * from './iterables.js';
+export * from './storages/batched_adds.js';
+export { joinRequestSourceStatuses } from './storages/request_loader.js';
+export * from './system-info/cpu-info.js';
+export * from './system-info/memory-info.js';
+export * from './system-info/ps-tree.js';
+export * from './system-info/runtime.js';
+export * from './url.js';

package/log.d.ts

@@ -1,7 +1,7 @@
-import type { CrawleeLogger, CrawleeLoggerOptions } from '@crawlee/types';
+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 };
+export type { CrawleeLogger, CrawleeLoggerOptions, LogOptions };
 /**
  * Abstract base class for custom Crawlee logger implementations.
  *
@@ -33,8 +33,7 @@ export type { CrawleeLogger, CrawleeLoggerOptions };
  * ```
  */
 export declare abstract class BaseCrawleeLogger implements CrawleeLogger {
-    private options;
-    private readonly warningsLogged;
+    #private;
     constructor(options?: Partial<CrawleeLoggerOptions>);
     /**
      * Core logging method. Subclasses must implement this to dispatch log messages
@@ -56,14 +55,14 @@ export declare abstract class BaseCrawleeLogger implements CrawleeLogger {
     getOptions(): CrawleeLoggerOptions;
     setOptions(options: Partial<CrawleeLoggerOptions>): void;
     child(options: Partial<CrawleeLoggerOptions>): CrawleeLogger;
-    error(message: string, data?: Record<string, unknown>): void;
+    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>): void;
-    warning(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>): void;
-    debug(message: string, data?: Record<string, unknown>): void;
-    perf(message: string, data?: Record<string, unknown>): 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;
 }
 /**
@@ -73,7 +72,7 @@ export declare abstract class BaseCrawleeLogger implements CrawleeLogger {
  * Users who want to use a different logging library should implement {@link BaseCrawleeLogger} directly.
  */
 export declare class ApifyLogAdapter extends BaseCrawleeLogger {
-    private readonly apifyLog;
+    #private;
     constructor(apifyLog: Log, options?: Partial<CrawleeLoggerOptions>);
     logWithLevel(level: number, message: string, data?: Record<string, unknown>): void;
     protected createChild(options: Partial<CrawleeLoggerOptions>): CrawleeLogger;

package/log.js

@@ -30,21 +30,43 @@ import log, { Log, Logger, LoggerJson, LoggerText, LogLevel } from '@apify/log';
  * ```
  */
 export class BaseCrawleeLogger {
-    options;
-    warningsLogged = new Set();
+    // 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;
+        this.#options = options;
     }
     getOptions() {
-        return this.options;
+        return this.#options;
     }
     setOptions(options) {
-        this.options = { ...this.options, ...options };
+        this.#options = { ...this.#options, ...options };
     }
     child(options) {
         return this.createChild(options);
     }
-    error(message, data) {
+    /**
+     * 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) {
@@ -54,25 +76,35 @@ export class BaseCrawleeLogger {
             exception,
         });
     }
-    softFail(message, data) {
+    softFail(message, data, options) {
+        if (this.#suppressedAsRepeat(LogLevel.SOFT_FAIL, message, options))
+            return;
         this.logWithLevel(LogLevel.SOFT_FAIL, message, data);
     }
-    warning(message, data) {
+    warning(message, data, options) {
+        if (this.#suppressedAsRepeat(LogLevel.WARNING, message, options))
+            return;
         this.logWithLevel(LogLevel.WARNING, message, data);
     }
     warningOnce(message) {
-        if (!this.warningsLogged.has(message)) {
-            this.warningsLogged.add(message);
-            this.warning(message);
-        }
-    }
-    info(message, data) {
+        // 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) {
+    debug(message, data, options) {
+        if (this.#suppressedAsRepeat(LogLevel.DEBUG, message, options))
+            return;
         this.logWithLevel(LogLevel.DEBUG, message, data);
     }
-    perf(message, data) {
+    perf(message, data, options) {
+        if (this.#suppressedAsRepeat(LogLevel.PERF, message, options))
+            return;
         this.logWithLevel(LogLevel.PERF, `[PERF] ${message}`, data);
     }
     deprecated(message) {
@@ -86,16 +118,16 @@ export class BaseCrawleeLogger {
  * Users who want to use a different logging library should implement {@link BaseCrawleeLogger} directly.
  */
 export class ApifyLogAdapter extends BaseCrawleeLogger {
-    apifyLog;
+    #apifyLog;
     constructor(apifyLog, options) {
         super(options ?? {});
-        this.apifyLog = apifyLog;
+        this.#apifyLog = apifyLog;
     }
     logWithLevel(level, message, data) {
-        this.apifyLog.internal(level, message, data);
+        this.#apifyLog.internal(level, message, data);
     }
     createChild(options) {
-        return new ApifyLogAdapter(this.apifyLog.child({ prefix: options.prefix ?? null }), {
+        return new ApifyLogAdapter(this.#apifyLog.child({ prefix: options.prefix ?? null }), {
             ...this.getOptions(),
             ...options,
         });

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

@@ -1,8 +1,5 @@
 import type * as storage from '@crawlee/types';
 import type { CrawleeLogger } from '@crawlee/types';
-import { DatasetBackend } from './resource-clients/dataset.js';
-import { KeyValueStoreBackend } from './resource-clients/key-value-store.js';
-import { RequestQueueBackend } from './resource-clients/request-queue.js';
 export interface MemoryStorageOptions {
     /**
      * Optional logger for MemoryStorageBackend warnings.
@@ -10,32 +7,32 @@ export interface MemoryStorageOptions {
     logger?: CrawleeLogger;
 }
 export declare class MemoryStorageBackend implements storage.StorageBackend {
+    #private;
     readonly logger?: CrawleeLogger;
-    /**
-     * 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.
-     */
-    private readonly instanceCacheKey;
-    readonly keyValueStoreBackendCache: KeyValueStoreBackend[];
-    readonly datasetBackendCache: DatasetBackend[];
-    readonly requestQueueBackendCache: RequestQueueBackend[];
     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;
-    private static resolveStorageKey;
+    /**
+     * 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>;
+    createRequestQueueBackend(options?: storage.StorageIdentifier): Promise<storage.RequestQueueBackend>;
     storageExists(id: string, type: 'Dataset' | 'KeyValueStore' | 'RequestQueue'): Promise<boolean>;
     /**
-     * Cleans up the default storages before the run starts. For the in-memory storage this simply
-     * resets the in-memory state of the cached default dataset, key-value store and request queue.
-     *
-     * As with `FileSystemStorageBackend`, the run's input (the `INPUT` key in the default key-value
-     * store) is preserved — only the rest of the default storages is cleared.
+     * 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>;
     /**

package/memory-storage/memory-storage.js

@@ -2,16 +2,18 @@ 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 = [];
+    #instanceCacheKey = `MemoryStorageBackend:${randomUUID()}`;
+    #keyValueStoreBackendCache = [];
+    #datasetBackendCache = [];
+    #requestQueueBackendCache = [];
     constructor(options = {}) {
         this.logger = options.logger;
     }
@@ -20,80 +22,108 @@ export class MemoryStorageBackend {
      * cache partitions in the storage backend cache.
      */
     getStorageBackendCacheKey() {
-        return this.instanceCacheKey;
+        return this.#instanceCacheKey;
     }
-    static resolveStorageKey(options) {
-        const isAlias = 'alias' in options && !!options.alias;
-        const rawKey = isAlias ? options.alias : (options.name ?? options.id);
+    /**
+     * 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__' ? 'default' : rawKey;
-        return { isAlias, cacheKey };
+        const cacheKey = rawKey === DEFAULT_STORAGE_ALIAS ? 'default' : rawKey;
+        return { isAlias: alias !== undefined, cacheKey };
     }
     async createDatasetBackend(options = {}) {
-        const { isAlias, cacheKey } = MemoryStorageBackend.resolveStorageKey(options);
-        if (cacheKey) {
-            const found = this.datasetBackendCache.find((store) => store.id === cacheKey ||
-                store.name?.toLowerCase() === cacheKey.toLowerCase() ||
-                store.cacheKey.toLowerCase() === cacheKey.toLowerCase());
-            if (found) {
-                return found;
-            }
+        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);
+        this.#datasetBackendCache.push(newStore);
         return newStore;
     }
     async createKeyValueStoreBackend(options = {}) {
-        const { isAlias, cacheKey } = MemoryStorageBackend.resolveStorageKey(options);
-        if (cacheKey) {
-            const found = this.keyValueStoreBackendCache.find((store) => store.id === cacheKey ||
-                store.name?.toLowerCase() === cacheKey.toLowerCase() ||
-                store.cacheKey.toLowerCase() === cacheKey.toLowerCase());
-            if (found) {
-                return found;
-            }
+        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);
+        this.#keyValueStoreBackendCache.push(newStore);
         return newStore;
     }
     async createRequestQueueBackend(options = {}) {
-        const { isAlias, cacheKey } = MemoryStorageBackend.resolveStorageKey(options);
-        if (cacheKey) {
-            const found = this.requestQueueBackendCache.find((queue) => queue.id === cacheKey ||
-                queue.name?.toLowerCase() === cacheKey.toLowerCase() ||
-                queue.cacheKey.toLowerCase() === cacheKey.toLowerCase());
-            if (found) {
-                return found;
-            }
+        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);
+        this.#requestQueueBackendCache.push(newStore);
         return newStore;
     }
     async storageExists(id, type) {
         let backends;
         switch (type) {
             case 'Dataset':
-                backends = this.datasetBackendCache;
+                backends = this.#datasetBackendCache;
                 break;
             case 'KeyValueStore':
-                backends = this.keyValueStoreBackendCache;
+                backends = this.#keyValueStoreBackendCache;
                 break;
             case 'RequestQueue':
-                backends = this.requestQueueBackendCache;
+                backends = this.#requestQueueBackendCache;
                 break;
             default:
                 return false;
@@ -102,28 +132,20 @@ export class MemoryStorageBackend {
         return backends.some((store) => store.id === id);
     }
     /**
-     * Cleans up the default storages before the run starts. For the in-memory storage this simply
-     * resets the in-memory state of the cached default dataset, key-value store and request queue.
-     *
-     * As with `FileSystemStorageBackend`, the run's input (the `INPUT` key in the default key-value
-     * store) is preserved — only the rest of the default storages is cleared.
+     * 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() {
-        // The run default is opened via `{ alias: '__default__' }`, which `resolveStorageKey`
-        // normalizes to `cacheKey === 'default'` (with `name === undefined`) — that is the clause
-        // that actually matches it. The `name === 'default'` clause additionally covers a store a user
-        // explicitly opened via `{ name: 'default' }`. (`'__default__'` never reaches `cacheKey`,
-        // as it is always normalized to `'default'` first, so it does not need to be checked here.)
-        const isDefault = (store) => store.name === 'default' || store.cacheKey === 'default';
-        const purgeDefaults = async (cache, purgeStore) => {
-            await Promise.all(cache.filter(isDefault).map(async (store) => purgeStore(store)));
+        // `#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 purgeRunScoped = async (cache, purgeStore) => {
+            await Promise.all(cache.filter(isRunScoped).map(async (store) => purgeStore(store)));
         };
         await Promise.all([
-            // Preserve the run input (INPUT) when purging the default key-value store, matching
-            // `FileSystemStorageBackend`.
-            purgeDefaults(this.keyValueStoreBackendCache, async (store) => store.purgeExceptInput()),
-            purgeDefaults(this.datasetBackendCache, async (store) => store.purge()),
-            purgeDefaults(this.requestQueueBackendCache, async (store) => store.purge()),
+            purgeRunScoped(this.#keyValueStoreBackendCache, async (store) => store.purge()),
+            purgeRunScoped(this.#datasetBackendCache, async (store) => store.purge()),
+            purgeRunScoped(this.#requestQueueBackendCache, async (store) => store.purge()),
         ]);
     }
     /**

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

@@ -14,6 +14,7 @@ export interface DatasetBackendOptions {
     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)
@@ -24,17 +25,11 @@ export declare class DatasetBackend<Data extends Dictionary = Dictionary> extend
     accessedAt: Date;
     modifiedAt: Date;
     itemCount: number;
-    private readonly datasetEntries;
-    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;
 }