@browserless.io/browserless 2.12.0-beta-3 → 2.12.0-beta-6

package/build/browserless.d.ts

@@ -36,9 +36,9 @@ export declare class Browserless extends EventEmitter {
         token?: Browserless['token'];
         webhooks?: Browserless['webhooks'];
     });
-    protected loadPwVersions: () => Promise<void>;
-    protected saveMetrics: () => Promise<void>;
-    setMetricsSaveInterval: (interval: number) => void;
+    protected loadPwVersions(): Promise<void>;
+    protected saveMetrics(): Promise<void>;
+    setMetricsSaveInterval(interval: number): void;
     protected routeIsDisabled(route: routeInstances): boolean;
     setStaticSDKDir(dir: string): void;
     disableRoutes(...routeNames: string[]): void;

package/build/browserless.js

@@ -45,11 +45,11 @@ export class Browserless extends EventEmitter {
             router ||
                 new Router(this.config, this.browserManager, this.limiter, this.Logger);
     }
-    loadPwVersions = async () => {
+    async loadPwVersions() {
         const { playwrightVersions } = JSON.parse((await fs.readFile('package.json')).toString());
         this.config.setPwVersions(playwrightVersions);
-    };
-    saveMetrics = async () => {
+    }
+    async saveMetrics() {
         const metricsPath = this.config.getMetricsJSONPath();
         const { cpu, memory } = await this.monitoring.getMachineStats();
         const metrics = await this.metrics.get();
@@ -76,15 +76,15 @@ export class Browserless extends EventEmitter {
             this.logger.info(`Saving metrics to "${metricsPath}"`);
             this.fileSystem.append(metricsPath, JSON.stringify(aggregatedStats), false);
         }
-    };
-    setMetricsSaveInterval = (interval) => {
+    }
+    setMetricsSaveInterval(interval) {
         if (interval <= 0) {
             return console.warn(`Interval value of "${interval}" must be greater than 1. Ignoring`);
         }
         clearInterval(this.metricsSaveInterval);
         this.metricsSaveInterval = interval;
         this.metricsSaveIntervalID = setInterval(this.saveMetrics, this.metricsSaveInterval);
-    };
+    }
     routeIsDisabled(route) {
         return this.disabledRouteNames.some((name) => name === route.name);
     }

package/build/browsers/chromium.cdp.d.ts

@@ -26,17 +26,17 @@ export declare class ChromiumCDP extends EventEmitter {
         userDataDir: ChromiumCDP['userDataDir'];
     });
     protected cleanListeners(): void;
-    keepAlive(): boolean;
-    getPageId: (page: Page) => string;
-    protected onTargetCreated: (target: Target) => Promise<void>;
-    isRunning: () => boolean;
-    newPage: () => Promise<Page>;
-    close: () => Promise<void>;
-    pages: () => Promise<Page[]>;
-    process: () => import("child_process").ChildProcess | null;
-    launch: (options?: CDPLaunchOptions) => Promise<Browser>;
-    wsEndpoint: () => string | null;
-    publicWSEndpoint: (token: string | null) => string | null;
-    proxyPageWebSocket: (req: Request, socket: Duplex, head: Buffer) => Promise<void>;
-    proxyWebSocket: (req: Request, socket: Duplex, head: Buffer) => Promise<void>;
+    keepUntil(): number;
+    getPageId(page: Page): string;
+    protected onTargetCreated(target: Target): Promise<void>;
+    isRunning(): boolean;
+    newPage(): Promise<Page>;
+    close(): Promise<void>;
+    pages(): Promise<Page[]>;
+    process(): import("child_process").ChildProcess | null;
+    launch(options?: CDPLaunchOptions): Promise<Browser>;
+    wsEndpoint(): string | null;
+    publicWSEndpoint(token: string | null): string | null;
+    proxyPageWebSocket(req: Request, socket: Duplex, head: Buffer): Promise<void>;
+    proxyWebSocket(req: Request, socket: Duplex, head: Buffer): Promise<void>;
 }

package/build/browsers/chromium.cdp.js

@@ -32,14 +32,14 @@ export class ChromiumCDP extends EventEmitter {
         this.browser?.removeAllListeners();
         this.removeAllListeners();
     }
-    keepAlive() {
-        return false;
+    keepUntil() {
+        return 0;
     }
-    getPageId = (page) => {
+    getPageId(page) {
         // @ts-ignore
         return page.target()._targetId;
-    };
-    onTargetCreated = async (target) => {
+    }
+    async onTargetCreated(target) {
         if (target.type() === 'page') {
             const page = await target.page().catch((e) => {
                 this.logger.error(`Error in ${this.constructor.name} new page ${e}`);
@@ -83,15 +83,17 @@ export class ChromiumCDP extends EventEmitter {
                 this.emit('newPage', page);
             }
         }
-    };
-    isRunning = () => this.running;
-    newPage = async () => {
+    }
+    isRunning() {
+        return this.running;
+    }
+    async newPage() {
         if (!this.browser) {
             throw new ServerError(`${this.constructor.name} hasn't been launched yet!`);
         }
         return this.browser.newPage();
-    };
-    close = async () => {
+    }
+    async close() {
         if (this.browser) {
             this.logger.info(`Closing ${this.constructor.name} process and all listeners`);
             this.emit('close');
@@ -102,10 +104,14 @@ export class ChromiumCDP extends EventEmitter {
             this.browser = null;
             this.browserWSEndpoint = null;
         }
-    };
-    pages = async () => this.browser?.pages() || [];
-    process = () => this.browser?.process() || null;
-    launch = async (options = {}) => {
+    }
+    async pages() {
+        return this.browser?.pages() || [];
+    }
+    process() {
+        return this.browser?.process() || null;
+    }
+    async launch(options = {}) {
         this.port = await getPort();
         this.logger.info(`${this.constructor.name} got open port ${this.port}`);
         const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -130,14 +136,16 @@ export class ChromiumCDP extends EventEmitter {
             : puppeteer.launch.bind(puppeteer);
         this.logger.info(finalOptions, `Launching ${this.constructor.name} Handler`);
         this.browser = (await launch(finalOptions));
-        this.browser.on('targetcreated', this.onTargetCreated);
+        this.browser.on('targetcreated', this.onTargetCreated.bind(this));
         this.running = true;
         this.browserWSEndpoint = this.browser.wsEndpoint();
         this.logger.info(`${this.constructor.name} is running on ${this.browserWSEndpoint}`);
         return this.browser;
-    };
-    wsEndpoint = () => this.browserWSEndpoint;
-    publicWSEndpoint = (token) => {
+    }
+    wsEndpoint() {
+        return this.browserWSEndpoint;
+    }
+    publicWSEndpoint(token) {
         if (!this.browserWSEndpoint) {
             return null;
         }
@@ -148,55 +156,59 @@ export class ChromiumCDP extends EventEmitter {
             externalURL.searchParams.set('token', token);
         }
         return externalURL.href;
-    };
-    proxyPageWebSocket = async (req, socket, head) => new Promise(async (resolve, reject) => {
-        if (!this.browserWSEndpoint || !this.browser) {
-            throw new ServerError(`No browserWSEndpoint found, did you launch first?`);
-        }
-        socket.once('close', resolve);
-        this.logger.info(`Proxying ${req.parsed.href} to ${this.constructor.name}`);
-        const shouldMakePage = req.parsed.pathname.includes(BLESS_PAGE_IDENTIFIER);
-        const page = shouldMakePage ? await this.browser.newPage() : null;
-        const pathname = page
-            ? path.join('/devtools', '/page', this.getPageId(page))
-            : req.parsed.pathname;
-        const target = new URL(pathname, this.browserWSEndpoint).href;
-        req.url = '';
-        // Delete headers known to cause issues
-        delete req.headers.origin;
-        this.proxy.ws(req, socket, head, {
-            changeOrigin: true,
-            target,
-        }, (error) => {
-            this.logger.error(`Error proxying session to ${this.constructor.name}: ${error}`);
-            this.close();
-            return reject(error);
-        });
-    });
-    proxyWebSocket = async (req, socket, head) => new Promise((resolve, reject) => {
-        if (!this.browserWSEndpoint) {
-            throw new ServerError(`No browserWSEndpoint found, did you launch first?`);
-        }
-        const close = once(() => {
-            this.browser?.off('close', close);
-            this.browser?.process()?.off('close', close);
-            socket.off('close', close);
-            return resolve();
+    }
+    async proxyPageWebSocket(req, socket, head) {
+        return new Promise(async (resolve, reject) => {
+            if (!this.browserWSEndpoint || !this.browser) {
+                throw new ServerError(`No browserWSEndpoint found, did you launch first?`);
+            }
+            socket.once('close', resolve);
+            this.logger.info(`Proxying ${req.parsed.href} to ${this.constructor.name}`);
+            const shouldMakePage = req.parsed.pathname.includes(BLESS_PAGE_IDENTIFIER);
+            const page = shouldMakePage ? await this.browser.newPage() : null;
+            const pathname = page
+                ? path.join('/devtools', '/page', this.getPageId(page))
+                : req.parsed.pathname;
+            const target = new URL(pathname, this.browserWSEndpoint).href;
+            req.url = '';
+            // Delete headers known to cause issues
+            delete req.headers.origin;
+            this.proxy.ws(req, socket, head, {
+                changeOrigin: true,
+                target,
+            }, (error) => {
+                this.logger.error(`Error proxying session to ${this.constructor.name}: ${error}`);
+                this.close();
+                return reject(error);
+            });
         });
-        this.browser?.once('close', close);
-        this.browser?.process()?.once('close', close);
-        socket.once('close', close);
-        this.logger.info(`Proxying ${req.parsed.href} to ${this.constructor.name} ${this.browserWSEndpoint}`);
-        req.url = '';
-        // Delete headers known to cause issues
-        delete req.headers.origin;
-        this.proxy.ws(req, socket, head, {
-            changeOrigin: true,
-            target: this.browserWSEndpoint,
-        }, (error) => {
-            this.logger.error(`Error proxying session to ${this.constructor.name}: ${error}`);
-            this.close();
-            return reject(error);
+    }
+    async proxyWebSocket(req, socket, head) {
+        return new Promise((resolve, reject) => {
+            if (!this.browserWSEndpoint) {
+                throw new ServerError(`No browserWSEndpoint found, did you launch first?`);
+            }
+            const close = once(() => {
+                this.browser?.off('close', close);
+                this.browser?.process()?.off('close', close);
+                socket.off('close', close);
+                return resolve();
+            });
+            this.browser?.once('close', close);
+            this.browser?.process()?.once('close', close);
+            socket.once('close', close);
+            this.logger.info(`Proxying ${req.parsed.href} to ${this.constructor.name} ${this.browserWSEndpoint}`);
+            req.url = '';
+            // Delete headers known to cause issues
+            delete req.headers.origin;
+            this.proxy.ws(req, socket, head, {
+                changeOrigin: true,
+                target: this.browserWSEndpoint,
+            }, (error) => {
+                this.logger.error(`Error proxying session to ${this.constructor.name}: ${error}`);
+                this.close();
+                return reject(error);
+            });
         });
-    });
+    }
 }

package/build/browsers/chromium.playwright.d.ts

@@ -22,16 +22,16 @@ export declare class ChromiumPlaywright extends EventEmitter {
         userDataDir: ChromiumPlaywright['userDataDir'];
     });
     protected cleanListeners(): void;
-    keepAlive(): boolean;
-    isRunning: () => boolean;
-    close: () => Promise<void>;
-    pages: () => Promise<[]>;
-    getPageId: () => string;
-    makeLiveURL: () => void;
-    newPage: () => Promise<Page>;
-    launch: (options?: BrowserServerOptions, version?: string) => Promise<playwright.BrowserServer>;
-    wsEndpoint: () => string | null;
-    publicWSEndpoint: (token: string | null) => string | null;
-    proxyPageWebSocket: () => Promise<void>;
-    proxyWebSocket: (req: Request, socket: Duplex, head: Buffer) => Promise<void>;
+    keepUntil(): number;
+    isRunning(): boolean;
+    close(): Promise<void>;
+    pages(): Promise<[]>;
+    getPageId(): string;
+    makeLiveURL(): void;
+    newPage(): Promise<Page>;
+    launch(options?: BrowserServerOptions, version?: string): Promise<playwright.BrowserServer>;
+    wsEndpoint(): string | null;
+    publicWSEndpoint(token: string | null): string | null;
+    proxyPageWebSocket(): Promise<void>;
+    proxyWebSocket(req: Request, socket: Duplex, head: Buffer): Promise<void>;
 }

package/build/browsers/chromium.playwright.js

@@ -22,11 +22,13 @@ export class ChromiumPlaywright extends EventEmitter {
     cleanListeners() {
         this.removeAllListeners();
     }
-    keepAlive() {
-        return false;
+    keepUntil() {
+        return 0;
     }
-    isRunning = () => this.running;
-    close = async () => {
+    isRunning() {
+        return this.running;
+    }
+    async close() {
         if (this.browser) {
             this.logger.info(`Closing ${this.constructor.name} process and all listeners`);
             this.emit('close');
@@ -36,22 +38,24 @@ export class ChromiumPlaywright extends EventEmitter {
             this.browser = null;
             this.browserWSEndpoint = null;
         }
-    };
-    pages = async () => [];
-    getPageId = () => {
+    }
+    async pages() {
+        return [];
+    }
+    getPageId() {
         throw new ServerError(`#getPageId is not yet supported with ${this.constructor.name}.`);
-    };
-    makeLiveURL = () => {
+    }
+    makeLiveURL() {
         throw new ServerError(`Live URLs are not yet supported with ${this.constructor.name}. In the future this will be at "${this.config.getExternalAddress()}"`);
-    };
-    newPage = async () => {
+    }
+    async newPage() {
         if (!this.browser || !this.browserWSEndpoint) {
             throw new ServerError(`${this.constructor.name} hasn't been launched yet!`);
         }
         const browser = await playwright.chromium.connect(this.browserWSEndpoint);
         return await browser.newPage();
-    };
-    launch = async (options = {}, version) => {
+    }
+    async launch(options = {}, version) {
         this.logger.info(`Launching ${this.constructor.name} Handler`);
         const opts = {
             ...options,
@@ -69,9 +73,11 @@ export class ChromiumPlaywright extends EventEmitter {
         this.running = true;
         this.browserWSEndpoint = browserWSEndpoint;
         return this.browser;
-    };
-    wsEndpoint = () => this.browserWSEndpoint;
-    publicWSEndpoint = (token) => {
+    }
+    wsEndpoint() {
+        return this.browserWSEndpoint;
+    }
+    publicWSEndpoint(token) {
         if (!this.browserWSEndpoint) {
             return null;
         }
@@ -82,26 +88,28 @@ export class ChromiumPlaywright extends EventEmitter {
             externalURL.searchParams.set('token', token);
         }
         return externalURL.href;
-    };
-    proxyPageWebSocket = async () => {
+    }
+    async proxyPageWebSocket() {
         this.logger.warn(`${this.constructor.name} Not yet implemented`);
-    };
-    proxyWebSocket = async (req, socket, head) => new Promise((resolve, reject) => {
-        if (!this.browserWSEndpoint) {
-            throw new ServerError(`No browserWSEndpoint found, did you launch first?`);
-        }
-        socket.once('close', resolve);
-        this.logger.info(`Proxying ${req.parsed.href} to ${this.constructor.name} ${this.browserWSEndpoint}`);
-        // Delete headers known to cause issues
-        delete req.headers.origin;
-        req.url = '';
-        this.proxy.ws(req, socket, head, {
-            changeOrigin: true,
-            target: this.browserWSEndpoint,
-        }, (error) => {
-            this.logger.error(`Error proxying session to ${this.constructor.name}: ${error}`);
-            this.close();
-            return reject(error);
+    }
+    async proxyWebSocket(req, socket, head) {
+        return new Promise((resolve, reject) => {
+            if (!this.browserWSEndpoint) {
+                throw new ServerError(`No browserWSEndpoint found, did you launch first?`);
+            }
+            socket.once('close', resolve);
+            this.logger.info(`Proxying ${req.parsed.href} to ${this.constructor.name} ${this.browserWSEndpoint}`);
+            // Delete headers known to cause issues
+            delete req.headers.origin;
+            req.url = '';
+            this.proxy.ws(req, socket, head, {
+                changeOrigin: true,
+                target: this.browserWSEndpoint,
+            }, (error) => {
+                this.logger.error(`Error proxying session to ${this.constructor.name}: ${error}`);
+                this.close();
+                return reject(error);
+            });
         });
-    });
+    }
 }

package/build/browsers/firefox.playwright.d.ts

@@ -21,16 +21,16 @@ export declare class FirefoxPlaywright extends EventEmitter {
         userDataDir: FirefoxPlaywright['userDataDir'];
     });
     protected cleanListeners(): void;
-    keepAlive(): boolean;
-    isRunning: () => boolean;
-    close: () => Promise<void>;
-    pages: () => Promise<[]>;
-    getPageId: () => string;
-    makeLiveURL: () => void;
-    newPage: () => Promise<Page>;
-    launch: (options?: BrowserServerOptions, version?: string) => Promise<playwright.BrowserServer>;
-    wsEndpoint: () => string | null;
-    publicWSEndpoint: (token: string | null) => string | null;
-    proxyPageWebSocket: () => Promise<void>;
-    proxyWebSocket: (req: Request, socket: Duplex, head: Buffer) => Promise<void>;
+    keepUntil(): number;
+    isRunning(): boolean;
+    close(): Promise<void>;
+    pages(): Promise<[]>;
+    getPageId(): string;
+    makeLiveURL(): void;
+    newPage(): Promise<Page>;
+    launch(options?: BrowserServerOptions, version?: string): Promise<playwright.BrowserServer>;
+    wsEndpoint(): string | null;
+    publicWSEndpoint(token: string | null): string | null;
+    proxyPageWebSocket(): Promise<void>;
+    proxyWebSocket(req: Request, socket: Duplex, head: Buffer): Promise<void>;
 }

package/build/browsers/firefox.playwright.js

@@ -21,11 +21,13 @@ export class FirefoxPlaywright extends EventEmitter {
     cleanListeners() {
         this.removeAllListeners();
     }
-    keepAlive() {
-        return false;
+    keepUntil() {
+        return 0;
     }
-    isRunning = () => this.running;
-    close = async () => {
+    isRunning() {
+        return this.running;
+    }
+    async close() {
         if (this.browser) {
             this.logger.trace(`Closing ${this.constructor.name} process and all listeners`);
             this.emit('close');
@@ -35,18 +37,20 @@ export class FirefoxPlaywright extends EventEmitter {
             this.browser = null;
             this.browserWSEndpoint = null;
         }
-    };
-    pages = async () => [];
-    getPageId = () => {
+    }
+    async pages() {
+        return [];
+    }
+    getPageId() {
         throw new ServerError(`#getPageId is not yet supported with ${this.constructor.name}.`);
-    };
-    makeLiveURL = () => {
+    }
+    makeLiveURL() {
         throw new ServerError(`Live URLs are not yet supported with ${this.constructor.name}.`);
-    };
-    newPage = async () => {
+    }
+    async newPage() {
         throw new ServerError(`Can't create new page with ${this.constructor.name}`);
-    };
-    launch = async (options = {}, version) => {
+    }
+    async launch(options = {}, version) {
         this.logger.info(`Launching ${this.constructor.name} Handler`);
         const opts = {
             ...options,
@@ -63,9 +67,11 @@ export class FirefoxPlaywright extends EventEmitter {
         this.browserWSEndpoint = browserWSEndpoint;
         this.running = true;
         return this.browser;
-    };
-    wsEndpoint = () => this.browserWSEndpoint;
-    publicWSEndpoint = (token) => {
+    }
+    wsEndpoint() {
+        return this.browserWSEndpoint;
+    }
+    publicWSEndpoint(token) {
         if (!this.browserWSEndpoint) {
             return null;
         }
@@ -76,26 +82,28 @@ export class FirefoxPlaywright extends EventEmitter {
             externalURL.searchParams.set('token', token);
         }
         return externalURL.href;
-    };
-    proxyPageWebSocket = async () => {
+    }
+    async proxyPageWebSocket() {
         this.logger.warn(`Not yet implemented in ${this.constructor.name}`);
-    };
-    proxyWebSocket = async (req, socket, head) => new Promise((resolve, reject) => {
-        if (!this.browserWSEndpoint) {
-            throw new ServerError(`No browserWSEndpoint found, did you launch first?`);
-        }
-        socket.once('close', resolve);
-        this.logger.info(`Proxying ${req.parsed.href} to ${this.constructor.name} ${this.browserWSEndpoint}`);
-        // Delete headers known to cause issues
-        delete req.headers.origin;
-        req.url = '';
-        this.proxy.ws(req, socket, head, {
-            changeOrigin: true,
-            target: this.browserWSEndpoint,
-        }, (error) => {
-            this.logger.error(`Error proxying session to ${this.constructor.name}: ${error}`);
-            this.close();
-            return reject(error);
+    }
+    async proxyWebSocket(req, socket, head) {
+        return new Promise((resolve, reject) => {
+            if (!this.browserWSEndpoint) {
+                throw new ServerError(`No browserWSEndpoint found, did you launch first?`);
+            }
+            socket.once('close', resolve);
+            this.logger.info(`Proxying ${req.parsed.href} to ${this.constructor.name} ${this.browserWSEndpoint}`);
+            // Delete headers known to cause issues
+            delete req.headers.origin;
+            req.url = '';
+            this.proxy.ws(req, socket, head, {
+                changeOrigin: true,
+                target: this.browserWSEndpoint,
+            }, (error) => {
+                this.logger.error(`Error proxying session to ${this.constructor.name}: ${error}`);
+                this.close();
+                return reject(error);
+            });
         });
-    });
+    }
 }

package/build/browsers/index.d.ts

@@ -1,36 +1,37 @@
+/// <reference types="node" />
 import { BrowserHTTPRoute, BrowserInstance, BrowserServerOptions, BrowserWebsocketRoute, BrowserlessSession, BrowserlessSessionJSON, CDPJSONPayload, CDPLaunchOptions, ChromiumCDP, Config, Hooks, Logger, Request } from '@browserless.io/browserless';
 import { Page } from 'puppeteer-core';
 export declare class BrowserManager {
     protected config: Config;
     protected hooks: Hooks;
     protected browsers: Map<BrowserInstance, BrowserlessSession>;
-    protected timers: Map<string, number>;
+    protected timers: Map<string, NodeJS.Timeout>;
     protected log: Logger;
     protected chromeBrowsers: (typeof ChromiumCDP)[];
     protected playwrightBrowserNames: string[];
     constructor(config: Config, hooks: Hooks);
-    protected browserIsChrome: (b: BrowserInstance) => boolean;
-    protected removeUserDataDir: (userDataDir: string | null) => Promise<void>;
-    protected onNewPage: (req: Request, page: Page) => Promise<void>;
+    protected browserIsChrome(b: BrowserInstance): boolean;
+    protected removeUserDataDir(userDataDir: string | null): Promise<void>;
+    protected onNewPage(req: Request, page: Page): Promise<unknown>;
     /**
      * Returns the /json/protocol API contents from Chromium or Chrome, whichever is installed,
      * and modifies URLs to set them to the appropriate addresses configured.
      * When both Chrome and Chromium are installed, defaults to Chromium.
      */
-    getProtocolJSON: (logger: Logger) => Promise<object>;
+    getProtocolJSON(logger: Logger): Promise<object>;
     /**
      * Returns the /json/version API from Chromium or Chrome, whichever is installed,
      * and modifies URLs to set them to the appropriate addresses configured.
      * When both Chrome and Chromium are installed, defaults to Chromium.
      */
-    getVersionJSON: (logger: Logger) => Promise<CDPJSONPayload>;
+    getVersionJSON(logger: Logger): Promise<CDPJSONPayload>;
     /**
      * Returns a list of all Chrome-like browsers (both Chromium and Chrome) with
      * their respective /json/list contents. URLs are modified so that subsequent
      * calls can be forwarded to the appropriate destination
      */
-    getJSONList: () => Promise<Array<CDPJSONPayload>>;
-    protected generateSessionJson: (browser: BrowserInstance, session: BrowserlessSession) => Promise<{
+    getJSONList(): Promise<Array<CDPJSONPayload>>;
+    protected generateSessionJson(browser: BrowserInstance, session: BrowserlessSession): Promise<{
         browser: string;
         browserId: string;
         initialConnectURL: string;
@@ -38,23 +39,23 @@ export declare class BrowserManager {
         running: boolean;
         timeAliveMs: number;
         type: string;
-        id: string | null;
+        id: string;
         isTempDataDir: boolean;
         launchOptions: CDPLaunchOptions | BrowserServerOptions;
         numbConnected: number;
-        resolver: (val: unknown) => void;
+        resolver(val: unknown): void;
         routePath: string | string[];
         startedOn: number;
         ttl: number;
         userDataDir: string | null;
     }[]>;
-    close: (browser: BrowserInstance, session: BrowserlessSession) => Promise<void>;
-    getAllSessions: () => Promise<BrowserlessSessionJSON[]>;
-    complete: (browser: BrowserInstance) => Promise<void>;
-    getBrowserForRequest: (req: Request, router: BrowserHTTPRoute | BrowserWebsocketRoute, logger: Logger) => Promise<BrowserInstance>;
-    shutdown: () => Promise<void>;
+    close(browser: BrowserInstance, session: BrowserlessSession): Promise<void>;
+    getAllSessions(): Promise<BrowserlessSessionJSON[]>;
+    complete(browser: BrowserInstance): Promise<void>;
+    getBrowserForRequest(req: Request, router: BrowserHTTPRoute | BrowserWebsocketRoute, logger: Logger): Promise<BrowserInstance>;
+    shutdown(): Promise<void>;
     /**
      * Left blank for downstream SDK modules to optionally implement.
      */
-    stop: () => void;
+    stop(): void;
 }