import * as _playwright_test from '@playwright/test';
import { Page, Locator, PlaywrightTestConfig } from '@playwright/test';
export { expect } from '@playwright/test';
import winston from 'winston';
import { Reporter, FullConfig, Suite, TestCase, TestResult, FullResult } from '@playwright/test/reporter';
import { RuleObject } from 'axe-core';
import * as playwright_core from 'playwright-core';

interface SafeWaitForURLOptions {
    timeout?: number;
    waitUntil?: 'commit' | 'domcontentloaded' | 'load' | 'networkidle';
    maxRetries?: number;
}
/**
 * Check if the current browser is Firefox
 */
declare function isFirefox(page: Page): boolean;
/**
 * Safe wrapper around page.waitForURL that handles browser-specific navigation errors
 *
 * Firefox has stricter navigation lifecycle handling that can cause NS_BINDING_ABORTED
 * errors when multiple rapid navigations occur (React router redirects, auth redirects).
 *
 * Safari can throw "Navigation canceled by policy check" errors during cross-origin
 * navigations or when security policies interrupt the navigation flow.
 *
 * This utility:
 * 1. Uses `waitUntil: 'commit'` for Firefox (faster, avoids abort)
 * 2. Includes retry logic for NS_BINDING_ABORTED errors (Firefox)
 * 3. Handles "Navigation canceled by policy check" errors (Safari)
 * 4. Checks if URL is already correct before failing
 */
declare function safeWaitForURL(page: Page, urlPattern: string | RegExp | ((url: URL) => boolean), options?: SafeWaitForURLOptions): Promise<void>;

declare function waitForPageLoad(page: Page): Promise<void>;
declare function closeWithEsc(page: Page): Promise<void>;
type StepFn = (title: string, fn: () => unknown) => unknown;
declare const test: _playwright_test.TestType<_playwright_test.PlaywrightTestArgs & _playwright_test.PlaywrightTestOptions & {
    step: StepFn;
}, _playwright_test.PlaywrightWorkerArgs & _playwright_test.PlaywrightWorkerOptions>;
declare const retry: (action: () => Promise<void>, errorMessage: string, retryCount?: number) => Promise<void>;

declare const isJSON: (value: string) => boolean;

declare const logger: winston.Logger;

interface MailsacEmail {
    _id: string;
    from: Array<{
        address: string;
        name?: string;
    }>;
    to: Array<{
        address: string;
        name?: string;
    }>;
    subject: string;
    inbox: string;
    received: string;
    size: number;
    attachments: string[];
    ip: string;
    via: string;
    folder: string;
    labels: string[];
    read: boolean;
    rtls: boolean;
    originalInbox: string;
    spam: boolean;
}
declare class MailsacClient {
    private apiKey;
    private baseUrl;
    constructor(apiKey: string);
    /**
     * Get all emails for a specific inbox
     * @param inbox - The inbox address (e.g., 'test@mailsac.com' or just 'test')
     */
    getEmails(inbox: string): Promise<MailsacEmail[]>;
    /**
     * Get a specific email by ID
     * @param email - The email address
     * @param messageId - The ID of the email to fetch
     */
    getEmailById(email: string, messageId: string): Promise<string>;
    /**
     * Delete a specific email by ID
     * @param emailId - The ID of the email to delete
     */
    deleteEmail(emailId: string): Promise<any>;
}

declare class AuthFlowBuilder {
    flow: string;
    idp: string;
    authHost: string;
    constructor(flow?: string, idp?: string, authHost?: string);
    run(page: Page, step: StepFn, username: string, password: string, hostUrl: string, authUrl: string, postLoginUrlMatcher?: (url: URL) => boolean): Promise<void>;
    usernamePasswordFlow(page: Page, username: string, password: string, hostUrl: string, authUrl: string, postLoginUrlMatcher?: (url: URL) => boolean): Promise<void>;
    magicLinkFlow(page: Page): Promise<void>;
    ssoFlow(page: Page, username: string, password: string, hostUrl: string, authUrl: string): Promise<void>;
    directSsoFlow(page: Page, step: StepFn, username: string, password: string, hostUrl: string, authUrl: string): Promise<void>;
}

interface SignUpCredentials {
    email: string;
    password: string;
}
declare function signUpWithEmailAndPassword(page: Page, authHost: string, postSignUpUrl: string, credentials?: SignUpCredentials, alreadyInSignupPage?: boolean): Promise<void>;
declare function loginWithEmailAndPassword(page: Page, username: string, password: string, hostUrl: string, postLoginUrlMatcher?: (url: URL) => boolean): Promise<void>;
declare function loginWithMicrosoftIdp(page: Page, username: string, password: string): Promise<void>;
declare function canChatWithEmbedMentor(page: Page, openChatButton: Locator): Promise<void>;
declare function getMentorIdFromUrl(url: string): string | null;

interface AuthSetupConfig {
    /** The app's host URL (e.g., https://mentor.example.com) */
    hostUrl: string;
    /** The auth service host URL (e.g., https://auth.example.com) */
    authHost: string;
    /** App name used in the login redirect URL (e.g., 'mentor', 'skills') */
    appName: string;
    /** Function to match the post-login URL to confirm authentication succeeded */
    postLoginUrlMatcher: (url: URL) => boolean;
    /** Auth flow type. Defaults to reading AUTH_FLOW env var or 'username_password' */
    authFlow?: 'username_password' | 'magic_link' | 'sso' | 'direct_sso';
    /** Auth IDP name for SSO flows */
    authIdp?: string;
}
/**
 * Creates a Playwright setup test function for authentication.
 * Use this as the test body in your auth.setup.ts file:
 *
 * ```ts
 * import { test as setup } from '@iblai/iblai-js/playwright';
 * import { createAuthSetup } from '@iblai/iblai-js/playwright';
 *
 * setup('authenticate', createAuthSetup({
 *   hostUrl: process.env.MENTOR_NEXTJS_HOST || '',
 *   authHost: process.env.AUTH_HOST || '',
 *   appName: 'mentor',
 *   postLoginUrlMatcher: (url) => url.href.includes('/platform/'),
 * }));
 * ```
 */
declare function createAuthSetup(config: AuthSetupConfig): ({ browser, step }: {
    browser: any;
    step: any;
}, testInfo: any) => Promise<void>;

declare class CustomReporter implements Reporter {
    onBegin(config: FullConfig, suite: Suite): void;
    onTestBegin(test: TestCase): void;
    onTestEnd(test: TestCase, result: TestResult): void;
    onTimeout(timeout: number): void;
    onEnd(result: FullResult): Promise<{
        status?: FullResult['status'];
    } | undefined | void> | void;
    onStdOut(chunk: string | Buffer, test: void | TestCase, result: void | TestResult): void;
    onStdErr(chunk: string | Buffer, test: void | TestCase, result: void | TestResult): void;
}

/**
 * Wait for a page to be fully ready (DOM complete + brief delay for lazy rendering)
 */
declare function waitForPageReady(page: Page, timeout?: number): Promise<void>;
/**
 * Check if the current user is an admin by reading localStorage
 */
declare function checkAdminStatus(page: Page): Promise<boolean>;
/**
 * Wait for an element to be fully stable (attached, visible, not animating)
 */
declare function waitForElementStable(page: Page, locator: Locator, timeout?: number): Promise<Locator>;
/**
 * Click an element with retry logic and stability checks
 */
declare function reliableClick(page: Page, locator: Locator, timeout?: number, maxRetries?: number): Promise<void>;
/**
 * Fill an input element with retry logic, clearing first and verifying the value
 */
declare function reliableFill(page: Page, locator: Locator, value: string, timeout?: number, maxRetries?: number): Promise<void>;
/**
 * Wait for a dialog element to be visible and its content loaded
 */
declare function waitForDialogReady(page: Page, dialogLocator: Locator, timeout?: number): Promise<Locator>;
/**
 * Select a date from a calendar component, navigating months if needed
 */
declare function selectDateFromCalendar(page: Page, dialogLocator: Locator, targetDate: Date, timeout?: number): Promise<void>;
/**
 * Run axe-core accessibility checks against a page
 */
declare function expectNoAccessibilityViolations(page: Page): Promise<void>;
/**
 * Run axe-core accessibility checks against visible dialogs
 */
declare function expectNoAccessibilityViolationsOnDialogs(page: Page, rules?: RuleObject, exclude?: string[]): Promise<void>;

declare function inviteUserTest(page: Page, inviteModal: Locator): Promise<void>;
declare function navigateToAccountComponent(page: Page, profileBtn: Locator): Promise<Locator>;
declare function navigateToDataReports(page: Page): Promise<void>;
declare function shouldDisplayReportCards(page: Page, REPORT_CARDS: {
    name: string;
    ariaLabel: string;
    description: string;
    expectsCsvEditor: boolean;
}[]): Promise<void>;
declare function shouldOpenCSVEditorDialog(page: Page): Promise<void>;
declare function shouldDisplayCSVInEditableTableFormat(page: Page): Promise<void>;
declare function shouldAllowEditingCellValuesInCSVEditor(page: Page): Promise<void>;
declare function shouldAddNewRowWhenClickingAddRowButton(page: Page): Promise<void>;
declare function shouldSaveEditedCSVAndTriggerDownload(page: Page): Promise<void>;
declare function shouldCloseCSVEditorWithoutSavingWhenClickingCancel(page: Page): Promise<void>;
declare function shouldCloseCSVEditorWhenClickingCloseButton(page: Page): Promise<void>;
declare function shouldVerifyCSVEditorDialogAccessibility(page: Page): Promise<void>;
declare function shouldOpenCSVEditorForUserMetadataReport(page: Page): Promise<void>;
declare function shouldDirectlyDownloadChatHistoryReportWithoutCSVEditor(page: Page): Promise<void>;
declare function shouldDisableOtherDownloadButtonsWhileGeneratingReport(page: Page): Promise<void>;
declare function shouldShowCombiningReportsDialog(page: Page): Promise<void>;
declare function shouldCancelCombiningReports(page: Page): Promise<void>;
declare function shouldHaveCombinedReportDataTestIds(page: Page): Promise<void>;
declare function shouldCombineRecommendationReports(page: Page): Promise<void>;

type AuthFlowType = 'username_password' | 'magic_link' | 'sso' | 'direct_sso';
interface EnvConfig {
    skillHost: string;
    authHost: string;
    analyticsHost: string;
    mentorHost: string;
    mentorNextjsHost: string;
    authNextjsHost: string;
    playwrightUsername: string;
    playwrightPassword: string;
    inviteUsername: string;
    inviteUserPassword: string;
    authFlow: AuthFlowType;
    authIdp: string;
    enableStripeTest: boolean;
    iblMentorDisabledTabs: string;
    embedUrl: string;
    wcagRange: string;
}
/**
 * Create an environment configuration object from process.env with optional overrides.
 * Each app can call this with their specific defaults.
 */
declare function createEnvConfig(overrides?: Partial<EnvConfig>): EnvConfig;

interface ReportDownloadOptions {
    /** Base URL of the SPA (e.g. https://mentor.ibl.ai) */
    baseUrl: string;
    /** Platform key extracted from or expected in the URL */
    platformKey: string;
    /** Report name extracted from or expected in the URL */
    reportName: string;
    /** Timeout for waiting on phase transitions (default: 60000ms) */
    timeout?: number;
}
/**
 * Build the expected report download page URL.
 * Format: <baseUrl>/reports/<platformKey>/<reportName>
 */
declare function buildReportUrl(baseUrl: string, platformKey: string, reportName: string): string;
/**
 * Parse platform_key and report_name from the current page URL.
 * Expected format: .../reports/<platform_key>/<report_name>
 */
declare function parseReportUrlParams(url: string): {
    platformKey: string;
    reportName: string;
} | null;
/**
 * Navigate to the report download page and verify the URL matches the expected format.
 */
declare function navigateToReportDownload(page: Page, options: ReportDownloadOptions): Promise<void>;
/**
 * Verify the report download page is showing the "Preparing" phase.
 */
declare function verifyPreparingPhase(page: Page, options?: {
    timeout?: number;
}): Promise<void>;
/**
 * Wait for and verify the report transitions to the "downloading" phase.
 */
declare function verifyDownloadingPhase(page: Page, options?: {
    timeout?: number;
}): Promise<void>;
/**
 * Wait for and verify the report transitions to the "done" phase.
 */
declare function verifyDonePhase(page: Page, options?: {
    timeout?: number;
}): Promise<void>;
/**
 * Wait for and verify the report transitions to the "error" phase.
 */
declare function verifyErrorPhase(page: Page, options?: {
    timeout?: number;
}): Promise<void>;
/**
 * Verify the "Back Home" button is visible and click it.
 */
declare function clickBackHome(page: Page): Promise<void>;
/**
 * Click the "Download Again" button (only visible in done phase).
 * Skips silently if the button is not visible.
 */
declare function clickDownloadAgain(page: Page): Promise<boolean>;
/**
 * Click the manual download link (only visible in downloading phase).
 */
declare function clickManualDownloadLink(page: Page): Promise<void>;
/**
 * Full flow: navigate to report download page and wait for download to complete.
 * Falls back to verifying the error phase if the download does not succeed.
 * Returns the resulting phase: 'done' or 'error'.
 */
declare function waitForReportDownload(page: Page, options: ReportDownloadOptions): Promise<'done' | 'error'>;

/**
 * Check if the Memory tab is visible in the profile modal.
 * Returns true if the tab exists and is visible, false otherwise.
 */
declare function isMemoryTabVisible(page: Page): Promise<boolean>;
/**
 * Switch to the Memory tab in the profile modal.
 * Assumes the profile modal is already open and the Memory tab is visible.
 */
declare function switchToMemoryTab(page: Page): Promise<void>;
/**
 * Verify that Memory tab settings section is visible with both toggles.
 */
declare function verifyMemoryTabSettings(page: Page): Promise<void>;
/**
 * Verify that the "My Memories" section is visible with Add Memory button.
 */
declare function verifyMemoryTabMemoriesList(page: Page): Promise<void>;
/**
 * Open the Add Memory dialog from the Memory tab.
 * Assumes the Memory tab is active.
 */
declare function openAddMemoryDialog(page: Page): Promise<Locator>;
/**
 * Toggle a memory setting switch and verify the state changes.
 * Returns the new checked state.
 */
declare function toggleMemorySwitch(page: Page, switchName: RegExp | string): Promise<boolean>;
/**
 * Add a memory via the Add Memory dialog.
 * Opens the dialog, fills content, saves, and waits for dialog to close.
 */
declare function addMemory(page: Page, content: string): Promise<void>;
/**
 * Delete the first visible memory in the list.
 * Hovers to reveal the delete button, then clicks it.
 */
declare function deleteFirstMemory(page: Page): Promise<void>;
/**
 * Delete a specific memory by matching its content text.
 * Finds the memory item containing the text, hovers to reveal
 * the delete button, and clicks it.
 */
declare function deleteMemoryByContent(page: Page, content: string): Promise<void>;
/**
 * @deprecated Use `deleteFirstMemory` instead. Archive was renamed to Delete.
 */
declare const archiveFirstMemory: typeof deleteFirstMemory;
/**
 * @deprecated Use `deleteMemoryByContent` instead. Archive was renamed to Delete.
 */
declare const archiveMemoryByContent: typeof deleteMemoryByContent;
/**
 * Get the count of visible memory items in the list.
 * Returns 0 if the empty state is shown.
 */
declare function getMemoryCount(page: Page): Promise<number>;
/**
 * Verify that a memory with the given content text exists in the list.
 */
declare function verifyMemoryExists(page: Page, content: string): Promise<void>;
/**
 * Verify that a memory with the given content text does NOT exist in the list.
 */
declare function verifyMemoryNotExists(page: Page, content: string): Promise<void>;

/**
 * Navigate to the Audit tab within the Analytics section.
 * Assumes the user is already on the analytics page (any tab).
 */
declare function navigateToAuditLog(page: Page): Promise<void>;
/**
 * Verify the audit log table is visible with correct headers.
 */
declare function verifyAuditLogTableVisible(page: Page): Promise<void>;
/**
 * Get the number of rows currently displayed in the audit log table.
 * Returns 0 if no table body rows are found.
 */
declare function getAuditLogRowCount(page: Page): Promise<number>;
/**
 * Verify that audit log entries contain expected data structure
 * (person name in first cell, action description in second, timestamp in third).
 */
declare function verifyAuditLogEntryStructure(page: Page): Promise<void>;
/**
 * Verify the empty state is displayed when there are no audit log entries.
 */
declare function verifyAuditLogEmptyState(page: Page): Promise<void>;
/**
 * Verify the 403 permission error state is displayed.
 */
declare function verifyAuditLogPermissionError(page: Page): Promise<void>;
/**
 * Verify the generic error state is displayed.
 */
declare function verifyAuditLogGenericError(page: Page): Promise<void>;
/**
 * Verify the loading spinner is displayed while audit logs are being fetched.
 */
declare function verifyAuditLogLoading(page: Page): Promise<void>;
/**
 * Wait for the audit log data to finish loading.
 * Waits for either table data, empty state, or error state to appear.
 */
declare function waitForAuditLogDataLoaded(page: Page, timeout?: number): Promise<void>;
/**
 * Filter audit log entries by action type.
 * @param action - One of 'All Actions', 'Create', 'Update', or 'Delete'
 */
declare function filterByAction(page: Page, action: 'All Actions' | 'Create' | 'Update' | 'Delete'): Promise<void>;
/**
 * Filter audit log entries by actor/person using the search combobox.
 * @param actorName - The username to filter by, or empty string to clear the filter
 */
declare function filterByActor(page: Page, actorName: string): Promise<void>;
/**
 * Get the list of actors available in the actor filter dropdown.
 * Opens the dropdown, reads the options, then closes it.
 */
declare function getAvailableActors(page: Page): Promise<string[]>;
/**
 * Open the date range picker and select a date range.
 * @param fromDate - Start date to select
 * @param toDate - End date to select
 */
declare function filterByDateRange(page: Page, fromDate: Date, toDate: Date): Promise<void>;
/**
 * Clear the date range filter by clicking the date picker and resetting.
 */
declare function clearDateRangeFilter(page: Page): Promise<void>;
/**
 * Get the current pagination info text (e.g., "Showing 1 to 20 of 45 results").
 * Returns null if pagination is not visible.
 */
declare function getPaginationInfo(page: Page): Promise<string | null>;
/**
 * Navigate to the next page of audit log results.
 */
declare function goToNextPage(page: Page): Promise<void>;
/**
 * Navigate to the previous page of audit log results.
 */
declare function goToPreviousPage(page: Page): Promise<void>;
/**
 * Navigate to the first page of audit log results.
 */
declare function goToFirstPage(page: Page): Promise<void>;
/**
 * Navigate to the last page of audit log results.
 * Finds the highest numbered page link in the pagination.
 */
declare function goToLastPage(page: Page): Promise<void>;
/**
 * Navigate to a specific page number by clicking its page button.
 */
declare function goToPage(page: Page, pageNumber: number): Promise<void>;
/**
 * Verify the current page is highlighted/active in pagination.
 */
declare function verifyCurrentPage(page: Page, expectedPage: number): Promise<void>;
/**
 * Check if the next page button is disabled (i.e., we're on the last page).
 */
declare function isOnLastPage(page: Page): Promise<boolean>;
/**
 * Check if the previous page button is disabled (i.e., we're on the first page).
 */
declare function isOnFirstPage(page: Page): Promise<boolean>;
/**
 * Full workflow: Navigate to audit log tab, wait for data to load,
 * and verify the table is visible. Use this as a test setup helper.
 */
declare function navigateToAuditLogAndWaitForData(page: Page): Promise<void>;
/**
 * Verify audit log entries are displayed after applying action filter.
 * Returns the row count after filtering.
 */
declare function filterByActionAndVerify(page: Page, action: 'All Actions' | 'Create' | 'Update' | 'Delete'): Promise<number>;
/**
 * Verify audit log entries are displayed after applying actor filter.
 * Returns the row count after filtering.
 */
declare function filterByActorAndVerify(page: Page, actorName: string): Promise<number>;

interface PlatformConfig {
    /** Platform name used in project naming (e.g., 'mentornextjs', 'skills') */
    name: string;
    /** Devices to test on. Defaults to all 4 desktop browsers */
    devices?: string[];
    /** Dependencies for this platform (e.g., ['setup']) */
    dependencies?: string[];
    /** Additional test file patterns to match */
    otherTestMatch?: string[];
    /** Test files to ignore */
    testIgnore?: string[];
}
interface CreatePlaywrightConfigOptions {
    /** Directory containing test files (relative to config file) */
    testDir?: string;
    /** Devices to use across all platforms. Defaults to Chrome, Firefox, Safari, Edge */
    devices?: string[];
    /** Platform configurations */
    platforms: PlatformConfig[];
    /** Path to custom reporter module (relative to config file). Defaults to './custom-reporter' */
    customReporterPath?: string;
    /** Additional cleanup or post-test projects */
    extraProjects?: Array<{
        name: string;
        devices?: string[];
        dependencies: string[];
        testMatch: string[];
    }>;
}
/** Extract browser key from device name (e.g., 'Desktop Chrome' -> 'chrome') */
declare function getBrowserKey(deviceName: string): string;
/**
 * Generate per-browser setup projects for Playwright authentication.
 * Each browser gets its own auth setup project (setup-chrome, setup-firefox, etc.)
 */
declare function generateBrowserSetupProjects(devicesToUse: string[]): {
    name: string;
    testMatch: RegExp;
    use: {
        viewport: playwright_core.ViewportSize;
        userAgent: string;
        deviceScaleFactor: number;
        isMobile: boolean;
        hasTouch: boolean;
        defaultBrowserType: "chromium" | "firefox" | "webkit";
    };
}[];
/**
 * Generate a Playwright project config for a platform + device combination.
 */
declare function generateProjectConfig(platform: string, deviceName: string, dependencies?: string[], otherTestMatch?: string[], testIgnoreMatch?: string[]): {
    name: string;
    testMatch: string[];
    use: {
        storageState: string;
        viewport: playwright_core.ViewportSize;
        userAgent: string;
        deviceScaleFactor: number;
        isMobile: boolean;
        hasTouch: boolean;
        defaultBrowserType: "chromium" | "firefox" | "webkit";
    };
    dependencies: string[];
    testIgnore: string[];
};
/**
 * Create a complete Playwright configuration for an IBL.ai application.
 *
 * Usage:
 * ```ts
 * import { createPlaywrightConfig } from '@iblai/iblai-js/playwright';
 *
 * export default createPlaywrightConfig({
 *   platforms: [
 *     { name: 'skills', dependencies: ['setup'], otherTestMatch: ['**skills/*\/*.spec.ts'] },
 *   ],
 * });
 * ```
 */
declare function createPlaywrightConfig(options: CreatePlaywrightConfigOptions): PlaywrightTestConfig;

export { AuthFlowBuilder, CustomReporter, MailsacClient, addMemory, archiveFirstMemory, archiveMemoryByContent, buildReportUrl, canChatWithEmbedMentor, checkAdminStatus, clearDateRangeFilter, clickBackHome, clickDownloadAgain, clickManualDownloadLink, closeWithEsc, createAuthSetup, createEnvConfig, createPlaywrightConfig, deleteFirstMemory, deleteMemoryByContent, expectNoAccessibilityViolations, expectNoAccessibilityViolationsOnDialogs, filterByAction, filterByActionAndVerify, filterByActor, filterByActorAndVerify, filterByDateRange, generateBrowserSetupProjects, generateProjectConfig, getAuditLogRowCount, getAvailableActors, getBrowserKey, getMemoryCount, getMentorIdFromUrl, getPaginationInfo, goToFirstPage, goToLastPage, goToNextPage, goToPage, goToPreviousPage, inviteUserTest, isFirefox, isJSON, isMemoryTabVisible, isOnFirstPage, isOnLastPage, logger, loginWithEmailAndPassword, loginWithMicrosoftIdp, navigateToAccountComponent, navigateToAuditLog, navigateToAuditLogAndWaitForData, navigateToDataReports, navigateToReportDownload, openAddMemoryDialog, parseReportUrlParams, reliableClick, reliableFill, retry, safeWaitForURL, selectDateFromCalendar, shouldAddNewRowWhenClickingAddRowButton, shouldAllowEditingCellValuesInCSVEditor, shouldCancelCombiningReports, shouldCloseCSVEditorWhenClickingCloseButton, shouldCloseCSVEditorWithoutSavingWhenClickingCancel, shouldCombineRecommendationReports, shouldDirectlyDownloadChatHistoryReportWithoutCSVEditor, shouldDisableOtherDownloadButtonsWhileGeneratingReport, shouldDisplayCSVInEditableTableFormat, shouldDisplayReportCards, shouldHaveCombinedReportDataTestIds, shouldOpenCSVEditorDialog, shouldOpenCSVEditorForUserMetadataReport, shouldSaveEditedCSVAndTriggerDownload, shouldShowCombiningReportsDialog, shouldVerifyCSVEditorDialogAccessibility, signUpWithEmailAndPassword, switchToMemoryTab, test, toggleMemorySwitch, verifyAuditLogEmptyState, verifyAuditLogEntryStructure, verifyAuditLogGenericError, verifyAuditLogLoading, verifyAuditLogPermissionError, verifyAuditLogTableVisible, verifyCurrentPage, verifyDonePhase, verifyDownloadingPhase, verifyErrorPhase, verifyMemoryExists, verifyMemoryNotExists, verifyMemoryTabMemoriesList, verifyMemoryTabSettings, verifyPreparingPhase, waitForAuditLogDataLoaded, waitForDialogReady, waitForElementStable, waitForPageLoad, waitForPageReady, waitForReportDownload };
export type { AuthFlowType, AuthSetupConfig, CreatePlaywrightConfigOptions, EnvConfig, PlatformConfig, ReportDownloadOptions, SafeWaitForURLOptions, SignUpCredentials, StepFn };
