@thefehr/foundry-playwright 0.2.1

package/dist/helpers.js

@@ -0,0 +1,414 @@
+import { expect } from "@playwright/test";
+import path from "path";
+import fs from "fs";
+/**
+ * Loads the verification registry from verified-versions.json.
+ */
+export function getVerificationRegistry() {
+    try {
+        const registryPath = path.join(process.cwd(), "verified-versions.json");
+        if (fs.existsSync(registryPath)) {
+            return JSON.parse(fs.readFileSync(registryPath, "utf8"));
+        }
+    }
+    catch (e) {
+        console.warn("[getVerificationRegistry] Failed to load registry:", e);
+    }
+    return [];
+}
+/**
+ * Helper to automatically set up a Foundry VTT instance before all tests in a file.
+ * Reduces boilerplate in spec files.
+ * @param test The Playwright test object.
+ * @param config Foundry setup configuration.
+ */
+export function useFoundry(test, config = {}) {
+    test.beforeAll(async ({ browser }) => {
+        const page = await browser.newPage();
+        const { foundrySetup } = await import("./auth.js");
+        await foundrySetup(page, config);
+        await page.close();
+    });
+}
+/**
+ * Validates the current Foundry/System/Module stack against the registry.
+ */
+export async function validateStack(page, targetVersion) {
+    const registry = getVerificationRegistry();
+    if (registry.length === 0)
+        return;
+    const current = await page.evaluate(() => {
+        const g = window.game;
+        const foundry = g.version || g.release?.generation;
+        const system = g.system.id;
+        const systemVersion = g.system.version;
+        const modules = Array.from(g.modules.values())
+            .filter((m) => m.active && m.id !== "fake-module")
+            .map((m) => ({ id: m.id, version: m.version }));
+        return { foundry, system, systemVersion, modules };
+    });
+    const fvtt = String(targetVersion || current.foundry);
+    // Find entries for this FVTT + System
+    const matches = registry.filter((e) => fvtt.startsWith(e.fvtt) && e.system === current.system);
+    if (matches.length === 0) {
+        console.warn(`\n[VALIDATION] ⚠️ Untested Stack: FVTT ${fvtt} + ${current.system} is not in the verified registry.`);
+        return "untested";
+    }
+    // Check for specific version match or incompatibility
+    const exactMatch = matches.find((m) => m.systemVersion === current.systemVersion);
+    if (exactMatch) {
+        if (exactMatch.status === "incompatible") {
+            console.error(`\n[VALIDATION] ❌ INCOMPATIBLE STACK DETECTED!\n` +
+                `FVTT ${fvtt} + ${current.system} v${current.systemVersion} is marked as INCOMPATIBLE.\n` +
+                `Notes: ${exactMatch.notes}\n`);
+            return "incompatible";
+        }
+        console.log(`[VALIDATION] ✅ Stable Stack: FVTT ${fvtt} + ${current.system} v${current.systemVersion} is verified.`);
+        return "stable";
+    }
+    console.warn(`\n[VALIDATION] ⚠️ Untested Version: FVTT ${fvtt} + ${current.system} is verified, but not with version v${current.systemVersion}.`);
+    return "untested";
+}
+/**
+ * Aggressively removes Foundry VTT tours and overlays from the DOM and localStorage.
+ * @param page The Playwright Page object.
+ */
+export async function disableTour(page) {
+    const removalScript = () => {
+        const selectors = [
+            ".tour-overlay",
+            "#tour-overlay",
+            ".joyride-overlay",
+            ".foundry-tour-overlay",
+            ".tour-dot",
+            ".tour-step-anchor",
+            ".nue-overlay",
+            ".nue-container",
+            "foundry-guide",
+        ];
+        // 1. Remove elements from DOM
+        const remove = () => {
+            selectors.forEach((s) => {
+                document.querySelectorAll(s).forEach((el) => {
+                    el.style.display = "none";
+                    el.style.pointerEvents = "none";
+                    el.remove();
+                });
+            });
+            // Also remove pointer-events from body if blocked
+            if (document.body.classList.contains("tour-open") ||
+                document.body.style.pointerEvents === "none") {
+                document.body.classList.remove("tour-open", "nue-open");
+                document.body.style.pointerEvents = "auto";
+            }
+        };
+        remove();
+        // 2. Inject override style
+        if (!document.getElementById("foundry-playwright-no-tour")) {
+            const style = document.createElement("style");
+            style.id = "foundry-playwright-no-tour";
+            style.innerHTML = `
+        .tour-overlay, #tour-overlay, .joyride-overlay, .foundry-tour-overlay, .nue-overlay, .nue-container, foundry-guide, .tour-step-anchor, .tour-dot { 
+          display: none !important; 
+          visibility: hidden !important; 
+          pointer-events: none !important; 
+        }
+      `;
+            document.head.appendChild(style);
+        }
+        // 3. Set localStorage to mark tours as completed
+        try {
+            const tourProgress = { core: { backupsOverview: 1, welcome: 1, setup: 1 } };
+            window.localStorage.setItem("core.tourProgress", JSON.stringify(tourProgress));
+        }
+        catch { }
+        // 4. Mutation Observer to keep them gone
+        const observer = new MutationObserver(remove);
+        observer.observe(document.body, { childList: true, subtree: true });
+    };
+    // Run as init script for new pages
+    await page.addInitScript(removalScript);
+    // Run immediately on the current page
+    await page.evaluate(removalScript).catch(() => null);
+}
+/**
+ * Navigates to a specific tab by name or ID.
+ * @param page The Playwright Page object.
+ * @param tabName The logical name or data-tab value of the tab.
+ */
+export async function switchTab(page, tabName) {
+    // Map logical names to data-tab values for robustness
+    const tabMap = {
+        "Game Worlds": "worlds",
+        Worlds: "worlds",
+        "Game Systems": "systems",
+        Systems: "systems",
+        "Add-on Modules": "modules",
+        Modules: "modules",
+        Configuration: "config",
+        "Update Software": "update",
+    };
+    const dataTabName = tabMap[tabName] || tabName.toLowerCase();
+    console.log(`[switchTab] Switching to tab: ${tabName}`);
+    // 1. Try robust data-tab selectors first (V13/V14 common patterns)
+    const selectors = [
+        `[data-tab="${dataTabName}"]`,
+        `[data-action="tab"][data-tab="${dataTabName}"]`,
+        `nav.tabs [data-tab="${dataTabName}"]`,
+        `nav.tabs [data-action="tab"][data-tab="${dataTabName}"]`,
+        `button[role="tab"][data-tab="${dataTabName}"]`,
+        `[data-application-part] [data-tab="${dataTabName}"]`,
+        // Fallbacks if mapping failed but text matches
+        `nav.tabs [data-tab]:has-text("${tabName}")`,
+        `[data-action="tab"]:has-text("${tabName}")`,
+        `.tabs .item:has-text("${tabName}")`,
+        `button[role="tab"]:has-text("${tabName}")`,
+    ];
+    let tab = null;
+    for (const selector of selectors) {
+        const candidate = page.locator(selector).first();
+        if ((await candidate.count()) > 0 && (await candidate.isVisible())) {
+            console.log(`[switchTab] Found candidate with selector: ${selector}`);
+            tab = candidate;
+            break;
+        }
+    }
+    if (!tab) {
+        console.log(`[switchTab] No robust selector matched for "${tabName}". Falling back to text search.`);
+        tab = page
+            .locator(`*:visible:has-text("${tabName}")`)
+            .filter({ hasNot: page.locator("option") })
+            .first();
+    }
+    await expect(tab).toBeVisible({ timeout: 15000 });
+    // Get the data-tab attribute if it exists to wait for content later
+    const dataTab = (await tab.getAttribute("data-tab")) || (await tab.getAttribute("data-action")) || dataTabName;
+    // Force click via evaluate to bypass overlays, then wait for transition
+    await tab.evaluate((el) => el.click());
+    // Wait for the tab to be active or for the target content to be visible
+    await page
+        .waitForFunction(({ name, dataTab }) => {
+        const activeTab = document.querySelector(".tabs .item.active, [data-action='tab'].active, [role='tab'][aria-selected='true'], .active[data-tab], .tab.active, [data-application-part].active, nav h2.active, .navigation h2.active, h2.active");
+        const isTabActive = activeTab?.textContent?.trim().includes(name) ||
+            (dataTab && activeTab?.getAttribute("data-tab") === dataTab);
+        // Also check if a section with that data-tab is now visible
+        const contentVisible = dataTab
+            ? document.querySelector(`section.tab[data-tab="${dataTab}"].active, .tab[data-tab="${dataTab}"].active, [data-application-part="${dataTab}"].active`) !== null ||
+                document.querySelector(`#setup-packages-${dataTab}.active`) !== null ||
+                document.querySelector(`#setup-packages-${dataTab}:not([style*="display: none"])`) !==
+                    null
+            : true;
+        return isTabActive || contentVisible;
+    }, { name: tabName, dataTab }, { timeout: 10000 })
+        .catch(() => null);
+    console.log(`[switchTab] Tab "${tabName}" clicked and verified.`);
+}
+/**
+ * Navigates to the Systems tab and opens the installation dialog.
+ * @param page The Playwright Page object.
+ */
+export async function openSystemInstallDialog(page) {
+    const { getSetupAdapter } = await import("./setup/index.js");
+    const adapter = await getSetupAdapter(page);
+    return await adapter.openSystemInstallDialog(page);
+}
+/**
+ * Navigates to the Modules tab and opens the installation dialog.
+ * @param page The Playwright Page object.
+ */
+export async function openModuleInstallDialog(page) {
+    const { getSetupAdapter } = await import("./setup/index.js");
+    const adapter = await getSetupAdapter(page);
+    return await adapter.openModuleInstallDialog(page);
+}
+/**
+ * Installs a system from a manifest URL.
+ * @param page The Playwright Page object.
+ * @param manifestUrl The URL to the system.json manifest.
+ */
+export async function installSystemFromManifest(page, manifestUrl) {
+    console.log(`[installSystemFromManifest] Installing from: ${manifestUrl}`);
+    const dialog = await openSystemInstallDialog(page);
+    await installFromManifest(page, dialog, manifestUrl);
+}
+/**
+ * Installs a module from a manifest URL.
+ * @param page The Playwright Page object.
+ * @param manifestUrl The URL to the module.json manifest.
+ */
+export async function installModuleFromManifest(page, manifestUrl) {
+    console.log(`[installModuleFromManifest] Installing from: ${manifestUrl}`);
+    const dialog = await openModuleInstallDialog(page);
+    await installFromManifest(page, dialog, manifestUrl);
+}
+/**
+ * Shared helper for filling manifest URL and clicking install in a dialog.
+ */
+async function installFromManifest(page, dialog, manifestUrl) {
+    // Foundry's manifest input is usually at the bottom
+    const manifestInput = dialog
+        .locator('input#install-package-manifestUrl, input[name="manifestURL"], input:not(#world-filter):not(#system-filter):not(#module-filter):not([type="checkbox"]):not([type="radio"])')
+        .first();
+    await manifestInput.fill(manifestUrl);
+    const installBtn = dialog
+        .locator('button[data-action="installPackage"], button:has-text("Install"), button.bright')
+        .filter({ visible: true })
+        .last();
+    await installBtn.evaluate((el) => el.click());
+    // Use the progress bar / notification wait logic
+    await page
+        .waitForFunction(() => {
+        const progress = document.querySelector(".notification.info, .progress-bar, .loading");
+        return !progress;
+    })
+        .catch(() => null);
+    // Close the dialog if it's still open
+    const closeBtn = dialog.locator('button[data-action="close"], .header-button.close');
+    if (await closeBtn.isVisible()) {
+        await closeBtn.click();
+    }
+}
+/**
+ * Waits for the Foundry VTT game object to be fully initialized and ready.
+ * @param page The Playwright Page object.
+ */
+export async function waitForReady(page) {
+    console.log("[waitForReady] Waiting for game to be ready...");
+    await page.waitForFunction(() => window.game?.ready, { timeout: 60000 });
+}
+/**
+ * Executes a function after ensuring a log has been emitted via FP_VERIFY.
+ * @param page The Playwright Page object.
+ * @param key The log key to wait for.
+ * @param predicate A function to test the log data.
+ * @param extraData Optional extra data to pass to the predicate.
+ */
+export async function verifyResult(page, key, predicate, extraData, options = {}) {
+    const { timeout = 15000 } = options;
+    console.log(`[verifyResult] Waiting for log "${key}" matching predicate...`);
+    // We must stringify the predicate to pass it into evaluate
+    const predicateStr = predicate.toString();
+    await page
+        .waitForFunction(({ key, predicateStr, extraData }) => {
+        try {
+            const predicate = new Function(`return ${predicateStr}`)();
+            const logs = window.FP_VERIFY?.logs[key] || [];
+            return logs.some((l) => predicate(l, extraData));
+        }
+        catch {
+            return false;
+        }
+    }, { key, predicateStr, extraData }, { timeout })
+        .catch((err) => {
+        console.error(`[verifyResult] Timeout waiting for log "${key}".`);
+        throw err;
+    });
+}
+/**
+ * Waits for a specific actor flag to be set to a value.
+ */
+export async function waitForActorFlag(page, actorName, flag, value) {
+    await verifyResult(page, "actor-update", (data) => {
+        return data.name === actorName && data.delta.flags?.["fake-module"]?.[flag] === value;
+    });
+}
+/**
+ * Waits for specific actor data to be updated.
+ */
+export async function waitForActorData(page, actorName, path, value) {
+    await verifyResult(page, "actor-update", (data) => {
+        const current = data.delta.system?.[path];
+        return data.name === actorName && current === value;
+    });
+}
+/**
+ * Waits for a game setting to be set.
+ */
+export async function waitForSetting(page, module, key, value) {
+    // Note: Settings updates are usually logged or checked directly
+    await page.waitForFunction(({ module, key, value }) => {
+        return window.game.settings.get(module, key) === value;
+    }, { module, key, value });
+}
+/**
+ * Clears the FP_VERIFY log registry.
+ */
+export async function clearFPVerify(page) {
+    await page.evaluate(() => {
+        if (window.FP_VERIFY_RESET)
+            window.FP_VERIFY_RESET();
+    });
+}
+/**
+ * Handles the Foundry VTT reload dialog.
+ */
+export async function handleReload(page) {
+    const dialog = page
+        .locator("dialog, foundry-app, .window-app")
+        .filter({ hasText: /Reload/i })
+        .last();
+    await expect(dialog).toBeVisible();
+    await dialog.locator('button:has-text("Yes")').first().click();
+    await page.waitForLoadState("networkidle");
+    await waitForReady(page);
+}
+/**
+ * Fills a field in a visible dialog.
+ */
+export async function fillDialogField(page, label, value) {
+    const dialog = page.locator("dialog, foundry-app, .window-app").filter({ visible: true }).last();
+    const input = dialog.locator(`input[name="${label}"], input[placeholder*="${label}" i]`).first();
+    await input.fill(value);
+}
+/**
+ * Performs the full module activation flow for a list of modules.
+ */
+export async function handleModuleActivationFlow(page, moduleIds) {
+    const { foundrySetup } = await import("./auth.js");
+    await foundrySetup(page, { moduleId: moduleIds, createWorld: false, deleteIfExists: false });
+}
+/**
+ * Simulates a drop from a compendium onto a target.
+ */
+export async function dropCompendiumItem(page, targetSelector, pack, itemId) {
+    const data = {
+        type: "Item",
+        uuid: `Compendium.${pack}.Item.${itemId}`,
+    };
+    await simulateFoundryDrop(page, targetSelector, data);
+}
+/**
+ * Simulates a Foundry VTT drag-and-drop event.
+ */
+export async function simulateFoundryDrop(page, targetSelector, data) {
+    console.log(`[simulateFoundryDrop] Dropping ${data.type} onto ${targetSelector}...`);
+    await page.evaluate(({ selector, data }) => {
+        const selectors = selector.split(",").map((s) => s.trim());
+        let el = null;
+        for (const sel of selectors) {
+            const cleanSel = sel.replace(/:has-text\([^)]*\)/g, "");
+            try {
+                const matches = document.querySelectorAll(cleanSel);
+                if (sel.includes(":has-text")) {
+                    const textMatch = sel.match(/:has-text\("([^"]*)"\)/);
+                    const searchText = textMatch ? textMatch[1] : "";
+                    el = Array.from(matches).find((m) => m.textContent?.includes(searchText));
+                }
+                else {
+                    el = matches[0];
+                }
+            }
+            catch {
+                // Ignore selector errors
+            }
+            if (el)
+                break;
+        }
+        if (!el)
+            throw new Error(`Target ${selector} not found.`);
+        const dataTransfer = new DataTransfer();
+        dataTransfer.setData("text/plain", JSON.stringify(data));
+        el.dispatchEvent(new DragEvent("dragover", { dataTransfer, bubbles: true, cancelable: true }));
+        el.dispatchEvent(new DragEvent("drop", { dataTransfer, bubbles: true, cancelable: true }));
+    }, { selector: targetSelector, data });
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./fixtures.js";
+export { disableTour, switchTab, openSystemInstallDialog, openModuleInstallDialog, installSystemFromManifest, installModuleFromManifest, waitForActorFlag, waitForActorData, waitForSetting, clearFPVerify, simulateFoundryDrop, verifyResult, waitForReady, handleReload, fillDialogField, handleModuleActivationFlow, dropCompendiumItem, useFoundry, } from "./helpers.js";
+export * from "./types/index.js";
+export * from "./auth.js";
+export * from "./state.js";
+export * from "./systems/index.js";
+export * from "./ui/index.js";
+export * from "./docker.js";
+export * from "./canvas.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from "./fixtures.js";
+export { disableTour, switchTab, openSystemInstallDialog, openModuleInstallDialog, installSystemFromManifest, installModuleFromManifest, waitForActorFlag, waitForActorData, waitForSetting, clearFPVerify, simulateFoundryDrop, verifyResult, waitForReady, handleReload, fillDialogField, handleModuleActivationFlow, dropCompendiumItem, useFoundry, } from "./helpers.js";
+export * from "./types/index.js";
+export * from "./auth.js";
+export * from "./state.js";
+export * from "./systems/index.js";
+export * from "./ui/index.js";
+export * from "./docker.js";
+export * from "./canvas.js";

package/dist/setup/base.d.ts

@@ -0,0 +1,97 @@
+import { FoundryPage } from "../types/index.js";
+/**
+ * Interface for version-specific Foundry VTT setup logic.
+ */
+export interface SetupAdapter {
+    /** The major Foundry VTT version this adapter is for (e.g., 13, 14). */
+    version: number;
+    /**
+     * Switches between tabs on the setup screen.
+     * @param page The Foundry VTT Page object.
+     * @param tabName The logical name of the tab (e.g., "Worlds", "Systems").
+     */
+    switchTab(page: FoundryPage, tabName: string): Promise<void>;
+    /**
+     * Handles the End User License Agreement screen if it appears.
+     * @param page The Foundry VTT Page object.
+     */
+    handleEULA(page: FoundryPage): Promise<void>;
+    /**
+     * Handles the License Key Activation screen if it appears.
+     * @param page The Foundry VTT Page object.
+     * @param licenseKey The license key to activate (optional).
+     */
+    handleLicenseActivation(page: FoundryPage, licenseKey?: string): Promise<void>;
+    /**
+     * Installs a game system from the manifest list.
+     * @param page The Foundry VTT Page object.
+     * @param systemId The ID of the system to install.
+     * @param systemLabel The human-readable label of the system.
+     */
+    installSystem(page: FoundryPage, systemId: string, systemLabel: string): Promise<void>;
+    /**
+     * Installs one or more add-on modules from the manifest list.
+     * @param page The Foundry VTT Page object.
+     * @param moduleIds The ID(s) of the module(s) to install.
+     */
+    installModules(page: FoundryPage, moduleIds: string[]): Promise<void>;
+    /**
+     * Installs a game system from a direct manifest URL.
+     * @param page The Foundry VTT Page object.
+     * @param manifestUrl The URL to the system.json manifest.
+     */
+    installSystemFromManifest(page: FoundryPage, manifestUrl: string): Promise<void>;
+    /**
+     * Installs a module from a direct manifest URL.
+     * @param page The Foundry VTT Page object.
+     * @param manifestUrl The URL to the module.json manifest.
+     */
+    installModuleFromManifest(page: FoundryPage, manifestUrl: string): Promise<void>;
+    /**
+     * Opens the system installation dialog.
+     * @param page The Foundry VTT Page object.
+     */
+    openSystemInstallDialog(page: FoundryPage): Promise<any>;
+    /**
+     * Opens the module installation dialog.
+     * @param page The Foundry VTT Page object.
+     */
+    openModuleInstallDialog(page: FoundryPage): Promise<any>;
+    /**
+     * Creates a new game world.
+     * @param page The Foundry VTT Page object.
+     * @param worldId The ID for the new world.
+     * @param systemLabel The human-readable label of the system to use.
+     * @param systemId The unique ID of the game system to use.
+     */
+    createWorld(page: FoundryPage, worldId: string, systemLabel: string, systemId: string): Promise<void>;
+    /**
+     * Deletes a game world if it exists.
+     * @param page The Foundry VTT Page object.
+     * @param worldId The ID of the world to delete.
+     */
+    deleteWorldIfExists(page: FoundryPage, worldId: string): Promise<void>;
+}
+/**
+ * Interface for version-specific logic within the Foundry VTT game environment.
+ */
+export interface GameAdapter {
+    /** The major Foundry VTT version this adapter is for. */
+    version: number;
+    createDocument(page: FoundryPage, documentName: string, data: any, options: any): Promise<any>;
+    updateDocument(page: FoundryPage, uuid: string, delta: any): Promise<any>;
+    deleteDocuments(page: FoundryPage, documentName: string, ids: string[], options: any): Promise<void>;
+    getDocuments(page: FoundryPage, collection: string, query: any): Promise<any[]>;
+}
+/**
+ * Base implementation of GameAdapter with shared logic for most versions.
+ */
+export declare abstract class BaseGameAdapter implements GameAdapter {
+    protected page?: FoundryPage | undefined;
+    abstract version: number;
+    constructor(page?: FoundryPage | undefined);
+    createDocument(page: FoundryPage, documentName: string, data: any, options: any): Promise<any>;
+    updateDocument(page: FoundryPage, uuid: string, delta: any): Promise<any>;
+    deleteDocuments(page: FoundryPage, documentName: string, ids: string[], options: any): Promise<void>;
+    getDocuments(page: FoundryPage, collection: string, query: Record<string, any>): Promise<any[]>;
+}

package/dist/setup/base.js

@@ -0,0 +1,53 @@
+/**
+ * Base implementation of GameAdapter with shared logic for most versions.
+ */
+export class BaseGameAdapter {
+    page;
+    constructor(page) {
+        this.page = page;
+    }
+    async createDocument(page, documentName, data, options) {
+        return page.evaluate(async ({ documentName, data, options }) => {
+            const collectionName = (documentName.toLowerCase() + "s");
+            const collection = window.game[collectionName];
+            const cls = collection?.documentClass || window[documentName];
+            if (!cls)
+                throw new Error(`Document class ${documentName} not found.`);
+            return await cls.create(data, options);
+        }, { documentName, data, options });
+    }
+    async updateDocument(page, uuid, delta) {
+        return page.evaluate(async ({ uuid, delta }) => {
+            const doc = window.fromUuidSync ? window.fromUuidSync(uuid) : null;
+            if (doc)
+                return await doc.update(delta);
+            for (const collection of Object.values(window.game.collections || {})) {
+                const match = collection.getName ? collection.getName(uuid) : null;
+                if (match)
+                    return await match.update(delta);
+            }
+            throw new Error(`Document ${uuid} not found.`);
+        }, { uuid, delta });
+    }
+    async deleteDocuments(page, documentName, ids, options) {
+        await page.evaluate(async ({ documentName, ids, options }) => {
+            const cls = window[documentName];
+            if (!cls)
+                throw new Error(`Document class ${documentName} not found.`);
+            await cls.deleteDocuments(ids, options);
+        }, { documentName, ids, options });
+    }
+    async getDocuments(page, collection, query) {
+        return page.evaluate(({ collection, query }) => {
+            const coll = window.game[collection];
+            if (!coll)
+                return [];
+            // Simple query matching
+            return coll
+                .filter((d) => {
+                return Object.entries(query).every(([k, v]) => d[k] === v);
+            })
+                .map((d) => d.toObject?.() || d.toJSON());
+        }, { collection, query });
+    }
+}

package/dist/setup/index.d.ts

@@ -0,0 +1,14 @@
+import { FoundryPage } from "../types/index.js";
+import { SetupAdapter, GameAdapter } from "./base.js";
+/**
+ * Detects the Foundry VTT version and returns the appropriate setup adapter.
+ * Prioritizes explicit version input from parameters or environment variables.
+ */
+export declare function getSetupAdapter(page: FoundryPage, versionOverride?: string | number): Promise<SetupAdapter>;
+/**
+ * Detects the Foundry VTT version and returns the appropriate game adapter.
+ */
+export declare function getGameAdapter(page: FoundryPage, versionOverride?: string | number): Promise<GameAdapter>;
+export * from "./base.js";
+export * from "./v13.js";
+export * from "./v14.js";