@crawlee/types 4.0.0-beta.14 → 4.0.0-beta.140

package/README.md

@@ -1,23 +1,23 @@
 <h1 align="center">
     <a href="https://crawlee.dev">
         <picture>
-          <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/apify/crawlee/master/website/static/img/crawlee-dark.svg?sanitize=true">
-          <img alt="Crawlee" src="https://raw.githubusercontent.com/apify/crawlee/master/website/static/img/crawlee-light.svg?sanitize=true" width="500">
+          <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/apify/crawlee/master/website/static/img/crawlee-dark.svg?sanitize=true" />
+          <img alt="Crawlee" src="https://raw.githubusercontent.com/apify/crawlee/master/website/static/img/crawlee-light.svg?sanitize=true" width="500" />
         </picture>
     </a>
-    <br>
+    <br />
     <small>A web scraping and browser automation library</small>
 </h1>
 
-<p align=center>
-    <a href="https://trendshift.io/repositories/5179" target="_blank"><img src="https://trendshift.io/api/badge/repositories/5179" alt="apify%2Fcrawlee | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+<p align="center">
+    <a href="https://trendshift.io/repositories/5179" target="_blank"><img src="https://trendshift.io/api/badge/repositories/5179" alt="apify%2Fcrawlee | Trendshift" width="250" height="55"/></a>
 </p>
 
-<p align=center>
-    <a href="https://www.npmjs.com/package/@crawlee/core" rel="nofollow"><img src="https://img.shields.io/npm/v/@crawlee/core.svg" alt="NPM latest version" data-canonical-src="https://img.shields.io/npm/v/@crawlee/core/next.svg" style="max-width: 100%;"></a>
-    <a href="https://www.npmjs.com/package/@crawlee/core" rel="nofollow"><img src="https://img.shields.io/npm/dm/@crawlee/core.svg" alt="Downloads" data-canonical-src="https://img.shields.io/npm/dm/@crawlee/core.svg" style="max-width: 100%;"></a>
-    <a href="https://discord.gg/jyEM2PRvMU" rel="nofollow"><img src="https://img.shields.io/discord/801163717915574323?label=discord" alt="Chat on discord" data-canonical-src="https://img.shields.io/discord/801163717915574323?label=discord" style="max-width: 100%;"></a>
-    <a href="https://github.com/apify/crawlee/actions/workflows/test-ci.yml"><img src="https://github.com/apify/crawlee/actions/workflows/test-ci.yml/badge.svg?branch=master" alt="Build Status" style="max-width: 100%;"></a>
+<p align="center">
+    <a href="https://www.npmjs.com/package/@crawlee/core" rel="nofollow"><img src="https://img.shields.io/npm/v/@crawlee/core.svg" alt="NPM latest version" data-canonical-src="https://img.shields.io/npm/v/@crawlee/core/next.svg" /></a>
+    <a href="https://www.npmjs.com/package/@crawlee/core" rel="nofollow"><img src="https://img.shields.io/npm/dm/@crawlee/core.svg" alt="Downloads" data-canonical-src="https://img.shields.io/npm/dm/@crawlee/core.svg" /></a>
+    <a href="https://discord.gg/jyEM2PRvMU" rel="nofollow"><img src="https://img.shields.io/discord/801163717915574323?label=discord" alt="Chat on discord" data-canonical-src="https://img.shields.io/discord/801163717915574323?label=discord" /></a>
+    <a href="https://github.com/apify/crawlee/actions/workflows/test-ci.yml"><img src="https://github.com/apify/crawlee/actions/workflows/test-ci.yml/badge.svg?branch=master" alt="Build Status" /></a>
 </p>
 
 Crawlee covers your crawling and scraping end-to-end and **helps you build reliable scrapers. Fast.**
@@ -89,7 +89,7 @@ By default, Crawlee stores data to `./storage` in the current working directory.
 We provide automated beta builds for every merged code change in Crawlee. You can find them in the npm [list of releases](https://www.npmjs.com/package/crawlee?activeTab=versions). If you want to test new features or bug fixes before we release them, feel free to install a beta build like this:
 
 ```bash
-npm install crawlee@3.12.3-beta.13
+npm install crawlee@next
 ```
 
 If you also use the [Apify SDK](https://github.com/apify/apify-sdk-js), you need to specify dependency overrides in your `package.json` file so that you don't end up with multiple versions of Crawlee installed:
@@ -98,9 +98,9 @@ If you also use the [Apify SDK](https://github.com/apify/apify-sdk-js), you need
 {
     "overrides": {
        "apify": {
-           "@crawlee/core": "3.12.3-beta.13",
-           "@crawlee/types": "3.12.3-beta.13",
-           "@crawlee/utils": "3.12.3-beta.13"
+           "@crawlee/core": "$crawlee",
+           "@crawlee/types": "$crawlee",
+           "@crawlee/utils": "$crawlee"
        }
     }
 }

package/browser.d.ts

@@ -1,3 +1,4 @@
+import type { ISession } from './session.js';
 import type { Dictionary } from './utility-types.js';
 export interface Cookie {
     /**
@@ -60,4 +61,106 @@ export interface BrowserLikeResponse {
     url(): string;
     headers(): Dictionary<string | string[]>;
 }
-//# sourceMappingURL=browser.d.ts.map
+/**
+ * A snapshot of the relevant state of a page, as extracted by
+ * {@link IBrowserPool.extractPageState}.
+ */
+export interface PageState {
+    /**
+     * Cookies currently set in the page's browsing context.
+     */
+    cookies: Cookie[];
+}
+/**
+ * Options accepted by {@link IBrowserPool.newPage}.
+ */
+export interface NewPageOptions {
+    /**
+     * Assign a custom ID to the page. If you don't provide one, a random string
+     * ID is generated.
+     */
+    id?: string;
+    /**
+     * The crawling session that will use the returned page.
+     *
+     * The pool derives proxy configuration from the session's {@link
+     * ProxyInfo|proxy} (including TLS-error handling) — there are intentionally
+     * no standalone `proxyUrl` / `ignoreTlsErrors` options; configure them
+     * through the session instead.
+     *
+     * Session injection is **best-effort**: the pool may use the session's
+     * {@link ProxyInfo|proxy}, cookies, or fingerprint data to configure the
+     * page or the underlying browser, but none of this is guaranteed. Different
+     * pool implementations (or pool configurations such as `useIncognitoPages`)
+     * may support different subsets of session properties — or ignore them
+     * entirely.
+     *
+     * The crawler is still responsible for deterministic session setup (e.g.
+     * injecting cookies into the page before navigation) that must happen
+     * regardless of pool implementation.
+     */
+    session?: ISession;
+}
+/**
+ * Minimal contract that any object passed to a browser crawler as its `browserPool`
+ * option must satisfy.
+ *
+ * Lifecycle (`destroy`) is the responsibility of whoever owns the pool — since a
+ * user-supplied pool is never owned by the crawler, the crawler never tears it
+ * down.
+ *
+ * Implement this interface to plug a custom page-provisioning strategy into any
+ * Crawlee browser crawler — for example a remote browser farm, a session-aware
+ * pool that pins pages to fingerprints differently, or a thin wrapper around the
+ * built-in `BrowserPool`.
+ *
+ * @category Browser management
+ */
+export interface IBrowserPool<Page = unknown> {
+    /**
+     * Opens a new page. The pool decides which browser to use, launching a new
+     * one if needed.
+     */
+    newPage(options?: NewPageOptions): Promise<Page>;
+    /**
+     * Signals the pool that the caller is done with the page. The pool is
+     * responsible for closing the page and performing any necessary cleanup
+     * (e.g. retiring the underlying browser when a session has gone bad).
+     *
+     * @param page The page to release back to the pool.
+     * @param options.error If the page is being released because of an error,
+     *   pass the error here. In particular, if the error is a
+     *   {@link SessionError}, implementations should treat it as a signal
+     *   to purge all state associated with the session (e.g. discard any
+     *   browser that served the page).
+     */
+    closePage(page: Page, options?: {
+        error?: Error;
+    }): Promise<void>;
+    /**
+     * Extracts the relevant state from a page so the caller can persist it —
+     * for example, back-propagating cookies into the crawling {@link
+     * ISession|session}.
+     *
+     * @param page The page to read state from.
+     */
+    extractPageState(page: Page): Promise<PageState>;
+    /**
+     * Injects state (currently just cookies) into a page. This is the
+     * counterpart to {@link IBrowserPool.extractPageState} and lets the
+     * caller set up a page — for example, seeding it with the crawling
+     * {@link ISession|session}'s cookies before navigation.
+     *
+     * As with {@link IBrowserPool.newPage}, the caller decides *what* state
+     * to inject, while the pool decides *how*.
+     *
+     * Isolation between pages is **best-effort**: depending on the pool
+     * implementation and its configuration, multiple pages may share a browsing
+     * context, so injected state (such as cookies) can bleed across pages
+     * served by the same underlying browser.
+     *
+     * @param page The page to inject state into.
+     * @param state The state to inject.
+     */
+    injectPageState(page: Page, state: PageState): Promise<void>;
+}

package/browser.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=browser.js.map

package/cookies.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Cookie shape used by {@link CookieJar}. Structurally compatible with `tough-cookie`'s
+ * `Cookie` class, so a `tough-cookie` cookie satisfies it without `@crawlee/types` depending
+ * on `tough-cookie` itself.
+ */
+export interface SessionCookie {
+    key: string;
+    value: string;
+    expires: Date | 'Infinity' | null;
+    maxAge: number | 'Infinity' | '-Infinity' | null;
+    domain: string | null;
+    path: string | null;
+    secure: boolean;
+    httpOnly: boolean;
+    extensions: string[] | null;
+    creation: Date | 'Infinity' | null;
+    creationIndex: number;
+    hostOnly: boolean | null;
+    pathIsDefault: boolean | null;
+    lastAccessed: Date | 'Infinity' | null;
+    sameSite: string | undefined;
+    toJSON(): Record<string, unknown>;
+    clone(): SessionCookie | undefined;
+    validate(): boolean;
+    setExpires(exp: string | Date): void;
+    setMaxAge(age: number): void;
+    cookieString(): string;
+    toString(): string;
+    TTL(now?: number): number;
+    expiryTime(now?: Date): number | undefined;
+    expiryDate(now?: Date): Date | undefined;
+    isPersistent(): boolean;
+    canonicalizedDomain(): string | undefined;
+    cdomain(): string | undefined;
+}
+/**
+ * Options for {@link CookieJar.setCookie}. Structurally compatible with `tough-cookie`'s
+ * `SetCookieOptions`.
+ */
+export interface CookieJarSetCookieOptions {
+    loose?: boolean;
+    sameSiteContext?: 'strict' | 'lax' | 'none';
+    ignoreError?: boolean;
+    http?: boolean;
+    now?: Date;
+}
+/**
+ * Options for {@link CookieJar}'s cookie-reading methods. Structurally compatible with
+ * `tough-cookie`'s `GetCookiesOptions`.
+ */
+export interface CookieJarGetCookiesOptions {
+    http?: boolean;
+    expire?: boolean;
+    allPaths?: boolean;
+    sameSiteContext?: 'none' | 'lax' | 'strict';
+    sort?: boolean;
+}
+/**
+ * Cookie jar contract, structurally compatible with `tough-cookie`'s `CookieJar` — which is
+ * what backs {@link Session} by default — so `@crawlee/types` does not have to depend on
+ * `tough-cookie` for it.
+ */
+export interface CookieJar {
+    setCookie(cookie: string | SessionCookie, url: string | URL, options?: CookieJarSetCookieOptions): Promise<SessionCookie | undefined>;
+    getCookies(url: string | URL, options?: CookieJarGetCookiesOptions): Promise<SessionCookie[]>;
+    getCookieString(url: string | URL, options?: CookieJarGetCookiesOptions): Promise<string>;
+    getSetCookieStrings(url: string | URL, options?: CookieJarGetCookiesOptions): Promise<string[] | undefined>;
+    serialize(): Promise<SerializedCookieJar>;
+    toJSON(): SerializedCookieJar | undefined;
+    clone(): Promise<CookieJar>;
+}
+/**
+ * JSON representation of a {@link CookieJar}. Structurally compatible with `tough-cookie`'s
+ * `SerializedCookieJar`.
+ */
+export interface SerializedCookieJar {
+    version: string;
+    storeType: string | null;
+    rejectPublicSuffixes: boolean;
+    cookies: Record<string, unknown>[];
+    [key: string]: unknown;
+}

package/cookies.js

@@ -0,0 +1 @@
+export {};

package/http-client.d.ts

@@ -0,0 +1,83 @@
+import type { Readable } from 'node:stream';
+import type { CookieJar } from './cookies.js';
+import type { ISession } from './session.js';
+import type { AllowedHttpMethods } from './utility-types.js';
+export type SearchParams = string | URLSearchParams | Record<string, string | number | boolean | null | undefined>;
+/**
+ * HTTP Request as accepted by {@link BaseHttpClient} methods.
+ */
+export interface HttpRequest {
+    url: string | URL;
+    method?: AllowedHttpMethods;
+    headers?: Headers;
+    body?: Readable;
+    signal?: AbortSignal;
+    timeout?: number;
+    cookieJar?: CookieJar;
+    followRedirect?: boolean | ((response: any) => boolean);
+    maxRedirects?: number;
+    encoding?: BufferEncoding;
+    throwHttpErrors?: boolean;
+    proxyUrl?: string;
+    headerGeneratorOptions?: Record<string, unknown>;
+    useHeaderGenerator?: boolean;
+    headerGenerator?: {
+        getHeaders: (options: Record<string, unknown>) => Record<string, string>;
+    };
+    insecureHTTPParser?: boolean;
+    sessionToken?: object;
+}
+/**
+ * Additional options for HTTP requests that need to be handled separately before passing to {@link BaseHttpClient}.
+ */
+export interface HttpRequestOptions extends HttpRequest {
+    /** Search (query string) parameters to be appended to the request URL */
+    searchParams?: SearchParams;
+    /** A form to be sent in the HTTP request body (URL encoding will be used) */
+    form?: Record<string, string>;
+    /** Arbitrary object to be JSON-serialized and sent as the HTTP request body */
+    json?: unknown;
+    /** Basic HTTP Auth username */
+    username?: string;
+    /** Basic HTTP Auth password */
+    password?: string;
+}
+/**
+ * Type of a function called when an HTTP redirect takes place. It is allowed to mutate the `updatedRequest` argument.
+ */
+export type RedirectHandler = (redirectResponse: Response, updatedRequest: {
+    url?: string | URL;
+    headers: Headers;
+}) => void;
+export interface SendRequestOptions {
+    session?: ISession;
+    cookieJar?: CookieJar;
+    /** Timeout for the HTTP request in milliseconds. */
+    timeoutMillis?: number;
+    /** An AbortSignal to cancel the HTTP request. */
+    signal?: AbortSignal;
+    /**
+     * Overrides the proxy URL set in the `session` for this request.
+     *
+     * Note that setting this manually can interfere with session proxy rotation.
+     */
+    proxyUrl?: string;
+    /**
+     * When `true`, TLS certificate errors are ignored for this request. Also enabled by
+     * `session.proxyInfo.ignoreTlsErrors` (MITM proxies). Best-effort: clients that cannot
+     * disable TLS verification (e.g. the native fetch fallback) ignore it.
+     */
+    ignoreTlsErrors?: boolean;
+}
+export interface StreamOptions extends SendRequestOptions {
+    onRedirect?: RedirectHandler;
+}
+/**
+ * Interface for user-defined HTTP clients to be used for plain HTTP crawling and for sending additional requests during a crawl.
+ */
+export interface BaseHttpClient {
+    /**
+     * Perform an HTTP Request and return the complete response.
+     */
+    sendRequest(request: Request, options?: SendRequestOptions): Promise<Response>;
+}

package/http-client.js

@@ -0,0 +1 @@
+export {};

package/index.d.ts

@@ -1,4 +1,8 @@
-export * from './storages.js';
-export * from './utility-types.js';
-export * from './browser.js';
-//# sourceMappingURL=index.d.ts.map
+export type * from './status-message.js';
+export type * from './storages.js';
+export type * from './utility-types.js';
+export type * from './browser.js';
+export type * from './cookies.js';
+export type * from './http-client.js';
+export type * from './session.js';
+export type * from './logger.js';

package/index.js

@@ -1,4 +1 @@
-export * from './storages.js';
-export * from './utility-types.js';
-export * from './browser.js';
-//# sourceMappingURL=index.js.map
+export {};

package/logger.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Configuration options for Crawlee logger implementations.
+ */
+export interface CrawleeLoggerOptions {
+    /** Prefix to be prepended to each logged line. */
+    prefix?: string | null;
+}
+/**
+ * Interface for Crawlee logger implementations.
+ * This allows users to inject custom loggers (e.g., Winston, Pino) while maintaining
+ * compatibility with the default `@apify/log` implementation.
+ */
+export interface CrawleeLogger {
+    /**
+     * Returns the logger configuration.
+     */
+    getOptions(): CrawleeLoggerOptions;
+    /**
+     * Configures logger options.
+     */
+    setOptions(options: Partial<CrawleeLoggerOptions>): void;
+    /**
+     * Creates a new instance of logger that inherits settings from a parent logger.
+     */
+    child(options: Partial<CrawleeLoggerOptions>): CrawleeLogger;
+    /**
+     * Logs an `ERROR` message.
+     */
+    error(message: string, data?: Record<string, unknown>): void;
+    /**
+     * Logs an `ERROR` level message with a nicely formatted exception.
+     */
+    exception(exception: Error, message: string, data?: Record<string, unknown>): void;
+    /**
+     * Logs a `SOFT_FAIL` level message.
+     */
+    softFail(message: string, data?: Record<string, unknown>): void;
+    /**
+     * Logs a `WARNING` level message.
+     */
+    warning(message: string, data?: Record<string, unknown>): void;
+    /**
+     * Logs a `WARNING` level message only once.
+     */
+    warningOnce(message: string): void;
+    /**
+     * Logs an `INFO` message.
+     */
+    info(message: string, data?: Record<string, unknown>): void;
+    /**
+     * Logs a `DEBUG` message.
+     */
+    debug(message: string, data?: Record<string, unknown>): void;
+    /**
+     * Logs a `PERF` level message for performance tracking.
+     */
+    perf(message: string, data?: Record<string, unknown>): void;
+    /**
+     * Logs given message only once as WARNING for deprecated features.
+     */
+    deprecated(message: string): void;
+    /**
+     * Logs a message at the given level. Useful when the log level is determined dynamically.
+     */
+    logWithLevel(level: number, message: string, data?: Record<string, unknown>): void;
+}

package/logger.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@crawlee/types",
-    "version": "4.0.0-beta.14",
+    "version": "4.0.0-beta.140",
     "description": "Shared types for the crawlee projects",
     "engines": {
         "node": ">=22.0.0"
@@ -34,7 +34,7 @@
     },
     "homepage": "https://crawlee.dev",
     "scripts": {
-        "build": "yarn clean && yarn compile && yarn copy",
+        "build": "pnpm clean && pnpm compile && pnpm copy",
         "clean": "rimraf ./dist",
         "compile": "tsc -p tsconfig.build.json",
         "copy": "tsx ../../scripts/copy.ts"
@@ -52,5 +52,5 @@
             }
         }
     },
-    "gitHead": "3d889c957289f962078c1e095f33897595b42632"
+    "gitHead": "70f846b4f05d89b34ccfded676e766fdbbdc5e66"
 }

package/session.d.ts

@@ -0,0 +1,152 @@
+import type { CookieJar, SerializedCookieJar } from './cookies.js';
+/**
+ * The main purpose of the ProxyInfo object is to provide information
+ * about the current proxy connection used by the crawler for the request.
+ * Outside of crawlers, you can get this object by calling {@link ProxyConfiguration.newProxyInfo}.
+ *
+ * **Example usage:**
+ *
+ * ```javascript
+ * const proxyConfiguration = new ProxyConfiguration({
+ *   proxyUrls: ['...', '...'] // List of Proxy URLs to rotate
+ * });
+ *
+ * // Getting proxyInfo object by calling class method directly
+ * const proxyInfo = await proxyConfiguration.newProxyInfo();
+ *
+ * // In crawler
+ * const crawler = new CheerioCrawler({
+ *   // ...
+ *   proxyConfiguration,
+ *   requestHandler({ proxyInfo }) {
+ *      // Getting used proxy URL
+ *       const proxyUrl = proxyInfo.url;
+ *   }
+ * })
+ *
+ * ```
+ */
+export interface ProxyInfo {
+    /**
+     * The URL of the proxy.
+     */
+    url: string;
+    /**
+     * Username for the proxy.
+     */
+    username?: string;
+    /**
+     * User's password for the proxy.
+     */
+    password: string;
+    /**
+     * Hostname of your proxy.
+     */
+    hostname: string;
+    /**
+     * Proxy port.
+     */
+    port: number | string;
+    /**
+     * When `true`, the proxy is likely intercepting HTTPS traffic and is able to view and modify its content.
+     * The built-in HTTP clients and the browser pool disable TLS certificate verification for the session's
+     * requests when this is set.
+     *
+     * @default false
+     */
+    ignoreTlsErrors?: boolean;
+}
+/**
+ * Identifies the browser-like profile a {@link Session} is impersonating, so
+ * repeated requests with the same session look consistent to the target server.
+ *
+ * These fields are *hints* — `browser`, `platform`, `device`. Consumers
+ * (`@crawlee/browser-pool`, `@crawlee/impit-client`, …) derive their own rich
+ * state from them (e.g. a full browser fingerprint, a TLS impersonation profile)
+ * and cache it on their own; the session itself is read-only intent.
+ */
+export interface SessionFingerprint {
+    /** Browser family — consumed by HTTP clients that impersonate (e.g. `impit`). */
+    browser?: 'chrome' | 'firefox' | 'safari' | 'edge';
+    /** Platform hint — used by header generators and as a virtual session key. */
+    platform?: 'windows' | 'macos' | 'linux' | 'android' | 'ios';
+    /** Device class — drives header generation and viewport defaults. */
+    device?: 'desktop' | 'mobile';
+}
+/**
+ * Persistable {@link Session} state.
+ */
+export interface SessionState {
+    id: string;
+    cookieJar: SerializedCookieJar;
+    proxyInfo?: ProxyInfo;
+    userData: object;
+    fingerprint?: SessionFingerprint;
+    errorScore: number;
+    maxErrorScore: number;
+    errorScoreDecrement: number;
+    usageCount: number;
+    maxUsageCount: number;
+    expiresAt: string;
+    createdAt: string;
+    retired: boolean;
+}
+/**
+ * Sessions are used to store information such as cookies and can be used for generating fingerprints and proxy sessions.
+ * You can imagine each session as a specific user, with its own cookies, IP (via proxy) and potentially a unique browser fingerprint.
+ * Session internal state can be enriched with custom user data for example some authorization tokens and specific headers in general.
+ * @category Scaling
+ */
+export interface ISession {
+    readonly id: string;
+    cookieJar: CookieJar;
+    proxyInfo?: ProxyInfo;
+    fingerprint?: SessionFingerprint;
+    /**
+     * Indicates whether the session can be used for next requests.
+     * Session is usable when it is not expired, not blocked and the maximum usage count has not been reached.
+     */
+    isUsable(): boolean;
+    /**
+     * This method should be called after a successful session usage.
+     */
+    markGood(): void;
+    /**
+     * Marks session as blocked.
+     * This method should be used if the session usage was unsuccessful
+     * and you are sure that it is because of the session configuration and not any external matters.
+     * For example when server returns 403 status code.
+     * If the session does not work due to some external factors as server error such as 5XX you probably want to use `markBad` method.
+     */
+    retire(): void;
+    /**
+     * Increases usage and error count.
+     * Should be used when the session has been used unsuccessfully. For example because of timeouts.
+     */
+    markBad(): void;
+}
+/**
+ * Minimal contract that any object passed to a crawler as its `sessionPool` option must satisfy.
+ *
+ * Crawlers only depend on a single method of the built-in `SessionPool`: `getSession()` /
+ * `getSession(id)` to hand out an {@link ISession} for a request. Lifecycle (reset, teardown)
+ * is the responsibility of whoever owns the pool — since a user-supplied pool is never owned by
+ * the crawler, the crawler never tears it down.
+ *
+ * Implement this interface to plug a custom session-management strategy into any Crawlee crawler —
+ * for example a remote, multi-process pool, a database-backed pool, or a thin wrapper around the
+ * built-in `SessionPool` with different rotation rules.
+ *
+ * @category Scaling
+ */
+export interface ISessionPool {
+    /**
+     * Returns a usable {@link ISession}. Without an id, the pool decides which session to return
+     * (creating a new one when appropriate). With an id, the pool returns the matching session if
+     * it is still usable.
+     *
+     * In case the `SessionPool` cannot provide a usable session given the configuration,
+     * this method may return `undefined`.
+     */
+    getSession(sessionId?: string): Promise<ISession | undefined>;
+}

package/session.js

@@ -0,0 +1 @@
+export {};

package/status-message.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Options for setting a crawler run's status message via {@link BasicCrawler.setStatusMessage}.
+ *
+ * Setting a status message is not a storage concern — the crawler broadcasts it through the event
+ * system (`EventType.STATUS_MESSAGE`), and integrations such as the Apify SDK forward it to their
+ * status-reporting backend.
+ */
+export interface SetStatusMessageOptions {
+    /** Whether this is the final status message of the run. */
+    isStatusMessageTerminal?: boolean;
+    /** The log level to log the message with. Defaults to `'DEBUG'`. */
+    level?: 'DEBUG' | 'INFO' | 'WARNING' | 'ERROR';
+}

package/status-message.js

@@ -0,0 +1 @@
+export {};

package/storages.d.ts

@@ -11,16 +11,13 @@ export interface QueueOperationInfo {
     /** The ID of the added request */
     requestId: string;
 }
-export interface DatasetCollectionClientOptions {
-    storageDir: string;
-}
-export interface DatasetCollectionData {
-    id: string;
-    name?: string;
-    createdAt: Date;
-    modifiedAt: Date;
-    accessedAt: Date;
-}
+/**
+ * A single page of items returned by {@link DatasetBackend.getData}.
+ *
+ * Datasets paginate by offset, so a page is self-describing via `total` / `offset` / `limit`: a
+ * frontend assembling all pages knows it has reached the end once `offset + items.length >= total`.
+ * The cursor-based counterpart for key-value stores is {@link KeyValueStoreListKeysResult}.
+ */
 export interface PaginatedList<Data> {
     /** Total count of entries in the dataset. */
     total: number;
@@ -35,20 +32,7 @@ export interface PaginatedList<Data> {
     /** Dataset entries based on chosen format parameter. */
     items: Data[];
 }
-export interface Dataset extends DatasetCollectionData {
-    itemCount: number;
-}
-/**
- * Dataset collection client.
- */
-export interface DatasetCollectionClient {
-    list(): Promise<PaginatedList<Dataset>>;
-    getOrCreate(name?: string): Promise<DatasetCollectionData>;
-}
-export interface DatasetClientUpdateOptions {
-    name?: string;
-}
-export interface DatasetClientListOptions {
+export interface DatasetBackendListOptions {
     desc?: boolean;
     limit?: number;
     offset?: number;
@@ -60,164 +44,158 @@ export interface DatasetInfo {
     modifiedAt: Date;
     accessedAt: Date;
     itemCount: number;
-    actId?: string;
-    actRunId?: string;
 }
-export interface DatasetStats {
-    readCount?: number;
-    writeCount?: number;
-    deleteCount?: number;
-    storageBytes?: number;
-}
-export interface DatasetClient<Data extends Dictionary = Dictionary> {
-    get(): Promise<DatasetInfo | undefined>;
-    update(newFields: DatasetClientUpdateOptions): Promise<Partial<DatasetInfo>>;
-    delete(): Promise<void>;
-    downloadItems(...args: unknown[]): Promise<Buffer>;
-    listItems(options?: DatasetClientListOptions): Promise<PaginatedList<Data>>;
-    pushItems(items: Data | Data[] | string | string[]): Promise<void>;
-}
-export interface KeyValueStoreStats {
-    readCount?: number;
-    writeCount?: number;
-    deleteCount?: number;
-    listCount?: number;
-    storageBytes?: number;
+export interface DatasetBackend<Data extends Dictionary = Dictionary> {
+    /**
+     * Returns metadata about the dataset (id, name, timestamps, item count, etc.).
+     *
+     * Implementations should throw if the underlying storage no longer exists
+     * (e.g. it was deleted externally). This method should never return stale data
+     * for a storage that has been removed.
+     */
+    getMetadata(): Promise<DatasetInfo>;
+    /** Remove the dataset and all its data. */
+    drop(): Promise<void>;
+    /** Remove all items from the dataset but keep the dataset itself. */
+    purge(): Promise<void>;
+    /** Add items to the dataset. */
+    pushData(items: Data[]): Promise<void>;
+    /** Fetch a page of items from the dataset. */
+    getData(options?: DatasetBackendListOptions): Promise<PaginatedList<Data>>;
 }
 export interface KeyValueStoreInfo {
     id: string;
     name?: string;
-    userId?: string;
     createdAt: Date;
     modifiedAt: Date;
     accessedAt: Date;
-    actId?: string;
-    actRunId?: string;
-    stats?: KeyValueStoreStats;
 }
 /**
- * Key-value store collection client.
+ * The value a serialized record carries on the way *into* a storage backend (`setValue`).
+ *
+ * The `KeyValueStore` frontend has already serialized by this point, so it is a pre-serialized
+ * string, raw bytes (`Buffer` / `ArrayBuffer` / typed array), or a stream the client drains.
+ */
+export type KeyValueStoreRecordInputValue = Buffer | ArrayBuffer | ArrayBufferView | string | NodeJS.ReadableStream | ReadableStream;
+/**
+ * A record as returned by a storage backend (`getValue`).
+ *
+ * Storage backends are byte transports: they persist and return bytes verbatim and never serialize
+ * or parse. Interpretation is the `KeyValueStore` frontend's job (it parses according to the content
+ * type via `parseValue`). The value is therefore always raw bytes — a `Buffer` (Node) or an
+ * `ArrayBuffer` (browser backends).
  */
-export interface KeyValueStoreCollectionClient {
-    list(): Promise<PaginatedList<KeyValueStoreInfo>>;
-    getOrCreate(name?: string): Promise<KeyValueStoreInfo>;
-}
 export interface KeyValueStoreRecord {
     key: string;
-    value: any;
+    value: Buffer | ArrayBuffer;
     contentType?: string;
 }
-export interface KeyValueStoreRecordOptions {
-    timeoutSecs?: number;
-    doNotRetryTimeouts?: boolean;
-}
-export interface KeyValueStoreClientUpdateOptions {
-    name?: string;
+/**
+ * A record passed to a storage backend for writing (`setValue`). Like {@link KeyValueStoreRecord} but
+ * with the lenient, pre-serialized {@link KeyValueStoreRecordInputValue} for the value.
+ */
+export interface KeyValueStoreInputRecord {
+    key: string;
+    value: KeyValueStoreRecordInputValue;
+    contentType?: string;
 }
-export interface KeyValueStoreClientListOptions {
-    limit?: number;
-    exclusiveStartKey?: string;
-    collection?: string;
+export interface KeyValueStoreListKeysOptions {
+    /** If set, only keys that start with this prefix are returned. */
     prefix?: string;
+    /** All keys up to this one are skipped from the result. */
+    exclusiveStartKey?: string;
+    /** Maximum number of keys to return. */
+    limit?: number;
 }
 export interface KeyValueStoreItemData {
     key: string;
     size: number;
+    /** The MIME content type the record was stored with, if known. */
+    contentType: string;
 }
-export interface KeyValueStoreClientListData {
+/**
+ * A single page of keys returned by {@link KeyValueStoreBackend.listKeys}.
+ *
+ * This mirrors {@link PaginatedList} (the shape returned by {@link DatasetBackend.getData}) so that
+ * both listing operations on the storage backend layer return a self-describing page. The difference
+ * is the pagination model: datasets are offset-based (`total` / `offset`), whereas key-value stores
+ * are cursor-based. A frontend assembling all pages should therefore not guess "is this the last
+ * page?" from `items.length < limit` — it should rely on {@link isTruncated} and resume from
+ * {@link nextExclusiveStartKey}.
+ */
+export interface KeyValueStoreListKeysResult {
+    /** Keys returned on this page. */
+    items: KeyValueStoreItemData[];
+    /** Number of keys returned on this page (`items.length`). */
     count: number;
+    /** Maximum number of keys requested for this page. */
     limit: number;
+    /** The `exclusiveStartKey` that produced this page, if any. */
     exclusiveStartKey?: string;
+    /** `true` if there are more keys beyond this page. When `true`, {@link nextExclusiveStartKey} is set. */
     isTruncated: boolean;
+    /** Cursor to pass as the next call's `exclusiveStartKey`, or `undefined` when {@link isTruncated} is `false`. */
     nextExclusiveStartKey?: string;
-    items: KeyValueStoreItemData[];
-}
-export interface KeyValueStoreClientGetRecordOptions {
-    buffer?: boolean;
-    stream?: boolean;
 }
 /**
  * Key-value Store client.
  */
-export interface KeyValueStoreClient {
-    get(): Promise<KeyValueStoreInfo | undefined>;
-    update(newFields: KeyValueStoreClientUpdateOptions): Promise<Partial<KeyValueStoreInfo>>;
-    delete(): Promise<void>;
-    listKeys(options?: KeyValueStoreClientListOptions): Promise<KeyValueStoreClientListData>;
+export interface KeyValueStoreBackend {
+    /**
+     * Returns metadata about the key-value store (id, name, timestamps, etc.).
+     *
+     * Implementations should throw if the underlying storage no longer exists
+     * (e.g. it was deleted externally). This method should never return stale data
+     * for a storage that has been removed.
+     */
+    getMetadata(): Promise<KeyValueStoreInfo>;
+    /** Remove the key-value store and all its data. */
+    drop(): Promise<void>;
+    /** Remove all records from the store but keep the store itself. */
+    purge(): Promise<void>;
+    /**
+     * Get a record by key. Returns the raw bytes plus content type, or `undefined` if not found.
+     *
+     * Clients are byte transports and must not parse the body — the `KeyValueStore` frontend
+     * interprets it according to the content type.
+     */
+    getValue(key: string): Promise<KeyValueStoreRecord | undefined>;
+    /** Set a record value. */
+    setValue(record: KeyValueStoreInputRecord): Promise<void>;
+    /** Delete a record by key. */
+    deleteValue(key: string): Promise<void>;
+    /**
+     * List a single page of keys in the store. Returns at most `limit` keys starting after
+     * `exclusiveStartKey`, wrapped in a self-describing page.
+     *
+     * Like {@link DatasetBackend.getData}, this returns one page rather than the whole collection;
+     * assembling all pages (e.g. for `KeyValueStore.keys()`) is the frontend's job. The result carries
+     * a cursor (`isTruncated` / `nextExclusiveStartKey`) so the frontend can paginate deterministically
+     * instead of inferring the end from `items.length < limit`.
+     */
+    listKeys(options?: KeyValueStoreListKeysOptions): Promise<KeyValueStoreListKeysResult>;
+    /** Get the public URL for a record, or `undefined` if unavailable. */
+    getPublicUrl(key: string): Promise<string | undefined>;
+    /** Check whether a record with the given key exists. */
     recordExists(key: string): Promise<boolean>;
-    getRecord(key: string, options?: KeyValueStoreClientGetRecordOptions): Promise<KeyValueStoreRecord | undefined>;
-    setRecord(record: KeyValueStoreRecord, options?: KeyValueStoreRecordOptions): Promise<void>;
-    deleteRecord(key: string): Promise<void>;
-}
-export interface RequestQueueStats {
-    readCount?: number;
-    writeCount?: number;
-    deleteCount?: number;
-    headItemReadCount?: number;
-    storageBytes?: number;
 }
 export interface RequestQueueInfo {
     id: string;
     name?: string;
-    userId?: string;
     createdAt: Date;
     modifiedAt: Date;
     accessedAt: Date;
-    expireAt?: string;
     totalRequestCount: number;
     handledRequestCount: number;
     pendingRequestCount: number;
-    actId?: string;
-    actRunId?: string;
-    hadMultipleClients?: boolean;
-    stats?: RequestQueueStats;
 }
 /**
- * Request queue collection client.
+ * Options for request-queue operations that add or return requests to the queue
+ * ({@link RequestQueueBackend.addBatchOfRequests}, {@link RequestQueueBackend.reclaimRequest}).
  */
-export interface RequestQueueCollectionClient {
-    list(): Promise<PaginatedList<RequestQueueInfo>>;
-    getOrCreate(name: string): Promise<RequestQueueInfo>;
-}
-export interface RequestQueueHeadItem {
-    id: string;
-    retryCount: number;
-    uniqueKey: string;
-    url: string;
-    method: AllowedHttpMethods;
-}
-export interface QueueHead {
-    limit: number;
-    queueModifiedAt: Date;
-    hadMultipleClients?: boolean;
-    items: RequestQueueHeadItem[];
-}
-export interface ListOptions {
-    /**
-     * @default 100
-     */
-    limit?: number;
-}
-export interface ListAndLockOptions extends ListOptions {
-    lockSecs: number;
-}
-export interface ListAndLockHeadResult extends QueueHead {
-    lockSecs: number;
-    queueHasLockedRequests?: boolean;
-}
-export interface ProlongRequestLockOptions {
-    lockSecs: number;
-    forefront?: boolean;
-}
-export interface ProlongRequestLockResult {
-    lockExpiresAt: Date;
-}
-export interface DeleteRequestLockOptions {
-    forefront?: boolean;
-}
-export interface RequestOptions {
+export interface RequestQueueOperationOptions {
+    /** Place the affected request(s) at the beginning of the queue so they are processed sooner. */
     forefront?: boolean;
-    [k: string]: unknown;
 }
 export interface RequestSchema {
     id?: string;
@@ -251,45 +229,195 @@ export interface BatchAddRequestsResult {
     processedRequests: ProcessedRequest[];
     unprocessedRequests: UnprocessedRequest[];
 }
-export interface RequestQueueClient {
-    get(): Promise<RequestQueueInfo | undefined>;
-    update(newFields: {
-        name?: string;
-    }): Promise<Partial<RequestQueueInfo> | undefined>;
-    delete(): Promise<void>;
-    listHead(options?: ListOptions): Promise<QueueHead>;
-    addRequest(request: RequestSchema, options?: RequestOptions): Promise<QueueOperationInfo>;
-    batchAddRequests(requests: RequestSchema[], options?: RequestOptions): Promise<BatchAddRequestsResult>;
-    getRequest(id: string): Promise<RequestOptions | undefined>;
-    updateRequest(request: UpdateRequestSchema, options?: RequestOptions): Promise<QueueOperationInfo>;
-    deleteRequest(id: string): Promise<unknown>;
-    listAndLockHead(options: ListAndLockOptions): Promise<ListAndLockHeadResult>;
-    prolongRequestLock(id: string, options: ProlongRequestLockOptions): Promise<ProlongRequestLockResult>;
-    deleteRequestLock(id: string, options?: DeleteRequestLockOptions): Promise<void>;
-}
-export interface RequestQueueOptions {
-    clientKey?: string;
-    timeoutSecs?: number;
-}
-export interface SetStatusMessageOptions {
-    isStatusMessageTerminal?: boolean;
-    level?: 'DEBUG' | 'INFO' | 'WARNING' | 'ERROR';
+/**
+ * Operations on a single request queue.
+ *
+ * A backend implementation owns all request bookkeeping (pending, in-progress, handled). Any
+ * coordination required between multiple distributed clients accessing the same queue (e.g. request
+ * locking on the Apify platform) is an internal concern of the implementation and is not exposed on
+ * this interface.
+ */
+export interface RequestQueueBackend {
+    /**
+     * Returns metadata about the request queue (id, name, timestamps, request counts, etc.).
+     *
+     * Implementations should throw if the underlying storage no longer exists
+     * (e.g. it was deleted externally). This method should never return stale data
+     * for a storage that has been removed.
+     */
+    getMetadata(): Promise<RequestQueueInfo>;
+    /** Remove the request queue and all its data. */
+    drop(): Promise<void>;
+    /** Remove all requests from the queue but keep the queue itself. */
+    purge(): Promise<void>;
+    /**
+     * Add a batch of requests to the queue.
+     *
+     * Each request is deduplicated by its `uniqueKey`. Duplicates are reported in the result
+     * but not re-added. With `forefront`, requests are placed at the beginning of the queue so
+     * they are processed sooner.
+     */
+    addBatchOfRequests(requests: RequestSchema[], options?: RequestQueueOperationOptions): Promise<BatchAddRequestsResult>;
+    /**
+     * Retrieve a request from the queue by its `uniqueKey`, or `undefined` if it does not exist.
+     */
+    getRequest(uniqueKey: string): Promise<UpdateRequestSchema | undefined>;
+    /**
+     * Return the next request in the queue to be processed, or `undefined` if there are currently no
+     * pending requests.
+     *
+     * The returned request is marked as in-progress; it will not be returned again until it is
+     * either reclaimed via {@link reclaimRequest} or marked as handled via {@link markRequestAsHandled}.
+     *
+     * An `undefined` return value does not mean processing is finished — only that there are no pending
+     * requests right now. Use {@link isEmpty} (together with the frontend's knowledge of pending
+     * add operations) to determine whether the queue is truly finished.
+     */
+    fetchNextRequest(): Promise<UpdateRequestSchema | undefined>;
+    /**
+     * Mark a request previously returned by {@link fetchNextRequest} as handled.
+     *
+     * Handled requests are never returned again by {@link fetchNextRequest}. Returns information
+     * about the operation, or `undefined` if the request was not in progress.
+     *
+     * An `undefined` result is a no-op, not an error: the request is simply not something this client is
+     * currently processing, so nothing is changed and the request is never added to the queue as a side
+     * effect. (Marking an already-handled request is idempotent and still returns operation info with
+     * `wasAlreadyHandled: true` rather than `undefined`.)
+     */
+    markRequestAsHandled(request: UpdateRequestSchema): Promise<QueueOperationInfo | undefined>;
+    /**
+     * Reclaim a failed request back to the queue so it can be processed again by a later call to
+     * {@link fetchNextRequest}. With `forefront`, the request is returned to the beginning of the
+     * queue. Returns information about the operation, or `undefined` if the request was not in progress.
+     *
+     * The request is expected to already be present in the queue (it should have been obtained via
+     * {@link fetchNextRequest}); reclaiming releases its lock rather than inserting it. An `undefined` result
+     * is a no-op, not an error: the request is simply not something this client is currently processing,
+     * so nothing is changed and the request is never added to the queue as a side effect. Use
+     * {@link addBatchOfRequests} to insert a new request.
+     */
+    reclaimRequest(request: UpdateRequestSchema, options?: RequestQueueOperationOptions): Promise<QueueOperationInfo | undefined>;
+    /**
+     * Resolves to `true` if the next call to {@link fetchNextRequest} would return `undefined` — i.e. there
+     * are no pending requests to fetch right now.
+     *
+     * Requests that are currently in progress (fetched but not yet handled or reclaimed, including
+     * requests locked by other clients sharing the same queue) are **not** counted. An empty queue
+     * therefore does not mean crawling is finished — those in-progress requests may still be reclaimed,
+     * and background tasks may still add more requests. Use {@link isFinished} to detect completion.
+     */
+    isEmpty(): Promise<boolean>;
+    /**
+     * Resolves to `true` only when there is no outstanding work left in the queue at all — i.e. there
+     * are no pending requests to fetch **and** no requests currently in progress (fetched but not yet
+     * handled or reclaimed, including requests locked by other clients sharing the same queue).
+     *
+     * This is the strong counterpart of {@link isEmpty}: a queue whose only remaining requests are in
+     * progress is empty (nothing to fetch) but not finished (that work might still be reclaimed). It is
+     * the building block for determining whether crawling is done — though a frontend may still need to
+     * account for its own pending background add operations on top of this.
+     */
+    isFinished(): Promise<boolean>;
+    /**
+     * Tells the client how long (in seconds) a consumer expects to hold a request fetched via
+     * {@link fetchNextRequest} before marking it handled or reclaiming it — typically the consumer's
+     * request-processing timeout plus some padding.
+     *
+     * A client that coordinates consumers via locking uses this to keep the request reserved for at least
+     * this long, so that a long-running consumer does not have its request handed out again while it is
+     * still being processed. Clients that do not lock may ignore it.
+     */
+    setExpectedRequestProcessingTimeSecs?(secs: number): Promise<void>;
 }
 /**
- * Represents a storage capable of working with datasets, KV stores and request queues.
+ * Identifies a storage by its ID, name, or alias. At most one may be provided.
+ *
+ * - `{ id }` — open a pre-existing storage by its unique ID.
+ * - `{ name }` — open or create a globally named storage (persists across runs). The name `default`
+ *   is reserved: it resolves to the default storage, and is emptied on start along with it.
+ * - `{ alias }` — open or create a run-scoped unnamed storage identified by this alias.
+ *   The alias is used locally (e.g. as a directory name or cache key) but the storage
+ *   itself has no persistent name. Use this for non-default unnamed storages. Like the
+ *   default storage, an aliased one is emptied on start unless `purgeOnStart` is disabled.
+ * - `{}` / omitted — open the default storage.
+ */
+export type StorageIdentifier = {
+    id: string;
+    name?: never;
+    alias?: never;
+} | {
+    id?: never;
+    name: string;
+    alias?: never;
+} | {
+    id?: never;
+    name?: never;
+    alias: string;
+} | {
+    id?: never;
+    name?: never;
+    alias?: never;
+};
+/**
+ * Represents a storage backend capable of working with datasets, key-value stores and request queues.
+ *
+ * A new storage backend needs to implement 4 classes:
+ * - `StorageBackend` - the factory that creates sub-backends
+ * - `DatasetBackend` - operations on a single dataset
+ * - `KeyValueStoreBackend` - operations on a single key-value store
+ * - `RequestQueueBackend` - operations on a single request queue
+ *
+ * The `StorageBackend` acts as an async factory: each `create*` method either opens an existing
+ * storage or creates a new one, returning a sub-backend bound to that storage instance.
  */
-export interface StorageClient {
-    datasets(): DatasetCollectionClient;
-    dataset(id: string): DatasetClient;
-    keyValueStores(): KeyValueStoreCollectionClient;
-    keyValueStore(id: string): KeyValueStoreClient;
-    requestQueues(): RequestQueueCollectionClient;
-    requestQueue(id: string, options?: RequestQueueOptions): RequestQueueClient;
+export interface StorageBackend {
+    /**
+     * Create (or open) a dataset backend.
+     * If `id` is provided, opens the dataset with that ID.
+     * If `name` is provided, opens an existing dataset with that name or creates a new one.
+     * If neither is provided, opens or creates the default dataset.
+     */
+    createDatasetBackend(options?: StorageIdentifier): Promise<DatasetBackend>;
+    /**
+     * Create (or open) a key-value store backend.
+     * If `id` is provided, opens the key-value store with that ID.
+     * If `name` is provided, opens an existing store with that name or creates a new one.
+     * If neither is provided, opens or creates the default key-value store.
+     */
+    createKeyValueStoreBackend(options?: StorageIdentifier): Promise<KeyValueStoreBackend>;
+    /**
+     * Create (or open) a request queue backend.
+     * If `id` is provided, opens the request queue with that ID.
+     * If `name` is provided, opens an existing queue with that name or creates a new one.
+     * If neither is provided, opens or creates the default request queue.
+     */
+    createRequestQueueBackend(options?: StorageIdentifier): Promise<RequestQueueBackend>;
+    /**
+     * Check whether a storage with the given ID exists.
+     *
+     * Used internally to resolve ambiguous `idOrName` strings passed to `Dataset.open()`,
+     * `KeyValueStore.open()`, and `RequestQueue.open()`.
+     */
+    storageExists?(id: string, type: 'Dataset' | 'KeyValueStore' | 'RequestQueue'): Promise<boolean>;
+    /**
+     * Return an opaque key that uniquely identifies this storage backend instance.
+     *
+     * The key is used by `StorageInstanceManager` to partition the storage cache per-backend,
+     * so that two storages with the same name but backed by different clients
+     * (e.g. a local `MemoryStorageBackend` and a cloud `ApifyClient`) are cached as separate instances.
+     *
+     * When not provided, the fallback uses the client's constructor name, so different
+     * `StorageBackend` implementations automatically get separate cache partitions.
+     */
+    getStorageBackendCacheKey?(): string;
+    /**
+     * Empty the run-scoped storages — the default one and every alias-keyed one, including any left
+     * behind by a previous run. Named storages persist across runs, as does the default store's `INPUT`.
+     */
     purge?(): Promise<void>;
     teardown?(): Promise<void>;
-    setStatusMessage?(message: string, options?: SetStatusMessageOptions): Promise<void>;
     stats?: {
         rateLimitErrors: number[];
     };
 }
-//# sourceMappingURL=storages.d.ts.map

package/storages.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=storages.js.map

package/utility-types.d.ts

@@ -1,8 +1,6 @@
-/** @ignore */
 export type Dictionary<T = any> = Record<PropertyKey, T>;
 /** @ignore */
 export type Constructor<T = unknown> = new (...args: any[]) => T;
 /** @ignore */
 export type Awaitable<T> = T | PromiseLike<T>;
 export type AllowedHttpMethods = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'TRACE' | 'OPTIONS' | 'CONNECT' | 'PATCH' | 'get' | 'head' | 'post' | 'put' | 'delete' | 'trace' | 'options' | 'connect' | 'patch';
-//# sourceMappingURL=utility-types.d.ts.map

package/utility-types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=utility-types.js.map

package/browser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,MAAM,WAAW,MAAM;IACnB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;OAEG;IACH,QAAQ,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;IACrC;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,QAAQ,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACrC;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;OAEG;IACH,YAAY,CAAC,EAAE,OAAO,GAAG,WAAW,GAAG,QAAQ,CAAC;IAChD;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,mBAAmB;IAChC,GAAG,IAAI,MAAM,CAAC;IACd,OAAO,IAAI,UAAU,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;CAC5C"}

package/browser.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"browser.js","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":""}

package/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC"}

package/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC"}

package/storages.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"storages.d.ts","sourceRoot":"","sources":["../src/storages.ts"],"names":[],"mappings":"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"}

package/storages.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"storages.js","sourceRoot":"","sources":["../src/storages.ts"],"names":[],"mappings":""}

package/utility-types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utility-types.d.ts","sourceRoot":"","sources":["../src/utility-types.ts"],"names":[],"mappings":"AAAA,cAAc;AACd,MAAM,MAAM,UAAU,CAAC,CAAC,GAAG,GAAG,IAAI,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;AAEzD,cAAc;AACd,MAAM,MAAM,WAAW,CAAC,CAAC,GAAG,OAAO,IAAI,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AAEjE,cAAc;AACd,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;AAE9C,MAAM,MAAM,kBAAkB,GACxB,KAAK,GACL,MAAM,GACN,MAAM,GACN,KAAK,GACL,QAAQ,GACR,OAAO,GACP,SAAS,GACT,SAAS,GACT,OAAO,GACP,KAAK,GACL,MAAM,GACN,MAAM,GACN,KAAK,GACL,QAAQ,GACR,OAAO,GACP,SAAS,GACT,SAAS,GACT,OAAO,CAAC"}

package/utility-types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utility-types.js","sourceRoot":"","sources":["../src/utility-types.ts"],"names":[],"mappings":""}