@crawlee/core 4.0.0-rc.0 → 4.0.0-rc.1

package/log.js

@@ -30,23 +30,43 @@ import log, { Log, Logger, LoggerJson, LoggerText, LogLevel } from '@apify/log';
  * ```
  */
 export class BaseCrawleeLogger {
-    // kept as TS-private: the adaptive crawler's log proxy calls non-intercepted methods with `this === proxy`,
-    // where `#`-field access would throw at runtime
-    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) {
@@ -56,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) {
@@ -88,18 +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;
-    constructor(
-    // kept as a TS-private parameter property: reached through the adaptive crawler's log proxy, see above
-    apifyLog, options) {
+    #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.
@@ -12,18 +9,26 @@ export interface MemoryStorageOptions {
 export declare class MemoryStorageBackend implements storage.StorageBackend {
     #private;
     readonly logger?: CrawleeLogger;
-    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;
+    /**
+     * 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 run-scoped storages before the run starts. For the in-memory storage this simply

package/memory-storage/memory-storage.js

@@ -11,9 +11,9 @@ export class MemoryStorageBackend {
      * cache by storage directory: two distinct `MemoryStorageBackend` instances must not share cached backends.
      */
     #instanceCacheKey = `MemoryStorageBackend:${randomUUID()}`;
-    keyValueStoreBackendCache = [];
-    datasetBackendCache = [];
-    requestQueueBackendCache = [];
+    #keyValueStoreBackendCache = [];
+    #datasetBackendCache = [];
+    #requestQueueBackendCache = [];
     constructor(options = {}) {
         this.logger = options.logger;
     }
@@ -24,6 +24,36 @@ export class MemoryStorageBackend {
     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
@@ -37,7 +67,7 @@ export class MemoryStorageBackend {
     }
     async createDatasetBackend(options = {}) {
         const { isAlias, cacheKey } = MemoryStorageBackend.#resolveStorageKey(options);
-        const found = this.datasetBackendCache.find((store) => store.id === cacheKey ||
+        const found = this.#datasetBackendCache.find((store) => store.id === cacheKey ||
             store.name?.toLowerCase() === cacheKey.toLowerCase() ||
             store.cacheKey.toLowerCase() === cacheKey.toLowerCase());
         if (found) {
@@ -48,12 +78,12 @@ export class MemoryStorageBackend {
             cacheKey,
             storageBackend: this,
         });
-        this.datasetBackendCache.push(newStore);
+        this.#datasetBackendCache.push(newStore);
         return newStore;
     }
     async createKeyValueStoreBackend(options = {}) {
         const { isAlias, cacheKey } = MemoryStorageBackend.#resolveStorageKey(options);
-        const found = this.keyValueStoreBackendCache.find((store) => store.id === cacheKey ||
+        const found = this.#keyValueStoreBackendCache.find((store) => store.id === cacheKey ||
             store.name?.toLowerCase() === cacheKey.toLowerCase() ||
             store.cacheKey.toLowerCase() === cacheKey.toLowerCase());
         if (found) {
@@ -64,12 +94,12 @@ export class MemoryStorageBackend {
             cacheKey,
             storageBackend: this,
         });
-        this.keyValueStoreBackendCache.push(newStore);
+        this.#keyValueStoreBackendCache.push(newStore);
         return newStore;
     }
     async createRequestQueueBackend(options = {}) {
         const { isAlias, cacheKey } = MemoryStorageBackend.#resolveStorageKey(options);
-        const found = this.requestQueueBackendCache.find((queue) => queue.id === cacheKey ||
+        const found = this.#requestQueueBackendCache.find((queue) => queue.id === cacheKey ||
             queue.name?.toLowerCase() === cacheKey.toLowerCase() ||
             queue.cacheKey.toLowerCase() === cacheKey.toLowerCase());
         if (found) {
@@ -80,20 +110,20 @@ export class MemoryStorageBackend {
             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;
@@ -109,15 +139,13 @@ export class MemoryStorageBackend {
         // `#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()),
+            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

@@ -25,16 +25,11 @@ export declare class DatasetBackend<Data extends Dictionary = Dictionary> extend
     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;
 }

package/memory-storage/resource-clients/dataset.js

@@ -23,48 +23,45 @@ export class DatasetBackend extends BaseClient {
     modifiedAt = new Date();
     itemCount = 0;
     #datasetEntries = new Map();
-    // kept as TS-private: storage-backend tests read this field at runtime
-    storageBackend;
+    #storageBackend;
     constructor(options) {
         super(options.id ?? randomUUID());
         this.name = options.name;
         this.cacheKey = options.cacheKey ?? this.name ?? this.id;
-        this.storageBackend = options.storageBackend;
+        this.#storageBackend = options.storageBackend;
     }
     async getMetadata() {
-        this.updateTimestamps(false);
+        this.#updateTimestamps(false);
         return this.toDatasetInfo();
     }
     async drop() {
-        const storeIndex = this.storageBackend.datasetBackendCache.findIndex((store) => store.id === this.id);
-        if (storeIndex !== -1) {
-            const [oldBackend] = this.storageBackend.datasetBackendCache.splice(storeIndex, 1);
-            oldBackend.itemCount = 0;
-            oldBackend.#datasetEntries.clear();
+        if (this.#storageBackend.evictBackend('Dataset', this.id)) {
+            this.itemCount = 0;
+            this.#datasetEntries.clear();
         }
     }
     async purge() {
         this.itemCount = 0;
         this.#datasetEntries.clear();
-        this.updateTimestamps(true);
+        this.#updateTimestamps(true);
     }
     getData(options = {}) {
         const { desc, limit, offset } = parseArgument(options, schemas.datasetListItemsOptions);
-        return this.getDataPage({
+        return this.#getDataPage({
             desc,
             offset: offset ?? 0,
             limit: Math.min(limit ?? LIST_ITEMS_LIMIT, LIST_ITEMS_LIMIT),
         });
     }
-    async getDataPage(options = {}) {
+    async #getDataPage(options = {}) {
         const { limit = LIST_ITEMS_LIMIT, offset = 0, desc } = options;
-        const [start, end] = this.getStartAndEndIndexes(desc ? Math.max(this.itemCount - offset - limit, 0) : offset, limit);
+        const [start, end] = this.#getStartAndEndIndexes(desc ? Math.max(this.itemCount - offset - limit, 0) : offset, limit);
         const items = [];
         for (let idx = start; idx < end; idx++) {
-            const entryNumber = this.generateLocalEntryName(idx);
+            const entryNumber = this.#generateLocalEntryName(idx);
             items.push(this.#datasetEntries.get(entryNumber));
         }
-        this.updateTimestamps(false);
+        this.#updateTimestamps(false);
         return {
             count: items.length,
             desc: desc ?? false,
@@ -76,10 +73,10 @@ export class DatasetBackend extends BaseClient {
     }
     async pushData(items) {
         for (const entry of items) {
-            const idx = this.generateLocalEntryName(++this.itemCount);
+            const idx = this.#generateLocalEntryName(++this.itemCount);
             this.#datasetEntries.set(idx, JSON.parse(JSON.stringify(entry)));
         }
-        this.updateTimestamps(true);
+        this.#updateTimestamps(true);
     }
     toDatasetInfo() {
         return {
@@ -91,15 +88,15 @@ export class DatasetBackend extends BaseClient {
             name: this.name,
         };
     }
-    generateLocalEntryName(idx) {
+    #generateLocalEntryName(idx) {
         return idx.toString().padStart(LOCAL_ENTRY_NAME_DIGITS, '0');
     }
-    getStartAndEndIndexes(offset, limit = this.itemCount) {
+    #getStartAndEndIndexes(offset, limit = this.itemCount) {
         const start = offset + 1;
         const end = Math.min(offset + limit, this.itemCount) + 1;
         return [start, end];
     }
-    updateTimestamps(hasBeenModified) {
+    #updateTimestamps(hasBeenModified) {
         this.accessedAt = new Date();
         if (hasBeenModified) {
             this.modifiedAt = new Date();

package/memory-storage/resource-clients/key-value-store.d.ts

@@ -29,18 +29,10 @@ export declare class KeyValueStoreBackend extends BaseClient implements storage.
     createdAt: Date;
     accessedAt: Date;
     modifiedAt: Date;
-    private readonly storageBackend;
     constructor(options: KeyValueStoreBackendOptions);
     getMetadata(): Promise<storage.KeyValueStoreInfo>;
     drop(): Promise<void>;
     purge(): Promise<void>;
-    /**
-     * Purges every record except the run's input. Used by {@link MemoryStorageBackend.purge} for the
-     * default key-value store, mirroring `FileSystemStorageBackend`, which preserves `INPUT` (and its
-     * extension variants) when purging the default store. The in-memory key has no extension, so we
-     * preserve the bare `INPUT` key only.
-     */
-    purgeExceptInput(): Promise<void>;
     listKeys(options?: storage.KeyValueStoreListKeysOptions): Promise<storage.KeyValueStoreListKeysResult>;
     /**
      * In-memory records are not file-backed, so there is no public file URL to return.
@@ -59,5 +51,4 @@ export declare class KeyValueStoreBackend extends BaseClient implements storage.
     setValue(record: storage.KeyValueStoreInputRecord): Promise<void>;
     deleteValue(key: string): Promise<void>;
     toKeyValueStoreInfo(): storage.KeyValueStoreInfo;
-    private updateTimestamps;
 }

package/memory-storage/resource-clients/key-value-store.js

@@ -20,11 +20,6 @@ const inputRecordSchema = z.object({
     ]),
     contentType: z.string().min(1).optional(),
 });
-/**
- * Key under which a run's input is stored in the default key-value store. Matches Crawlee's default
- * `inputKey` (`CRAWLEE_INPUT_KEY`) and the `INPUT` files `FileSystemStorageBackend` preserves on purge.
- */
-const KEY_VALUE_STORE_INPUT_KEY = 'INPUT';
 export class KeyValueStoreBackend extends BaseClient {
     name;
     /**
@@ -36,42 +31,25 @@ export class KeyValueStoreBackend extends BaseClient {
     accessedAt = new Date();
     modifiedAt = new Date();
     #keyValueEntries = new Map();
-    // kept as TS-private: storage-backend tests read this field at runtime
-    storageBackend;
+    #storageBackend;
     constructor(options) {
         super(options.id ?? randomUUID());
         this.name = options.name;
         this.cacheKey = options.cacheKey ?? this.name ?? this.id;
-        this.storageBackend = options.storageBackend;
+        this.#storageBackend = options.storageBackend;
     }
     async getMetadata() {
-        this.updateTimestamps(false);
+        this.#updateTimestamps(false);
         return this.toKeyValueStoreInfo();
     }
     async drop() {
-        const storeIndex = this.storageBackend.keyValueStoreBackendCache.findIndex((store) => store.id === this.id);
-        if (storeIndex !== -1) {
-            const [oldBackend] = this.storageBackend.keyValueStoreBackendCache.splice(storeIndex, 1);
-            oldBackend.#keyValueEntries.clear();
+        if (this.#storageBackend.evictBackend('KeyValueStore', this.id)) {
+            this.#keyValueEntries.clear();
         }
     }
     async purge() {
         this.#keyValueEntries.clear();
-        this.updateTimestamps(true);
-    }
-    /**
-     * Purges every record except the run's input. Used by {@link MemoryStorageBackend.purge} for the
-     * default key-value store, mirroring `FileSystemStorageBackend`, which preserves `INPUT` (and its
-     * extension variants) when purging the default store. The in-memory key has no extension, so we
-     * preserve the bare `INPUT` key only.
-     */
-    async purgeExceptInput() {
-        for (const key of this.#keyValueEntries.keys()) {
-            if (key !== KEY_VALUE_STORE_INPUT_KEY) {
-                this.#keyValueEntries.delete(key);
-            }
-        }
-        this.updateTimestamps(true);
+        this.#updateTimestamps(true);
     }
     async listKeys(options = {}) {
         const { prefix, exclusiveStartKey, limit } = parseArgument(options, schemas.keyValueStoreListKeysOptions);
@@ -98,7 +76,7 @@ export class KeyValueStoreBackend extends BaseClient {
         const isTruncated = limit !== undefined && filteredItems.length > limit;
         const pageItems = isTruncated ? filteredItems.slice(0, limit) : filteredItems;
         const nextExclusiveStartKey = isTruncated ? pageItems[pageItems.length - 1].key : undefined;
-        this.updateTimestamps(false);
+        this.#updateTimestamps(false);
         return {
             items: pageItems,
             count: pageItems.length,
@@ -142,7 +120,7 @@ export class KeyValueStoreBackend extends BaseClient {
             // frontend treats it as "no content type" rather than a bogus value.
             contentType: entry.contentType ?? (mime.contentType(entry.extension) || undefined),
         };
-        this.updateTimestamps(false);
+        this.#updateTimestamps(false);
         return record;
     }
     async setValue(record) {
@@ -174,13 +152,13 @@ export class KeyValueStoreBackend extends BaseClient {
             contentType,
         };
         this.#keyValueEntries.set(key, normalizedRecord);
-        this.updateTimestamps(true);
+        this.#updateTimestamps(true);
     }
     async deleteValue(key) {
         parseArgument(key, keySchema);
         if (this.#keyValueEntries.has(key)) {
             this.#keyValueEntries.delete(key);
-            this.updateTimestamps(true);
+            this.#updateTimestamps(true);
         }
     }
     toKeyValueStoreInfo() {
@@ -192,7 +170,7 @@ export class KeyValueStoreBackend extends BaseClient {
             modifiedAt: this.modifiedAt,
         };
     }
-    updateTimestamps(hasBeenModified) {
+    #updateTimestamps(hasBeenModified) {
         this.accessedAt = new Date();
         if (hasBeenModified) {
             this.modifiedAt = new Date();

package/memory-storage/resource-clients/request-queue.d.ts

@@ -34,28 +34,10 @@ export declare class RequestQueueBackend extends BaseClient implements storage.R
     modifiedAt: Date;
     handledRequestCount: number;
     pendingRequestCount: number;
-    private readonly storageBackend;
     constructor(options: RequestQueueBackendOptions);
     getMetadata(): Promise<storage.RequestQueueInfo>;
     drop(): Promise<void>;
     purge(): Promise<void>;
-    private requestKeyIterator;
-    /**
-     * Scans the queue and returns the pending head — requests that are neither handled nor currently
-     * in progress — ordered by `orderNo`, deduplicated.
-     *
-     * When `detectInProgressRequests` is set, the result also carries an `hasInProgressRequests` flag
-     * telling whether any unhandled-but-in-progress request was skipped along the way. It lets
-     * {@link isFinished} distinguish "no work left at all" from "work remains, but it is currently being
-     * processed". Without it, a consumer with concurrency could consider the queue finished and shut the
-     * crawler down while it is still handling the last requests.
-     *
-     * Computing the flag is expensive: because an in-progress request may sit anywhere in the queue, it
-     * forces a scan of every pending entry even when only `limit` items are wanted. Callers that only
-     * need the head (e.g. {@link fetchNextRequest}, {@link isEmpty}) leave it off so the scan can stop as
-     * soon as the page is filled, keeping those calls O(head) instead of O(N).
-     */
-    private listPendingHead;
     fetchNextRequest(): Promise<storage.UpdateRequestSchema | undefined>;
     addBatchOfRequests(requests: storage.RequestSchema[], options?: storage.RequestQueueOperationOptions): Promise<storage.BatchAddRequestsResult>;
     getRequest(uniqueKey: string): Promise<storage.UpdateRequestSchema | undefined>;
@@ -70,8 +52,4 @@ export declare class RequestQueueBackend extends BaseClient implements storage.R
      */
     listItems(): Promise<storage.UpdateRequestSchema[]>;
     toRequestQueueInfo(): storage.RequestQueueInfo;
-    private updateTimestamps;
-    private jsonToRequest;
-    private createInternalRequest;
-    private calculateOrderNo;
 }