@tstdl/base 0.83.28 → 0.84.1

package/application/application.d.ts

@@ -11,7 +11,7 @@ export declare class Application {
     private readonly moduleInstances;
     private readonly shutdownPromise;
     private readonly _shutdownToken;
-    readonly shutdownToken: ReadonlyCancellationToken;
+    get shutdownToken(): ReadonlyCancellationToken;
     static get shutdownToken(): ReadonlyCancellationToken;
     constructor(logger: Logger);
     static registerModule(moduleType: Type<Module>): void;

package/application/application.js

@@ -59,7 +59,6 @@ let Application = Application_1 = class Application2 {
     if ((0, import_type_guards.isUndefined)(this._instance)) {
       this._instance = import_container.container.resolve(Application_1);
       this._instance._shutdownToken = import_process_shutdown.shutdownToken;
-      this._instance.shutdownToken = import_process_shutdown.shutdownToken.asReadonly;
     }
     return this._instance;
   }
@@ -68,7 +67,9 @@ let Application = Application_1 = class Application2 {
   moduleInstances;
   shutdownPromise;
   _shutdownToken;
-  shutdownToken;
+  get shutdownToken() {
+    return this._shutdownToken.asReadonly();
+  }
   static get shutdownToken() {
     return Application_1.instance.shutdownToken;
   }
@@ -78,7 +79,6 @@ let Application = Application_1 = class Application2 {
     this.moduleInstances = /* @__PURE__ */ new Set();
     this.shutdownPromise = new import_deferred_promise.DeferredPromise();
     this._shutdownToken = import_process_shutdown.shutdownToken.createChild();
-    this.shutdownToken = this._shutdownToken.asReadonly;
   }
   static registerModule(moduleType) {
     Application_1.instance.registerModule(moduleType);

package/browser/browser-context-controller.d.ts

@@ -0,0 +1,32 @@
+import type { BrowserContext } from 'playwright';
+import type { Injectable } from '../container/interfaces.js';
+import { resolveArgumentType } from '../container/interfaces.js';
+import type { AsyncDisposable } from '../disposable/disposable.js';
+import { disposeAsync } from '../disposable/disposable.js';
+import type { Json } from '../types.js';
+import type { Opaque } from 'type-fest';
+import type { NewBrowserContextOptions } from './browser-controller.js';
+import type { PageControllerOptions } from './page-controller.js';
+import { PageController } from './page-controller.js';
+export type BrowserContextControllerOptions = {
+    defaultNewPageOptions?: NewPageOptions;
+};
+export type NewPageOptions = {
+    extraHttpHeaders?: Record<string, string>;
+    controllerOptions?: PageControllerOptions;
+};
+export type BrowserContextState = Opaque<Json, 'BrowserContextState'>;
+export type BrowserContextControllerArgument = NewBrowserContextOptions;
+export declare class BrowserContextController implements AsyncDisposable, Injectable<BrowserContextControllerArgument> {
+    private readonly options;
+    /** @deprecated should be avoided */
+    readonly context: BrowserContext;
+    readonly [resolveArgumentType]: BrowserContextControllerArgument;
+    constructor(context: BrowserContext, options?: BrowserContextControllerOptions);
+    [disposeAsync](): Promise<void>;
+    close(): Promise<void>;
+    getState(): Promise<BrowserContextState>;
+    setExtraHttpHeaders(headers: Record<string, string>): Promise<void>;
+    newPage(options?: NewPageOptions): Promise<PageController>;
+    waitForClose(): Promise<void>;
+}

package/browser/browser-context-controller.js

@@ -0,0 +1,88 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var browser_context_controller_exports = {};
+__export(browser_context_controller_exports, {
+  BrowserContextController: () => BrowserContextController
+});
+module.exports = __toCommonJS(browser_context_controller_exports);
+var import_decorators = require("../container/decorators.js");
+var import_interfaces = require("../container/interfaces.js");
+var import_disposable = require("../disposable/disposable.js");
+var import_type_guards = require("../utils/type-guards.js");
+var import_browser_controller = require("./browser-controller.js");
+var import_page_controller = require("./page-controller.js");
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+let BrowserContextController = class BrowserContextController2 {
+  options;
+  /** @deprecated should be avoided */
+  context;
+  constructor(context, options = {}) {
+    this.context = context;
+    this.options = options;
+  }
+  async [import_disposable.disposeAsync]() {
+    await this.close();
+  }
+  async close() {
+    await this.context.close();
+  }
+  async getState() {
+    const state = await this.context.storageState();
+    return state;
+  }
+  async setExtraHttpHeaders(headers) {
+    await this.context.setExtraHTTPHeaders(headers);
+  }
+  async newPage(options) {
+    const page = await this.context.newPage();
+    const mergedOptions = { ...this.options.defaultNewPageOptions, ...options };
+    const controller = new import_page_controller.PageController(page, mergedOptions.controllerOptions);
+    if ((0, import_type_guards.isDefined)(mergedOptions.extraHttpHeaders)) {
+      await controller.setExtraHttpHeaders(mergedOptions.extraHttpHeaders);
+    }
+    return controller;
+  }
+  async waitForClose() {
+    return new Promise((resolve) => this.context.once("close", () => resolve()));
+  }
+};
+BrowserContextController = __decorate([
+  (0, import_decorators.injectable)({
+    provider: {
+      useFactory: async (argument, context) => {
+        const browserController = await context.resolveAsync(import_browser_controller.BrowserController);
+        return browserController.newContext(argument);
+      }
+    }
+  }),
+  __metadata("design:paramtypes", [Object, Object])
+], BrowserContextController);

package/browser/browser-controller.d.ts

@@ -1,26 +1,45 @@
+import type { Browser } from 'playwright';
 import type { Injectable } from '../container/interfaces.js';
 import { resolveArgumentType } from '../container/interfaces.js';
 import type { AsyncDisposable } from '../disposable/disposable.js';
 import { disposeAsync } from '../disposable/disposable.js';
-import * as puppeteer from 'puppeteer';
+import type { BrowserContextControllerOptions, BrowserContextState, NewPageOptions } from './browser-context-controller.js';
+import { BrowserContextController } from './browser-context-controller.js';
 import type { NewBrowserOptions } from './browser.service.js';
-import type { PageControllerOptions } from './page-controller.js';
-import { PageController } from './page-controller.js';
+import type { PageController } from './page-controller.js';
 export type BrowserControllerOptions = {
-    defaultNewPageOptions?: NewPageOptions;
+    defaultNewContextOptions?: NewBrowserContextOptions;
 };
-export type NewPageOptions = {
+export type NewBrowserContextOptions = {
+    state?: BrowserContextState;
+    locale?: string;
     extraHttpHeaders?: Record<string, string>;
-    controllerOptions?: PageControllerOptions;
+    controllerOptions?: BrowserContextControllerOptions;
+    viewport?: {
+        width: number;
+        height: number;
+    } | null;
+    proxy?: {
+        server: string;
+        bypass?: string;
+        username?: string;
+        password?: string;
+    };
 };
-export declare class BrowserController implements AsyncDisposable, Injectable<NewBrowserOptions> {
+export type BrowserControllerArgument = NewBrowserOptions;
+export declare class BrowserController implements AsyncDisposable, Injectable<BrowserControllerArgument> {
     /** @deprecated should be avoided */
-    readonly browser: puppeteer.Browser;
+    readonly browser: Browser;
     readonly options: BrowserControllerOptions | undefined;
-    readonly [resolveArgumentType]: NewBrowserOptions;
-    constructor(browser: puppeteer.Browser, options?: BrowserControllerOptions);
+    readonly [resolveArgumentType]: BrowserControllerArgument;
+    constructor(browser: Browser, options?: BrowserControllerOptions);
     [disposeAsync](): Promise<void>;
+    newContext(options?: NewBrowserContextOptions): Promise<BrowserContextController>;
+    /**
+     * Creates a new context and a new page. Context is automatically closed on page close.
+     * Only use for isolated or "use once" scenarios, otherwise all the contexts are more expensive than using a single context.
+     */
+    newPage(options?: NewBrowserContextOptions & NewPageOptions): Promise<PageController>;
     close(): Promise<void>;
-    newPage(options?: NewPageOptions): Promise<PageController>;
     waitForClose(): Promise<void>;
 }

package/browser/browser-controller.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var browser_controller_exports = {};
 __export(browser_controller_exports, {
@@ -34,11 +24,9 @@ module.exports = __toCommonJS(browser_controller_exports);
 var import_decorators = require("../container/decorators.js");
 var import_interfaces = require("../container/interfaces.js");
 var import_disposable = require("../disposable/disposable.js");
-var import_object = require("../utils/object/object.js");
-var import_type_guards = require("../utils/type-guards.js");
-var puppeteer = __toESM(require("puppeteer"), 1);
+var import_browser_context_controller = require("./browser-context-controller.js");
 var import_browser_service = require("./browser.service.js");
-var import_page_controller = require("./page-controller.js");
+var import_utils = require("./utils.js");
 var __decorate = function(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
@@ -62,28 +50,50 @@ let BrowserController = class BrowserController2 {
     this.options = options;
   }
   async [import_disposable.disposeAsync]() {
-    return this.close();
+    await this.close();
+  }
+  async newContext(options) {
+    const mergedOptions = (0, import_utils.mergeNewBrowserContextOptions)(this.options?.defaultNewContextOptions, options);
+    const context = await this.browser.newContext({
+      storageState: mergedOptions.state,
+      locale: mergedOptions.locale,
+      viewport: mergedOptions.viewport,
+      proxy: mergedOptions.proxy,
+      extraHTTPHeaders: mergedOptions.extraHttpHeaders
+    });
+    return new import_browser_context_controller.BrowserContextController(context, mergedOptions.controllerOptions);
+  }
+  /**
+   * Creates a new context and a new page. Context is automatically closed on page close.
+   * Only use for isolated or "use once" scenarios, otherwise all the contexts are more expensive than using a single context.
+   */
+  async newPage(options) {
+    const context = await this.newContext(options);
+    try {
+      const page = await context.newPage(options);
+      page.ownedContext = context;
+      return page;
+    } catch (error) {
+      await context.close();
+      throw error;
+    }
   }
   async close() {
     if (this.browser.isConnected()) {
+      for (const context of this.browser.contexts()) {
+        await context.close();
+      }
       await this.browser.close();
     }
   }
-  async newPage(options) {
-    const mergedExtraHttpHeaderEntries = [...(0, import_object.objectEntries)(options?.extraHttpHeaders ?? {}), ...(0, import_object.objectEntries)(this.options?.defaultNewPageOptions?.extraHttpHeaders ?? {})];
-    const newPageOptions = {
-      controllerOptions: options?.controllerOptions ?? this.options?.defaultNewPageOptions?.controllerOptions,
-      extraHttpHeaders: mergedExtraHttpHeaderEntries.length > 0 ? (0, import_object.fromEntries)(mergedExtraHttpHeaderEntries) : void 0
-    };
-    const page = await this.browser.newPage();
-    const controller = new import_page_controller.PageController(page, newPageOptions.controllerOptions);
-    if ((0, import_type_guards.isDefined)(newPageOptions.extraHttpHeaders)) {
-      await controller.setExtraHttpHeaders(newPageOptions.extraHttpHeaders);
-    }
-    return controller;
-  }
   async waitForClose() {
-    return new Promise((resolve) => this.browser.once("disconnected", resolve));
+    return new Promise((resolve) => {
+      if (!this.browser.isConnected()) {
+        resolve();
+      } else {
+        this.browser.once("disconnected", () => resolve());
+      }
+    });
   }
 };
 BrowserController = __decorate([
@@ -95,5 +105,5 @@ BrowserController = __decorate([
       }
     }
   }),
-  __metadata("design:paramtypes", [puppeteer.Browser, Object])
+  __metadata("design:paramtypes", [Object, Object])
 ], BrowserController);

package/browser/browser.service.d.ts

@@ -2,31 +2,33 @@ import type { Injectable } from '../container/interfaces.js';
 import { afterResolve, resolveArgumentType } from '../container/interfaces.js';
 import type { AsyncDisposable } from '../disposable/disposable.js';
 import { disposeAsync } from '../disposable/disposable.js';
-import type { BrowserControllerOptions } from './browser-controller.js';
+import { BrowserContextController } from './browser-context-controller.js';
+import type { BrowserControllerOptions, NewBrowserContextOptions } from './browser-controller.js';
 import { BrowserController } from './browser-controller.js';
 export declare class BrowserServiceOptions {
     defaultNewBrowserOptions?: NewBrowserOptions;
 }
 export type BrowserServiceArgument = BrowserServiceOptions;
 export type NewBrowserOptions = {
+    browser?: 'chromium' | 'firefox' | 'webkit';
     headless?: boolean;
-    width?: number;
-    height?: number;
-    language?: string;
-    proxy?: string;
+    windowSize?: {
+        width: number;
+        height: number;
+    };
     /** @deprecated should be avoided */
     browserArguments?: string[];
-    /** @deprecated should be avoided */
-    browserEnvironment?: Record<string, string | undefined>;
     controllerOptions?: BrowserControllerOptions;
 };
 export declare class BrowserService implements AsyncDisposable, Injectable<BrowserServiceArgument> {
     private readonly browsers;
+    private readonly persistentBrowserContexts;
     readonly options: BrowserServiceOptions | undefined;
     readonly [resolveArgumentType]: BrowserServiceArgument;
     constructor(options?: BrowserServiceOptions);
     [afterResolve](): void;
     [disposeAsync](): Promise<void>;
     newBrowser(options?: NewBrowserOptions): Promise<BrowserController>;
+    newPersistentContext(dataDirectory: string, browserOptions?: NewBrowserOptions, contextOptions?: NewBrowserContextOptions): Promise<BrowserContextController>;
     dispose(): Promise<void>;
 }

package/browser/browser.service.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var browser_service_exports = {};
 __export(browser_service_exports, {
@@ -36,9 +26,9 @@ var import_decorators = require("../container/decorators.js");
 var import_interfaces = require("../container/interfaces.js");
 var import_core = require("../core.js");
 var import_disposable = require("../disposable/disposable.js");
-var import_type_guards = require("../utils/type-guards.js");
-var puppeteer = __toESM(require("puppeteer"), 1);
+var import_browser_context_controller = require("./browser-context-controller.js");
 var import_browser_controller = require("./browser-controller.js");
+var import_utils = require("./utils.js");
 var __decorate = function(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
@@ -63,10 +53,12 @@ class BrowserServiceOptions {
 }
 let BrowserService = class BrowserService2 {
   browsers;
+  persistentBrowserContexts;
   options;
   constructor(options) {
     this.options = options;
-    this.browsers = [];
+    this.browsers = /* @__PURE__ */ new Set();
+    this.persistentBrowserContexts = /* @__PURE__ */ new Set();
   }
   [import_interfaces.afterResolve]() {
     import_core.disposer.add(this);
@@ -74,33 +66,38 @@ let BrowserService = class BrowserService2 {
   async [import_disposable.disposeAsync]() {
     return this.dispose();
   }
-  async newBrowser(options) {
-    const { width = 1e3, height = 1e3, browserArguments, browserEnvironment, proxy, language, headless, controllerOptions } = { ...this.options?.defaultNewBrowserOptions, ...options };
-    const args = [`--window-size=${width},${height}`, ...browserArguments ?? []];
-    const env = { ...process.env, ...browserEnvironment };
-    if ((0, import_type_guards.isDefined)(proxy)) {
-      args.push(`--proxy-server=${proxy}`);
-    }
-    if ((0, import_type_guards.isDefined)(language)) {
-      args.push(`--lang=${language}`);
-      env["LANGUAGE"] = language;
-    }
-    const browser = await puppeteer.launch({
-      headless: headless == true ? "new" : false,
-      args,
-      env,
-      defaultViewport: { width, height }
+  async newBrowser(options = {}) {
+    const mergedOptions = { ...this.options?.defaultNewBrowserOptions, ...options };
+    const launchOptions = (0, import_utils.getLaunchOptions)(mergedOptions);
+    const browser = await (0, import_utils.getBrowserType)(mergedOptions.browser).launch(launchOptions);
+    this.browsers.add(browser);
+    browser.once("disconnected", () => this.browsers.delete(browser));
+    return new import_browser_controller.BrowserController(browser, mergedOptions.controllerOptions);
+  }
+  async newPersistentContext(dataDirectory, browserOptions = {}, contextOptions = {}) {
+    const mergedBrowserOptions = { ...this.options?.defaultNewBrowserOptions, ...browserOptions };
+    const mergedContextOptions = (0, import_utils.mergeNewBrowserContextOptions)(this.options?.defaultNewBrowserOptions?.controllerOptions?.defaultNewContextOptions, browserOptions.controllerOptions?.defaultNewContextOptions, contextOptions);
+    const launchOptions = (0, import_utils.getLaunchOptions)(mergedBrowserOptions);
+    const context = await (0, import_utils.getBrowserType)(mergedBrowserOptions.browser).launchPersistentContext(dataDirectory, {
+      ...launchOptions,
+      locale: mergedContextOptions.locale,
+      viewport: mergedContextOptions.viewport,
+      proxy: mergedContextOptions.proxy,
+      extraHTTPHeaders: mergedContextOptions.extraHttpHeaders
     });
-    this.browsers.push(new WeakRef(browser));
-    return new import_browser_controller.BrowserController(browser, controllerOptions);
+    this.persistentBrowserContexts.add(context);
+    context.once("close", () => this.persistentBrowserContexts.delete(context));
+    return new import_browser_context_controller.BrowserContextController(context, mergedBrowserOptions.controllerOptions?.defaultNewContextOptions?.controllerOptions);
   }
   async dispose() {
-    for (const browserRef of this.browsers) {
-      const browser = browserRef.deref();
-      if ((0, import_type_guards.isDefined)(browser) && browser.isConnected()) {
+    for (const browser of this.browsers) {
+      if (browser.isConnected()) {
         await browser.close();
       }
     }
+    for (const context of this.persistentBrowserContexts) {
+      await context.close();
+    }
   }
 };
 BrowserService = __decorate([

package/browser/index.d.ts

@@ -1,4 +1,4 @@
+export * from './browser-context-controller.js';
 export * from './browser-controller.js';
 export * from './browser.service.js';
 export * from './page-controller.js';
-export * from './types.js';

package/browser/index.js

@@ -15,7 +15,7 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var browser_exports = {};
 module.exports = __toCommonJS(browser_exports);
+__reExport(browser_exports, require("./browser-context-controller.js"), module.exports);
 __reExport(browser_exports, require("./browser-controller.js"), module.exports);
 __reExport(browser_exports, require("./browser.service.js"), module.exports);
 __reExport(browser_exports, require("./page-controller.js"), module.exports);
-__reExport(browser_exports, require("./types.js"), module.exports);

package/browser/page-controller.d.ts

@@ -1,7 +1,7 @@
-import * as puppeteer from 'puppeteer';
+import type { Page } from 'playwright';
 import type { AsyncDisposable } from '../disposable/disposable.js';
 import { disposeAsync } from '../disposable/disposable.js';
-import type { WritableOneOrMany } from '../types.js';
+import type { BrowserContextController } from './browser-context-controller.js';
 import type { PdfRenderOptions } from './pdf-options.js';
 export type Delay = number | DelayProvider;
 export type DelayProvider = () => number;
@@ -9,48 +9,46 @@ export type PageControllerOptions = {
     actionDelay?: Delay;
     typeDelay?: Delay;
 };
-export type SelectorOptions = {
-    xpath?: boolean;
-};
-export type WaitForElementOptions = {
+export type WaitOptions = {
     timeout?: number;
 };
-export type PageLifecycleEvent = puppeteer.PuppeteerLifeCycleEvent;
-export type WaitForOptions = {
-    timeout?: number;
-    waitUntil?: WritableOneOrMany<PageLifecycleEvent>;
+export type LoadState = 'load' | 'domcontentloaded' | 'networkidle';
+export type WaitForStateOptions = {
+    waitUntil: LoadState;
+};
+export type DelayOptions = {
+    delay?: Delay;
+};
+export type Abortable = {
+    abort?: AbortSignal;
+};
+/** @deprecated for internal use only */
+export type PageControllerInternal = {
+    ownedContext?: BrowserContextController;
 };
 export declare class PageController implements AsyncDisposable {
+    private readonly ownedContext?;
     /** @deprecated should be avoided */
-    readonly page: puppeteer.Page;
+    readonly page: Page;
     readonly options: PageControllerOptions;
-    constructor(pageOrFrame: puppeteer.Page | puppeteer.Frame, options?: PageControllerOptions);
+    constructor(page: Page, options?: PageControllerOptions);
     [disposeAsync](): Promise<void>;
     close(): Promise<void>;
-    setContent(html: string, options?: WaitForOptions): Promise<void>;
+    setContent(html: string, options?: WaitOptions & WaitForStateOptions): Promise<void>;
     setExtraHttpHeaders(headers: Record<string, string>): Promise<void>;
-    authenticate(username: string, password: string): Promise<void>;
-    navigate(url: string, options?: WaitForOptions): Promise<void>;
+    navigate(url: string, options?: WaitOptions & WaitForStateOptions): Promise<void>;
     waitForClose(): Promise<void>;
-    waitForIdle(options?: {
-        idleTime?: number;
-        timeout?: number;
-    }): Promise<void>;
-    waitForUrl(urlOrPredicate: string | ((url: string) => boolean | Promise<boolean>), options?: {
-        timeout?: number;
-    }): Promise<void>;
-    waitForFrame(selector: string, options?: SelectorOptions): Promise<PageController>;
-    waitForFrameByUrl(urlOrPredicate: string | ((frame: puppeteer.Frame) => boolean | Promise<boolean>), options?: {
-        timeout?: number;
-    }): Promise<PageController>;
-    getDeepestFrame(): PageController;
-    type(handleOrSelector: puppeteer.ElementHandle | string, text: string, options?: SelectorOptions): Promise<void>;
-    select(handleOrSelector: puppeteer.ElementHandle | string, value: string, options?: SelectorOptions): Promise<void>;
-    click(handleOrSelector: puppeteer.ElementHandle | string, options?: SelectorOptions): Promise<void>;
-    getValue(handleOrSelector: puppeteer.ElementHandle | string, options?: SelectorOptions): Promise<string>;
-    waitForElement(selector: string, options?: WaitForElementOptions & SelectorOptions): Promise<void>;
-    renderPdf(options?: PdfRenderOptions): Promise<Uint8Array>;
-    renderPdfStream(options?: PdfRenderOptions): ReadableStream<Uint8Array>;
-    private waitForElementHandle;
+    waitForState(state: LoadState, options?: WaitOptions): Promise<void>;
+    waitForNetworkIdle(options?: WaitOptions): Promise<void>;
+    waitForUrl(urlOrPredicate: string | RegExp | ((url: URL) => boolean), options?: WaitOptions): Promise<void>;
+    waitForFrame(selector: string, options?: WaitOptions): Promise<PageController>;
+    fill(selector: string, text: string, options?: DelayOptions & WaitOptions): Promise<void>;
+    type(selector: string, text: string, options?: DelayOptions & WaitOptions): Promise<void>;
+    selectOption(selector: string, value: string | string[], options?: WaitOptions): Promise<void>;
+    click(selector: string, options?: WaitOptions): Promise<void>;
+    getValue(selector: string, options?: WaitOptions): Promise<string>;
+    waitForElement(selector: string, options?: WaitOptions): Promise<void>;
+    renderPdf(options?: PdfRenderOptions & Abortable): Promise<Uint8Array>;
+    renderPdfStream(options?: PdfRenderOptions & Abortable): ReadableStream<Uint8Array>;
     private prepareAction;
 }