dappress 0.4.0 → 0.5.1

package/dist/browser.d.ts

@@ -0,0 +1,7 @@
+import { type Browser } from 'puppeteer-core';
+export declare function captureDebuggerUrl(on: Cypress.PluginEvents): void;
+/**
+ * Run `action` with a Puppeteer browser connected to Cypress's browser, then
+ * give the focus back to the Cypress tab and disconnect. The browser stays open.
+ */
+export declare function withBrowser<T>(action: (browser: Browser) => Promise<T>): Promise<T>;

package/dist/browser.js

@@ -0,0 +1,45 @@
+"use strict";
+// Connects Puppeteer to the browser Cypress launched, through the debugging
+// URL Cypress hands out in after:browser:launch (Cypress 13.6+).
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureDebuggerUrl = captureDebuggerUrl;
+exports.withBrowser = withBrowser;
+const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
+let debuggerUrl;
+function captureDebuggerUrl(on) {
+    on('after:browser:launch', (browser, options) => {
+        debuggerUrl = options.webSocketDebuggerUrl;
+    });
+}
+/**
+ * Run `action` with a Puppeteer browser connected to Cypress's browser, then
+ * give the focus back to the Cypress tab and disconnect. The browser stays open.
+ */
+async function withBrowser(action) {
+    if (!debuggerUrl) {
+        throw new Error('[dappress] No browser to connect to. Is configureDappress() called in setupNodeEvents, with Cypress 13.6 or later?');
+    }
+    const browser = await puppeteer_core_1.default.connect({ browserWSEndpoint: debuggerUrl, defaultViewport: null });
+    try {
+        return await action(browser);
+    }
+    catch (error) {
+        // The browser side only gets the message, so keep the full stack in the terminal
+        console.error(error.stack || error);
+        throw error;
+    }
+    finally {
+        await focusCypressTab(browser).catch(() => { });
+        await browser.disconnect();
+    }
+}
+// MetaMask opens its own tabs and popups; Chrome throttles the Cypress tab
+// while it is in the background. The Cypress runner lives under /__/.
+async function focusCypressTab(browser) {
+    const target = browser.targets().find((candidate) => candidate.type() === 'page' && candidate.url().includes('/__/'));
+    if (target)
+        await (await target.page())?.bringToFront();
+}

package/dist/config.d.ts

@@ -0,0 +1,21 @@
+import type { DappressOptions, Network, PublicOptions, ResolvedOptions } from './types';
+export declare const DEFAULTS: {
+    metamaskVersion: string;
+    seedPhrase: string | null;
+    password: string;
+    network: Network | null;
+    backupAndSync: boolean;
+    autoSetup: boolean;
+    cache: boolean;
+    timeout: number;
+    cacheDir: string;
+};
+/**
+ * The plugin options, in order of precedence: environment variables, the
+ * Cypress `env` block (cypress.env.json), the wallet setup file
+ * (cypress/wallet.setup.ts or .js), the options given to configureDappress(),
+ * then the defaults above.
+ */
+export declare function resolveOptions(userOptions?: DappressOptions, cypressConfig?: Partial<Pick<Cypress.PluginConfigOptions, 'env' | 'projectRoot'>>): ResolvedOptions;
+/** The subset of options that is safe to expose to the browser side (no secrets). */
+export declare function publicOptions(options: ResolvedOptions): PublicOptions;

package/dist/config.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULTS = void 0;
+exports.resolveOptions = resolveOptions;
+exports.publicOptions = publicOptions;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const bip39_1 = require("@scure/bip39");
+const english_1 = require("@scure/bip39/wordlists/english");
+exports.DEFAULTS = {
+    metamaskVersion: '13.50.0',
+    // None: a new wallet is made for each run. A phrase known to others is not
+    // blank, since MetaMask restores the accounts saved for it elsewhere.
+    seedPhrase: null,
+    password: 'Tester@1234',
+    // The network cy.connectToDapp() moves the dapp onto, as a wallet_addEthereumChain parameter; none by default
+    network: null,
+    // MetaMask's backup and sync saves the accounts and contacts of a seed phrase
+    // and restores them on other installs. Off, a test's accounts don't come back.
+    backupAndSync: false,
+    // Run cy.setupMetaMask() automatically before the first test of each spec
+    autoSetup: true,
+    // Import the wallet once and reuse the profile across runs (keeps the vault under cacheDir)
+    cache: false,
+    // How long to wait for MetaMask to show a confirmation after a dapp request (ms)
+    timeout: 20000,
+    cacheDir: node_path_1.default.join(node_os_1.default.homedir(), '.cache', 'dappress'),
+};
+// A .ts file loads when the Cypress config is itself in TypeScript
+const WALLET_SETUP_FILES = ['cypress/wallet.setup.ts', 'cypress/wallet.setup.js'];
+/**
+ * The plugin options, in order of precedence: environment variables, the
+ * Cypress `env` block (cypress.env.json), the wallet setup file
+ * (cypress/wallet.setup.ts or .js), the options given to configureDappress(),
+ * then the defaults above.
+ */
+function resolveOptions(userOptions = {}, cypressConfig = {}) {
+    const env = cypressConfig.env || {};
+    const fromEnv = {
+        metamaskVersion: process.env.DAPPRESS_METAMASK_VERSION || env.DAPPRESS_METAMASK_VERSION,
+        seedPhrase: process.env.DAPPRESS_SEED_PHRASE || env.DAPPRESS_SEED_PHRASE,
+        password: process.env.DAPPRESS_PASSWORD || env.DAPPRESS_PASSWORD,
+    };
+    const options = { ...exports.DEFAULTS, ...userOptions, ...loadWalletSetup(cypressConfig.projectRoot) };
+    for (const [key, value] of Object.entries(fromEnv)) {
+        if (value)
+            options[key] = value;
+    }
+    const seedPhrase = options.seedPhrase || newWallet(options);
+    return { ...options, seedPhrase };
+}
+/** No seed phrase was given: make one for this run. It is never written anywhere. */
+function newWallet(options) {
+    console.log('[dappress] No seed phrase configured: using a new wallet for this run');
+    if (options.cache) {
+        console.warn('[dappress] The profile cache needs a seed phrase of your own: importing the wallet in this run instead');
+        options.cache = false;
+    }
+    return (0, bip39_1.generateMnemonic)(english_1.wordlist);
+}
+/** The project's wallet setup file: { seedPhrase?, network? }. */
+function loadWalletSetup(projectRoot = process.cwd()) {
+    const file = WALLET_SETUP_FILES.map((name) => node_path_1.default.join(projectRoot, name)).find((candidate) => node_fs_1.default.existsSync(candidate));
+    if (!file)
+        return {};
+    // The file is the project's, found at run time: there is nothing to import statically
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const loaded = require(file);
+    const setup = loaded.default || loaded; // `export default` or `module.exports`
+    const unknown = Object.keys(setup).filter((key) => !['seedPhrase', 'network'].includes(key));
+    if (unknown.length)
+        throw new Error(`[dappress] Unknown keys in ${node_path_1.default.basename(file)}: ${unknown.join(', ')}`);
+    return setup;
+}
+/** The subset of options that is safe to expose to the browser side (no secrets). */
+function publicOptions(options) {
+    return { metamaskVersion: options.metamaskVersion, autoSetup: options.autoSetup, network: options.network };
+}

package/dist/download.d.ts

@@ -0,0 +1,7 @@
+import type { ResolvedOptions } from './types';
+/**
+ * Download and unzip the MetaMask Chrome build for `version` into the cache.
+ * Returns the path of the unpacked extension (the folder holding manifest.json).
+ * Already cached versions are reused.
+ */
+export declare function prepareExtension({ metamaskVersion, cacheDir }: Pick<ResolvedOptions, 'metamaskVersion' | 'cacheDir'>): Promise<string>;

package/dist/download.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareExtension = prepareExtension;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = require("node:stream/promises");
+const node_stream_1 = require("node:stream");
+const extract_zip_1 = __importDefault(require("extract-zip"));
+function releaseUrl(version) {
+    return `https://github.com/MetaMask/metamask-extension/releases/download/v${version}/metamask-chrome-${version}.zip`;
+}
+function extensionDir(cacheDir, version) {
+    return node_path_1.default.join(cacheDir, 'metamask', version);
+}
+async function download(url, destination) {
+    const response = await fetch(url, { redirect: 'follow' });
+    if (!response.ok || !response.body) {
+        throw new Error(`[dappress] Could not download ${url}: HTTP ${response.status}`);
+    }
+    await node_fs_1.default.promises.mkdir(node_path_1.default.dirname(destination), { recursive: true });
+    await (0, promises_1.pipeline)(node_stream_1.Readable.fromWeb(response.body), node_fs_1.default.createWriteStream(destination));
+}
+/**
+ * Download and unzip the MetaMask Chrome build for `version` into the cache.
+ * Returns the path of the unpacked extension (the folder holding manifest.json).
+ * Already cached versions are reused.
+ */
+async function prepareExtension({ metamaskVersion, cacheDir }) {
+    const dir = extensionDir(cacheDir, metamaskVersion);
+    const manifest = node_path_1.default.join(dir, 'manifest.json');
+    if (node_fs_1.default.existsSync(manifest))
+        return dir;
+    const zipPath = node_path_1.default.join(cacheDir, 'metamask', `metamask-chrome-${metamaskVersion}.zip`);
+    if (!node_fs_1.default.existsSync(zipPath)) {
+        console.log(`[dappress] Downloading MetaMask ${metamaskVersion}…`);
+        await download(releaseUrl(metamaskVersion), zipPath);
+    }
+    console.log(`[dappress] Unpacking MetaMask ${metamaskVersion}…`);
+    await node_fs_1.default.promises.rm(dir, { recursive: true, force: true });
+    await (0, extract_zip_1.default)(zipPath, { dir });
+    if (!node_fs_1.default.existsSync(manifest)) {
+        throw new Error(`[dappress] ${zipPath} does not look like a MetaMask build: no manifest.json after extraction`);
+    }
+    return dir;
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="cypress" preserve="true" />
+import type { DappressOptions } from './types';
+export type { DappressOptions, Network, WalletSetup } from './types';
+/**
+ * Wire Dappress into a Cypress project. Call it from setupNodeEvents:
+ *
+ *   setupNodeEvents(on, config) {
+ *     return configureDappress(on, config);
+ *   }
+ *
+ * It loads the MetaMask extension into the browser Cypress launches, and
+ * registers the tasks behind the cy.* commands from 'dappress/support'.
+ */
+export declare function configureDappress(on: Cypress.PluginEvents, config: Cypress.PluginConfigOptions, userOptions?: DappressOptions): Cypress.PluginConfigOptions;

package/dist/index.js

@@ -0,0 +1,55 @@
+"use strict";
+/// <reference types="cypress" preserve="true" />
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureDappress = configureDappress;
+const config_1 = require("./config");
+const browser_1 = require("./browser");
+const download_1 = require("./download");
+const profile_1 = require("./profile");
+const actions_1 = require("./actions");
+/**
+ * Wire Dappress into a Cypress project. Call it from setupNodeEvents:
+ *
+ *   setupNodeEvents(on, config) {
+ *     return configureDappress(on, config);
+ *   }
+ *
+ * It loads the MetaMask extension into the browser Cypress launches, and
+ * registers the tasks behind the cy.* commands from 'dappress/support'.
+ */
+function configureDappress(on, config, userOptions = {}) {
+    const options = (0, config_1.resolveOptions)(userOptions, config);
+    if (config.chromeWebSecurity === false) {
+        console.warn('[dappress] chromeWebSecurity is off: MetaMask cannot start its snaps, so adding or importing an account will hang');
+    }
+    // A cached wallet gets its requests in MetaMask's popup window, which headless Chrome doesn't open
+    const usesCache = (browser) => options.cache && !browser.isHeadless;
+    // Build the wallet profile before the run, out of the time Cypress allows a browser to come up
+    on('before:run', async ({ browser }) => {
+        if (browser && usesCache(browser))
+            await (0, profile_1.prepareProfile)({ browserPath: browser.path, extensionDir: await (0, download_1.prepareExtension)(options), options });
+    });
+    on('before:browser:launch', async (browser, launchOptions) => {
+        if (browser.family !== 'chromium') {
+            throw new Error(`[dappress] MetaMask is a Chromium extension; ${browser.name} is not supported`);
+        }
+        const extensionDir = await (0, download_1.prepareExtension)(options);
+        launchOptions.extensions.push(extensionDir);
+        if (browser.isHeadless) {
+            // Cypress leaves extensions out of a headless launch, so ask Chrome directly
+            launchOptions.args.push(`--load-extension=${extensionDir}`);
+            if (options.cache)
+                console.warn('[dappress] The wallet cache needs a headed browser: importing the wallet in this run instead');
+        }
+        if (usesCache(browser)) {
+            const profileDir = await (0, profile_1.prepareProfile)({ browserPath: browser.path, extensionDir, options });
+            await (0, profile_1.installProfile)(profileDir, browser, config.isTextTerminal);
+        }
+        return launchOptions;
+    });
+    (0, browser_1.captureDebuggerUrl)(on);
+    on('task', (0, actions_1.createTasks)(options));
+    // Non-sensitive settings the browser side reads with Cypress.expose()
+    config.expose = { ...config.expose, dappress: (0, config_1.publicOptions)(options) };
+    return config;
+}

package/dist/metamask-pages.d.ts

@@ -0,0 +1,17 @@
+import type { Browser, Page } from 'puppeteer-core';
+/**
+ * MetaMask's extension id. Cypress loads its own extension in headed
+ * Chromium browsers, so the id is the one whose home page is titled "MetaMask".
+ */
+export declare function findExtensionId(browser: Browser, timeout?: number): Promise<string>;
+/** The full-screen MetaMask page, opened if it isn't already. */
+export declare function getHomePage(browser: Browser, extensionId: string): Promise<Page>;
+/** The pages open where dapp requests show up: the side panel, a popup. */
+export declare function getRequestPages(browser: Browser, extensionId: string): Promise<Page[]>;
+/**
+ * The page a dapp request is shown on. Waits for the popup to open, or takes
+ * the side panel. A popup still on its home route is one closing after the
+ * previous request, or one that hasn't routed to the request yet: skipped.
+ */
+export declare function getConfirmationPage(browser: Browser, extensionId: string, timeout: number): Promise<Page>;
+export declare function withUsableWindow(page: Page): Promise<Page>;

package/dist/metamask-pages.js

@@ -0,0 +1,143 @@
+"use strict";
+// Find MetaMask's pages in the browser Cypress launched: the full-screen home
+// page, and the surface where dapp requests show up. On Chrome that surface
+// is the side panel when it is open, and the "MetaMask Dialog" popup otherwise.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findExtensionId = findExtensionId;
+exports.getHomePage = getHomePage;
+exports.getRequestPages = getRequestPages;
+exports.getConfirmationPage = getConfirmationPage;
+exports.withUsableWindow = withUsableWindow;
+const page_helpers_1 = require("./page-helpers");
+const HOME_PATH = '/home.html';
+const CONFIRMATION_PATHS = ['/notification.html', '/sidepanel.html'];
+function extensionIdOf(url) {
+    const match = /^chrome-extension:\/\/([a-z]{32})\//.exec(url);
+    return match ? match[1] : null;
+}
+function isHomeRoute(url) {
+    return url.includes('/notification.html') && /notification\.html(#\/?)?$/.test(url);
+}
+function pagesOf(browser, extensionId, pathname) {
+    return browser.targets().filter((target) => target.type() === 'page' && target.url().startsWith(`chrome-extension://${extensionId}${pathname}`));
+}
+/**
+ * MetaMask's extension id. Cypress loads its own extension in headed
+ * Chromium browsers, so the id is the one whose home page is titled "MetaMask".
+ */
+async function findExtensionId(browser, timeout = 30000) {
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+        const ids = new Set(browser
+            .targets()
+            .map((target) => extensionIdOf(target.url()))
+            .filter((id) => id !== null));
+        for (const id of ids) {
+            if (await isMetaMask(browser, id))
+                return id;
+        }
+        await (0, page_helpers_1.sleep)(500);
+    }
+    throw new Error('[dappress] MetaMask extension not found in the browser. Is it loaded in before:browser:launch?');
+}
+async function isMetaMask(browser, extensionId) {
+    const [target] = pagesOf(browser, extensionId, HOME_PATH);
+    if (target) {
+        // A page still loading or redirecting loses its execution context while its
+        // title is read; not MetaMask yet, findExtensionId looks again
+        try {
+            const page = await pageOf(target);
+            return (await page.title()).startsWith('MetaMask');
+        }
+        catch {
+            return false;
+        }
+    }
+    const page = await browser.newPage();
+    try {
+        const response = await page.goto(`chrome-extension://${extensionId}${HOME_PATH}`, { waitUntil: 'domcontentloaded' });
+        return Boolean(response && response.ok()) && (await page.title()).startsWith('MetaMask');
+    }
+    catch {
+        return false;
+    }
+    finally {
+        await page.close();
+    }
+}
+// A target of type "page" has a page; Puppeteer types it as one that may not
+async function pageOf(target) {
+    const page = await target.page();
+    if (!page)
+        throw new Error(`[dappress] No page behind ${target.url()}`);
+    return page;
+}
+/** The full-screen MetaMask page, opened if it isn't already. */
+async function getHomePage(browser, extensionId) {
+    const [target] = pagesOf(browser, extensionId, HOME_PATH);
+    if (target)
+        return pageOf(target);
+    const page = await browser.newPage();
+    await page.goto(`chrome-extension://${extensionId}${HOME_PATH}`, { waitUntil: 'domcontentloaded' });
+    return page;
+}
+/** The pages open where dapp requests show up: the side panel, a popup. */
+async function getRequestPages(browser, extensionId) {
+    const pages = [];
+    for (const pathname of CONFIRMATION_PATHS) {
+        for (const target of pagesOf(browser, extensionId, pathname)) {
+            const page = await target.page();
+            if (page)
+                pages.push(pathname === '/notification.html' ? await withUsableWindow(page) : page);
+        }
+    }
+    return pages;
+}
+/**
+ * The page a dapp request is shown on. Waits for the popup to open, or takes
+ * the side panel. A popup still on its home route is one closing after the
+ * previous request, or one that hasn't routed to the request yet: skipped.
+ */
+async function getConfirmationPage(browser, extensionId, timeout) {
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+        for (const pathname of CONFIRMATION_PATHS) {
+            const [target] = pagesOf(browser, extensionId, pathname).filter((candidate) => !isHomeRoute(candidate.url()));
+            if (target)
+                return pathname === '/notification.html' ? withUsableWindow(await pageOf(target)) : pageOf(target);
+        }
+        await (0, page_helpers_1.sleep)(250);
+    }
+    const seen = browser
+        .targets()
+        .filter((target) => extensionIdOf(target.url()) === extensionId)
+        .map((target) => `${target.type()} ${target.url()}`)
+        .join(', ');
+    throw new Error(`[dappress] MetaMask showed no confirmation within ${timeout}ms. Did the dapp send a request? MetaMask pages seen: ${seen || 'none'}`);
+}
+// MetaMask asks Chrome for a 400x620 popup. Under Xvfb on a GitHub runner the
+// window it gets is 1x1: nothing is laid out, the pane of a confirmation that
+// must be read to the end has no height, so it can never be scrolled there and
+// its Confirm button stays disabled. The popup is given its size back first.
+const POPUP = { width: 400, height: 620 };
+async function withUsableWindow(page) {
+    const session = await page.target().createCDPSession();
+    try {
+        const { windowId, bounds } = await session.send('Browser.getWindowForTarget');
+        if (bounds.windowState === 'normal' && (bounds.width ?? 0) >= 200 && (bounds.height ?? 0) >= 200)
+            return page;
+        console.log(`[dappress] MetaMask's popup is ${bounds.width}x${bounds.height} (${bounds.windowState}); resizing it to ${POPUP.width}x${POPUP.height}`);
+        if (bounds.windowState !== 'normal')
+            await session.send('Browser.setWindowBounds', { windowId, bounds: { windowState: 'normal' } });
+        await session.send('Browser.setWindowBounds', { windowId, bounds: { ...POPUP } });
+        // Let the page lay itself out at its new size before anything is looked for in it
+        await (0, page_helpers_1.sleep)(300);
+    }
+    catch (error) {
+        console.warn(`[dappress] Could not check the popup window's size: ${error.message}`);
+    }
+    finally {
+        await session.detach().catch(() => { });
+    }
+    return page;
+}

package/dist/metamask.d.ts

@@ -0,0 +1,53 @@
+import type { Page } from 'puppeteer-core';
+import type { ConnectOptions, ResolvedOptions, TransactionOptions, WalletState } from './types';
+export declare const decisions: {
+    connectToDapp: string[];
+    rejectConnection: string[];
+    approveNewNetwork: string[];
+    rejectNewNetwork: string[];
+    approveSwitchNetwork: string[];
+    rejectSwitchNetwork: string[];
+    approveAddToken: string[];
+    rejectAddToken: string[];
+    confirmSignature: string[];
+    rejectSignature: string[];
+    confirmTransaction: string[];
+    rejectTransaction: string[];
+};
+export type Decision = keyof typeof decisions;
+/** Which screen the extension home page shows, once MetaMask has started. */
+export declare function walletState(page: Page): Promise<WalletState | 'unknown'>;
+/** Import a wallet from its seed phrase on a fresh MetaMask install. */
+export declare function onboard(page: Page, { seedPhrase, password, backupAndSync }: Pick<ResolvedOptions, 'seedPhrase' | 'password' | 'backupAndSync'>): Promise<void>;
+export declare function unlock(page: Page, { password }: Pick<ResolvedOptions, 'password'>): Promise<void>;
+/**
+ * A page that was showing the unlock form when the wallet got unlocked from
+ * another one keeps showing it, and the dapp's requests wait behind it. The
+ * password is given there too, as a user would; what follows is the wallet
+ * or a request, so only the form is watched.
+ */
+export declare function leaveUnlockForm(page: Page, { password }: Pick<ResolvedOptions, 'password'>): Promise<void>;
+/**
+ * Add an account to the wallet and select it. Yields its name, "Account N".
+ * A click that lands while the list is still settling is lost, so the button
+ * is pressed again when no account shows up.
+ */
+export declare function addAccount(page: Page): Promise<string>;
+/** Make `name` the selected account of the wallet. */
+export declare function switchAccount(page: Page, name: string): Promise<void>;
+/** Import an account from its private key and select it. Yields its name. */
+export declare function importAccount(page: Page, privateKey: string): Promise<string>;
+/** Lock the wallet from the menu of its home page. Nothing to do on a wallet already locked. */
+export declare function lock(page: Page): Promise<void>;
+/**
+ * Disconnect the site at `origin` from the wallet, on its page of the
+ * "Permissions" screen. The dapp gets an empty accountsChanged.
+ */
+export declare function disconnectSite(page: Page, origin: string): Promise<void>;
+/** The options a command took from the test: those of the commands that take any. */
+type CommandOptions = ConnectOptions & TransactionOptions;
+/** Press the button of `decision` on the confirmation shown on `page`, once it is set as `options` ask. */
+export declare function decide(decision: Decision, page: Page, timeout: number, options?: CommandOptions): Promise<void>;
+/** wallet_addEthereumChain on a network MetaMask knows behaves like a switch: either prompt may show. */
+export declare function approveNetworkChange(page: Page, timeout: number): Promise<void>;
+export {};