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

package/session_pool/fingerprint.js

@@ -1,30 +0,0 @@
-/**
- * (browser, platform, device) combinations that correspond to setups people
- * actually run. Anything not listed here (e.g. `edge` on android, `safari` on
- * windows, `desktop` mobile platforms) is left out so a randomized default
- * never produces a fingerprint that would itself be a giveaway.
- */
-const PROFILES_BY_PLATFORM = [
-    { browser: 'chrome', platform: 'windows', device: 'desktop' },
-    { browser: 'firefox', platform: 'windows', device: 'desktop' },
-    { browser: 'edge', platform: 'windows', device: 'desktop' },
-    { browser: 'chrome', platform: 'macos', device: 'desktop' },
-    { browser: 'firefox', platform: 'macos', device: 'desktop' },
-    { browser: 'safari', platform: 'macos', device: 'desktop' },
-    { browser: 'edge', platform: 'macos', device: 'desktop' },
-    { browser: 'chrome', platform: 'linux', device: 'desktop' },
-    { browser: 'firefox', platform: 'linux', device: 'desktop' },
-    { browser: 'chrome', platform: 'android', device: 'mobile' },
-    { browser: 'firefox', platform: 'android', device: 'mobile' },
-    { browser: 'safari', platform: 'ios', device: 'mobile' },
-];
-/**
- * Build a {@link SessionFingerprint} whose `platform` matches the host OS
- * and whose `browser`/`device` are randomized within the realistic profiles for
- * that platform. Used by {@link SessionPool} as the default fingerprint for
- * freshly created sessions; callers can override by passing their own
- * `fingerprint` in `sessionOptions`.
- */
-export function createDefaultSessionFingerprint() {
-    return { ...PROFILES_BY_PLATFORM[Math.floor(Math.random() * PROFILES_BY_PLATFORM.length)] };
-}

package/session_pool/index.d.ts

@@ -1,4 +0,0 @@
-export * from './errors.js';
-export * from './session.js';
-export * from './session_pool.js';
-export * from './consts.js';

package/session_pool/index.js

@@ -1,4 +0,0 @@
-export * from './errors.js';
-export * from './session.js';
-export * from './session_pool.js';
-export * from './consts.js';

package/session_pool/session.d.ts

@@ -1,161 +0,0 @@
-import type { Dictionary, ISession, ProxyInfo, SessionFingerprint, SessionState } from '@crawlee/types';
-import { CookieJar } from 'tough-cookie';
-import type { CrawleeLogger } from '../log.js';
-export interface SessionOptions {
-    /** Id of session used for generating fingerprints. It is used as proxy session name. */
-    id?: string;
-    /**
-     * Number of seconds after which the session is considered as expired.
-     * @default 3000
-     */
-    maxAgeSecs?: number;
-    /** Object where custom user data can be stored. For example custom headers. */
-    userData?: Dictionary;
-    /**
-     * Maximum number of marking session as blocked usage.
-     * If the `errorScore` reaches the `maxErrorScore` session is marked as block and it is thrown away.
-     * It starts at 0. Calling the `markBad` function increases the `errorScore` by 1.
-     * Calling the `markGood` will decrease the `errorScore` by `errorScoreDecrement`
-     * @default 3
-     */
-    maxErrorScore?: number;
-    /**
-     * It is used for healing the session.
-     * For example: if your session is marked bad two times, but it is successful on the third attempt it's errorScore
-     * is decremented by this number.
-     * @default 0.5
-     */
-    errorScoreDecrement?: number;
-    /** Date of creation. */
-    createdAt?: Date;
-    /** Date of expiration. */
-    expiresAt?: Date;
-    /**
-     * Indicates how many times the session has been used.
-     * @default 0
-     */
-    usageCount?: number;
-    /**
-     * Session should be used only a limited amount of times.
-     * This number indicates how many times the session is going to be used, before it is thrown away.
-     * @default 50
-     */
-    maxUsageCount?: number;
-    /**
-     * Marks the session as already retired. Used when restoring a previously persisted session
-     * so that `isUsable()` reflects the terminal state regardless of error score or usage count.
-     * @default false
-     */
-    retired?: boolean;
-    log?: CrawleeLogger;
-    errorScore?: number;
-    cookieJar?: CookieJar;
-    proxyInfo?: ProxyInfo;
-    /**
-     * Browser / HTTP client fingerprint tied to this session. Backends use this to make
-     * repeated requests with the same session look consistent (same user-agent, headers,
-     * TLS profile). See {@link SessionFingerprint}.
-     */
-    fingerprint?: SessionFingerprint;
-}
-/**
- * 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 declare class Session implements ISession {
-    readonly id: string;
-    readonly userData: Dictionary;
-    private _maxErrorScore;
-    private _errorScoreDecrement;
-    private _createdAt;
-    private _expiresAt;
-    private _usageCount;
-    private _maxUsageCount;
-    private _errorScore;
-    private _retired;
-    private _proxyInfo?;
-    private _cookieJar;
-    private _fingerprint?;
-    private log;
-    get errorScore(): number;
-    get usageCount(): number;
-    get maxErrorScore(): number;
-    get errorScoreDecrement(): number;
-    get expiresAt(): Date;
-    get createdAt(): Date;
-    get maxUsageCount(): number;
-    get cookieJar(): CookieJar;
-    get proxyInfo(): ProxyInfo | undefined;
-    get fingerprint(): SessionFingerprint | undefined;
-    set fingerprint(fingerprint: SessionFingerprint | undefined);
-    /**
-     * `true` once {@link Session.retire|`retire()`} has been called. Retirement is terminal:
-     * a retired session is never picked by the pool and cannot be revived via `markGood()`.
-     */
-    get retired(): boolean;
-    /**
-     * Session configuration.
-     */
-    constructor(options?: SessionOptions);
-    /**
-     * Indicates whether the session is blocked.
-     * Session is blocked once it reaches the `maxErrorScore`.
-     */
-    isBlocked(): boolean;
-    /**
-     * Indicates whether the session is expired.
-     * Session expiration is determined by the `maxAgeSecs`.
-     * Once the session is older than `createdAt + maxAgeSecs` the session is considered expired.
-     */
-    isExpired(): boolean;
-    /**
-     * Indicates whether the session is used maximum number of times.
-     * Session maximum usage count can be changed by `maxUsageCount` parameter.
-     */
-    isMaxUsageCountReached(): boolean;
-    /**
-     * Indicates whether the session can be used for next requests.
-     * Session is usable when it is not retired, not expired, not blocked and the maximum usage count has not be reached.
-     */
-    isUsable(): boolean;
-    /**
-     * This method should be called after a successful session usage.
-     * It increases `usageCount` and potentially lowers the `errorScore` by the `errorScoreDecrement`.
-     */
-    markGood(): void;
-    /**
-     * Gets session state for persistence in KeyValueStore.
-     * @returns Represents session internal state.
-     */
-    getState(): SessionState;
-    /**
-     * Permanently retires the session — `isUsable()` will return `false` from here on,
-     * and no `markGood()` / `markBad()` can revive it. Calling `retire()` again is a no-op.
-     *
-     * Use this when you're confident the session itself is the problem (e.g. a `403` response).
-     * For transient external failures (such as `5XX` responses), use `markBad()` instead.
-     */
-    retire(): void;
-    /**
-     * Increases usage and error count.
-     * Should be used when the session has been used unsuccessfully. For example because of timeouts.
-     */
-    markBad(): void;
-    /**
-     * Returns cookies saved with the session in the typical
-     * key1=value1; key2=value2 format, ready to be used in
-     * a cookie header or elsewhere.
-     * @returns Represents `Cookie` header.
-     */
-    getCookieString(url: string): string;
-    /**
-     * Sets a cookie within this session for the specific URL.
-     */
-    setCookie(rawCookie: string, url: string): void;
-    /**
-     * Checks if session is not usable. if it is not retires the session.
-     */
-    private maybeSelfRetire;
-}

package/session_pool/session.js

@@ -1,218 +0,0 @@
-import ow from 'ow';
-import { CookieJar } from 'tough-cookie';
-import { cryptoRandomObjectId } from '@apify/utilities';
-import { getDefaultCookieExpirationDate } from '../cookie_utils.js';
-import { serviceLocator } from '../service_locator.js';
-/**
- * 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 class Session {
-    id;
-    userData;
-    _maxErrorScore;
-    _errorScoreDecrement;
-    _createdAt;
-    _expiresAt;
-    _usageCount;
-    _maxUsageCount;
-    _errorScore;
-    _retired = false;
-    _proxyInfo;
-    _cookieJar;
-    _fingerprint;
-    log;
-    get errorScore() {
-        return this._errorScore;
-    }
-    get usageCount() {
-        return this._usageCount;
-    }
-    get maxErrorScore() {
-        return this._maxErrorScore;
-    }
-    get errorScoreDecrement() {
-        return this._errorScoreDecrement;
-    }
-    get expiresAt() {
-        return this._expiresAt;
-    }
-    get createdAt() {
-        return this._createdAt;
-    }
-    get maxUsageCount() {
-        return this._maxUsageCount;
-    }
-    get cookieJar() {
-        return this._cookieJar;
-    }
-    get proxyInfo() {
-        return this._proxyInfo;
-    }
-    get fingerprint() {
-        return this._fingerprint;
-    }
-    set fingerprint(fingerprint) {
-        this._fingerprint = fingerprint;
-    }
-    /**
-     * `true` once {@link Session.retire|`retire()`} has been called. Retirement is terminal:
-     * a retired session is never picked by the pool and cannot be revived via `markGood()`.
-     */
-    get retired() {
-        return this._retired;
-    }
-    /**
-     * Session configuration.
-     */
-    constructor(options = {}) {
-        ow(options, ow.object.exactShape({
-            id: ow.optional.string,
-            cookieJar: ow.optional.object,
-            proxyInfo: ow.optional.object,
-            maxAgeSecs: ow.optional.number,
-            userData: ow.optional.object,
-            maxErrorScore: ow.optional.number,
-            errorScoreDecrement: ow.optional.number,
-            createdAt: ow.optional.date,
-            expiresAt: ow.optional.date,
-            usageCount: ow.optional.number,
-            errorScore: ow.optional.number,
-            maxUsageCount: ow.optional.number,
-            retired: ow.optional.boolean,
-            log: ow.optional.object,
-            fingerprint: ow.optional.object,
-        }));
-        const { id = `session_${cryptoRandomObjectId(10)}`, cookieJar = new CookieJar(), proxyInfo = undefined, maxAgeSecs = 3000, userData = {}, maxErrorScore = 3, errorScoreDecrement = 0.5, createdAt = new Date(), usageCount = 0, errorScore = 0, maxUsageCount = 50, retired = false, log = serviceLocator.getLogger(), fingerprint, } = options;
-        const { expiresAt = getDefaultCookieExpirationDate(maxAgeSecs) } = options;
-        this.log = log.child({ prefix: 'Session' });
-        this._cookieJar = cookieJar.setCookie ? cookieJar : CookieJar.fromJSON(JSON.stringify(cookieJar));
-        this._proxyInfo = proxyInfo;
-        this._fingerprint = fingerprint;
-        this.id = id;
-        this.userData = userData;
-        this._maxErrorScore = maxErrorScore;
-        this._errorScoreDecrement = errorScoreDecrement;
-        // Internal
-        this._expiresAt = expiresAt;
-        this._createdAt = createdAt;
-        this._usageCount = usageCount; // indicates how many times the session has been used
-        this._errorScore = errorScore; // indicates number of markBaded request with the session
-        this._maxUsageCount = maxUsageCount;
-        this._retired = retired;
-    }
-    /**
-     * Indicates whether the session is blocked.
-     * Session is blocked once it reaches the `maxErrorScore`.
-     */
-    isBlocked() {
-        return this.errorScore >= this.maxErrorScore;
-    }
-    /**
-     * Indicates whether the session is expired.
-     * Session expiration is determined by the `maxAgeSecs`.
-     * Once the session is older than `createdAt + maxAgeSecs` the session is considered expired.
-     */
-    isExpired() {
-        return this.expiresAt <= new Date();
-    }
-    /**
-     * Indicates whether the session is used maximum number of times.
-     * Session maximum usage count can be changed by `maxUsageCount` parameter.
-     */
-    isMaxUsageCountReached() {
-        return this.usageCount >= this.maxUsageCount;
-    }
-    /**
-     * Indicates whether the session can be used for next requests.
-     * Session is usable when it is not retired, not expired, not blocked and the maximum usage count has not be reached.
-     */
-    isUsable() {
-        return !this._retired && !this.isBlocked() && !this.isExpired() && !this.isMaxUsageCountReached();
-    }
-    /**
-     * This method should be called after a successful session usage.
-     * It increases `usageCount` and potentially lowers the `errorScore` by the `errorScoreDecrement`.
-     */
-    markGood() {
-        this._usageCount += 1;
-        if (this._errorScore > 0) {
-            this._errorScore -= this._errorScoreDecrement;
-        }
-        this.maybeSelfRetire();
-    }
-    /**
-     * Gets session state for persistence in KeyValueStore.
-     * @returns Represents session internal state.
-     */
-    getState() {
-        return {
-            id: this.id,
-            cookieJar: this.cookieJar.toJSON(),
-            proxyInfo: this._proxyInfo,
-            userData: this.userData,
-            fingerprint: this._fingerprint,
-            maxErrorScore: this.maxErrorScore,
-            errorScoreDecrement: this.errorScoreDecrement,
-            expiresAt: this.expiresAt.toISOString(),
-            createdAt: this.createdAt.toISOString(),
-            usageCount: this.usageCount,
-            maxUsageCount: this.maxUsageCount,
-            errorScore: this.errorScore,
-            retired: this._retired,
-        };
-    }
-    /**
-     * Permanently retires the session — `isUsable()` will return `false` from here on,
-     * and no `markGood()` / `markBad()` can revive it. Calling `retire()` again is a no-op.
-     *
-     * Use this when you're confident the session itself is the problem (e.g. a `403` response).
-     * For transient external failures (such as `5XX` responses), use `markBad()` instead.
-     */
-    retire() {
-        if (this._retired)
-            return;
-        this._errorScore += this._maxErrorScore;
-        this._usageCount += 1;
-        this._retired = true;
-    }
-    /**
-     * Increases usage and error count.
-     * Should be used when the session has been used unsuccessfully. For example because of timeouts.
-     */
-    markBad() {
-        this._errorScore += 1;
-        this._usageCount += 1;
-        this.maybeSelfRetire();
-    }
-    /**
-     * Returns cookies saved with the session in the typical
-     * key1=value1; key2=value2 format, ready to be used in
-     * a cookie header or elsewhere.
-     * @returns Represents `Cookie` header.
-     */
-    getCookieString(url) {
-        return this.cookieJar.getCookieStringSync(url, {});
-    }
-    /**
-     * Sets a cookie within this session for the specific URL.
-     */
-    setCookie(rawCookie, url) {
-        try {
-            this.cookieJar.setCookieSync(rawCookie, url);
-        }
-        catch (e) {
-            this.log.warning('Could not set cookie.', { url, error: e.message });
-        }
-    }
-    /**
-     * Checks if session is not usable. if it is not retires the session.
-     */
-    maybeSelfRetire() {
-        if (!this.isUsable()) {
-            this.retire();
-        }
-    }
-}

package/session_pool/session_pool.d.ts

@@ -1,246 +0,0 @@
-import type { ISessionPool } from '@crawlee/types';
-import type { PersistenceOptions } from '../crawlers/statistics.js';
-import type { CrawleeLogger } from '../log.js';
-import type { SessionOptions } from './session.js';
-import { Session } from './session.js';
-declare const SESSION_REUSE_STRATEGIES: readonly ["random", "round-robin", "use-until-failure"];
-export type SessionReuseStrategy = (typeof SESSION_REUSE_STRATEGIES)[number];
-/**
- * Factory user-function which creates customized {@link Session} instances.
- */
-export interface CreateSession {
-    /**
-     * @param options.sessionOptions Per-call session options already merged with the pool-wide defaults.
-     */
-    (options?: {
-        sessionOptions?: SessionOptions;
-    }): Session | Promise<Session>;
-}
-export interface SessionPoolOptions {
-    /**
-     * Unique identifier for this session pool instance. Used to generate a unique
-     * persistence key when `persistStateKey` is not provided.
-     * If not provided, an auto-incrementing ID is used.
-     */
-    id?: string | number;
-    /**
-     * Maximum size of the pool. Indicates how many sessions are rotated.
-     * @default 1000
-     */
-    maxPoolSize?: number;
-    /** The configuration options for {@link Session} instances. */
-    sessionOptions?: SessionOptions;
-    /** Name or Id of `KeyValueStore` where is the `SessionPool` state stored. */
-    persistStateKeyValueStoreId?: string;
-    /**
-     * Session pool persists its state under this key in Key value store.
-     * @default CRAWLEE_SESSION_POOL_STATE_{id}
-     */
-    persistStateKey?: string;
-    /**
-     * Custom function that should return a `Session` instance, or a promise resolving to such instance.
-     * Any error thrown from this function will terminate the process. Receives `{ sessionOptions }`
-     * already merged from the pool-wide defaults and the per-call overrides.
-     */
-    createSessionFunction?: CreateSession;
-    /**
-     * Strategy for picking sessions from the pool.
-     * - `'random'` (default): fills the pool up to `maxPoolSize`, then picks a random usable session
-     * - `'round-robin'`: fills the pool up to `maxPoolSize`, then reuses sessions cycling through them in order
-     * - `'use-until-failure'`: always reuses the same session until it is retired, then moves to the next one
-     * @default 'random'
-     */
-    sessionReuseStrategy?: SessionReuseStrategy;
-    /** @internal */
-    log?: CrawleeLogger;
-    /**
-     * Control how and when to persist the state of the session pool.
-     */
-    persistenceOptions?: PersistenceOptions;
-}
-/**
- * Handles the rotation, creation and persistence of user-like sessions.
- * Creates a pool of {@link Session} instances, that are randomly rotated.
- * When some session is marked as blocked, it is removed and new one is created instead (the pool never returns an unusable session).
- * Learn more in the {@doclink guides/session-management | Session management guide}.
- *
- * Session pool is already integrated into crawlers and is always active.
- * All public methods are lazy-initialized — the pool initializes itself on first use.
- *
- * You can configure the pool with many options. See the {@link SessionPoolOptions}.
- * Session pool is by default persisted in default {@link KeyValueStore}.
- * If you want to have one pool for all runs you have to specify
- * {@link SessionPoolOptions.persistStateKeyValueStoreId}.
- *
- * **Advanced usage:**
- *
- * ```javascript
- * const sessionPool = new SessionPool({
- *     maxPoolSize: 25,
- *     sessionOptions:{
- *          maxAgeSecs: 10,
- *          maxUsageCount: 150, // for example when you know that the site blocks after 150 requests.
- *     },
- *     persistStateKeyValueStoreId: 'my-key-value-store-for-sessions',
- *     persistStateKey: 'my-session-pool',
- * });
- *
- * // Get random session from the pool
- * const session1 = await sessionPool.getSession();
- * const session2 = await sessionPool.getSession();
- * const session3 = await sessionPool.getSession();
- *
- * // Now you can mark the session either failed or successful
- *
- * // Marks session as bad after unsuccessful usage -> it increases error count (soft retire)
- * session1.markBad()
- *
- * // Marks as successful.
- * session2.markGood()
- *
- * // Retires session -> session is removed from the pool
- * session3.retire()
- *
- * ```
- *
- * **Default session allocation flow:*
- * 1. Until the `SessionPool` reaches `maxPoolSize`, new sessions are created, provided to the user and added to the pool
- * 2. Blocked/retired sessions stay in the pool but are never provided to the user
- * 3. Once the pool is full (live plus blocked session count reaches `maxPoolSize`), a random session from the pool is provided.
- * 4. If a blocked session would be picked, instead all blocked sessions are evicted from the pool and a new session is created and provided
- *
- * @category Scaling
- */
-export declare class SessionPool implements ISessionPool {
-    private static nextId;
-    readonly id: string;
-    private log;
-    private maxPoolSize;
-    private createSessionFunction;
-    private keyValueStore?;
-    private sessions;
-    private sessionMap;
-    private sessionOptions;
-    private persistStateKeyValueStoreId?;
-    private persistStateKey;
-    private listener?;
-    private events;
-    private persistenceOptions;
-    private sessionReuseStrategy;
-    private initPromise?;
-    private queue;
-    private roundRobinIndex;
-    constructor(options?: SessionPoolOptions);
-    /**
-     * Gets count of usable sessions in the pool.
-     */
-    usableSessionsCount(): Promise<number>;
-    /**
-     * Gets count of retired sessions in the pool.
-     */
-    retiredSessionsCount(): Promise<number>;
-    /**
-     * Starts periodic state persistence and potentially loads SessionPool state from {@link KeyValueStore}.
-     * Called automatically on first use of any public method.
-     */
-    private ensureInitialized;
-    private setupPool;
-    /**
-     * Adds a new session to the session pool. The pool automatically creates sessions up to the maximum size of the pool,
-     * but this allows you to add more sessions once the max pool size is reached.
-     * This also allows you to add session with overridden session options (e.g. with specific session id).
-     * @param [options] The configuration options for the session being added to the session pool.
-     */
-    addSession(options?: Session | SessionOptions): Promise<void>;
-    /**
-     * Adds a new session to the session pool. The pool automatically creates sessions up to the maximum size of the pool,
-     * but this allows you to add more sessions once the max pool size is reached.
-     * This also allows you to add session with overridden session options (e.g. with specific session id).
-     * @param [options] The configuration options for the session being added to the session pool.
-     */
-    newSession(sessionOptions?: SessionOptions): Promise<Session>;
-    /**
-     * Gets session.
-     * If there is space for new session, it creates and returns new session.
-     * If the session pool is full, it picks a session from the pool,
-     * If the picked session is usable it is returned, otherwise it creates and returns a new one.
-     * @param [sessionId] If provided, it returns the usable session with this id, `undefined` otherwise.
-     */
-    getSession(sessionId?: string): Promise<Session | undefined>;
-    /**
-     * @param options - Override the persistence options provided in the constructor
-     */
-    resetStore(options?: PersistenceOptions): Promise<void>;
-    /**
-     * Returns an object representing the internal state of the `SessionPool` instance.
-     * Note that the object's fields can change in future releases.
-     */
-    getState(): Promise<{
-        usableSessionsCount: number;
-        retiredSessionsCount: number;
-// @ts-ignore optional peer dependency or compatibility with es2022
-        sessions: import("@crawlee/types").SessionState[];
-    }>;
-    /**
-     * Persists the current state of the `SessionPool` into the default {@link KeyValueStore}.
-     * The state is persisted automatically in regular intervals.
-     * @param options - Override the persistence options provided in the constructor
-     */
-    persistState(options?: PersistenceOptions): Promise<void>;
-    /**
-     * Removes listener from `persistState` event.
-     * This function should be called after you are done with using the `SessionPool` instance.
-     */
-    teardown(): Promise<void>;
-    /**
-     * Removes retired `Session` instances from `SessionPool`.
-     */
-    private removeRetiredSessions;
-    /**
-     * Adds `Session` instance to `SessionPool`.
-     * @param newSession `Session` instance to be added.
-     */
-    private registerSession;
-    /**
-     * Gets random index.
-     */
-    private getRandomIndex;
-    /**
-     * Creates new session without any extra behavior.
-     * @param [options]
-     * @param [options.sessionOptions] The configuration options for the session being created.
-     * @returns New session.
-     */
-    private defaultCreateSessionFunction;
-    /**
-     * Invokes `createSessionFunction` with `sessionOptions` already merged from pool-wide defaults and
-     * the supplied per-call overrides, so custom implementations don't need to spread `pool.sessionOptions` themselves.
-     *
-     * A default {@link SessionFingerprint} is generated up front (host OS as
-     * `platform`, a random valid `browser`/`device` for that platform). Pool-wide
-     * and per-call options override it, and a persisted fingerprint coming
-     * through `maybeLoadSessionPool` naturally wins because it arrives in
-     * `perCallOptions`.
-     */
-    private _invokeCreateSessionFunction;
-    /**
-     * Creates new session and adds it to the pool.
-     * @returns Newly created `Session` instance.
-     */
-    private createSession;
-    /**
-     * Decides whether there is enough space for creating new session.
-     */
-    private hasSpaceForSession;
-    /**
-     * Picks a session from the `SessionPool` according to the configured `sessionReuseStrategy`.
-     * Returns `undefined` when no session should be reused and a new one should be created instead.
-     */
-    private pickSession;
-    /**
-     * Potentially loads `SessionPool`.
-     * If the state was persisted it loads the `SessionPool` from the persisted state.
-     */
-    private maybeLoadSessionPool;
-}
-export {};