@tstdl/base 0.83.27 → 0.84.0

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

@@ -24,8 +24,8 @@ module.exports = __toCommonJS(application_exports);
 var import_container = require("../container/index.js");
 var import_core = require("../core.js");
 var import_logger = require("../logger/index.js");
-var import_module = require("../module/module.js");
 var import_module_base = require("../module/module-base.js");
+var import_module = require("../module/module.js");
 var import_function_module = require("../module/modules/function.module.js");
 var import_process_shutdown = require("../process-shutdown.js");
 var import_deferred_promise = require("../promise/deferred-promise.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

@@ -0,0 +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 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 { PageController } from './page-controller.js';
+export type BrowserControllerOptions = {
+    defaultNewContextOptions?: NewBrowserContextOptions;
+};
+export type NewBrowserContextOptions = {
+    state?: BrowserContextState;
+    locale?: string;
+    extraHttpHeaders?: Record<string, string>;
+    controllerOptions?: BrowserContextControllerOptions;
+    viewport?: {
+        width: number;
+        height: number;
+    } | null;
+    proxy?: {
+        server: string;
+        bypass?: string;
+        username?: string;
+        password?: string;
+    };
+};
+export type BrowserControllerArgument = NewBrowserOptions;
+export declare class BrowserController implements AsyncDisposable, Injectable<BrowserControllerArgument> {
+    /** @deprecated should be avoided */
+    readonly browser: Browser;
+    readonly options: BrowserControllerOptions | undefined;
+    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>;
+    waitForClose(): Promise<void>;
+}

package/browser/browser-controller.js

@@ -0,0 +1,109 @@
+"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_controller_exports = {};
+__export(browser_controller_exports, {
+  BrowserController: () => BrowserController
+});
+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_browser_context_controller = require("./browser-context-controller.js");
+var import_browser_service = require("./browser.service.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")
+    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 BrowserController = class BrowserController2 {
+  /** @deprecated should be avoided */
+  browser;
+  options;
+  constructor(browser, options) {
+    this.browser = browser;
+    this.options = options;
+  }
+  async [import_disposable.disposeAsync]() {
+    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 waitForClose() {
+    return new Promise((resolve) => {
+      if (!this.browser.isConnected()) {
+        resolve();
+      } else {
+        this.browser.once("disconnected", () => resolve());
+      }
+    });
+  }
+};
+BrowserController = __decorate([
+  (0, import_decorators.injectable)({
+    provider: {
+      useFactory: async (argument, context) => {
+        const browserService = await context.resolveAsync(import_browser_service.BrowserService);
+        return browserService.newBrowser(argument);
+      }
+    }
+  }),
+  __metadata("design:paramtypes", [Object, Object])
+], BrowserController);

package/browser/browser.service.d.ts

@@ -0,0 +1,34 @@
+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 { 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;
+    windowSize?: {
+        width: number;
+        height: number;
+    };
+    /** @deprecated should be avoided */
+    browserArguments?: string[];
+    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

@@ -0,0 +1,107 @@
+"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_service_exports = {};
+__export(browser_service_exports, {
+  BrowserService: () => BrowserService,
+  BrowserServiceOptions: () => BrowserServiceOptions
+});
+module.exports = __toCommonJS(browser_service_exports);
+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_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")
+    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);
+};
+var __param = function(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+};
+class BrowserServiceOptions {
+  defaultNewBrowserOptions;
+}
+let BrowserService = class BrowserService2 {
+  browsers;
+  persistentBrowserContexts;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.browsers = /* @__PURE__ */ new Set();
+    this.persistentBrowserContexts = /* @__PURE__ */ new Set();
+  }
+  [import_interfaces.afterResolve]() {
+    import_core.disposer.add(this);
+  }
+  async [import_disposable.disposeAsync]() {
+    return this.dispose();
+  }
+  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.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 browser of this.browsers) {
+      if (browser.isConnected()) {
+        await browser.close();
+      }
+    }
+    for (const context of this.persistentBrowserContexts) {
+      await context.close();
+    }
+  }
+};
+BrowserService = __decorate([
+  (0, import_decorators.singleton)(),
+  __param(0, (0, import_decorators.injectArg)()),
+  __metadata("design:paramtypes", [BrowserServiceOptions])
+], BrowserService);

package/browser/index.d.ts

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

package/browser/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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);

package/browser/page-controller.d.ts

@@ -0,0 +1,54 @@
+import type { Page } from 'playwright';
+import type { AsyncDisposable } from '../disposable/disposable.js';
+import { disposeAsync } from '../disposable/disposable.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;
+export type PageControllerOptions = {
+    actionDelay?: Delay;
+    typeDelay?: Delay;
+};
+export type WaitOptions = {
+    timeout?: number;
+};
+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: Page;
+    readonly options: PageControllerOptions;
+    constructor(page: Page, options?: PageControllerOptions);
+    [disposeAsync](): Promise<void>;
+    close(): Promise<void>;
+    setContent(html: string, options?: WaitOptions & WaitForStateOptions): Promise<void>;
+    setExtraHttpHeaders(headers: Record<string, string>): Promise<void>;
+    navigate(url: string, options?: WaitOptions & WaitForStateOptions): Promise<void>;
+    waitForClose(): Promise<void>;
+    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;
+}