import { Locator, Page } from '@playwright/test';
/**
 * Chat-privacy Playwright bindings.
 *
 * Three surfaces, three groups of helpers:
 *
 *  1. **Header toggle** — the nav-bar `ChatPrivacyToggle` (`<HatGlasses />`
 *     icon-button that morphs into the "Private Mode" pill).
 *  2. **User profile** — the "Private Mode" tab in `UserProfileModal`
 *     (three radio-card options: Normal / Anonymized / Disabled).
 *  3. **Tenant admin** — the "Allow users to control chat privacy" row in
 *     the Advanced settings tab (`<Switch>`).
 *
 * All selectors target stable hooks — primarily `data-testid` plus the
 * `data-state` / `data-source` / `aria-pressed` attributes the components
 * already expose. Avoid asserting on visible copy directly (it changes);
 * the label maps below are kept for readable assertions on the rare cases
 * where copy IS the thing we want to lock.
 */
export declare const CHAT_PRIVACY_LABELS: {
    readonly toggle: {
        /** Title of the mid-session confirmation dialog. */
        readonly dialogTitle: "Enable Private Mode for this chat?";
        /** Label on the dialog's confirm button (matches both idle + busy state via regex). */
        readonly dialogConfirm: RegExp;
    };
    readonly profileTab: {
        /** Tab name in the user profile modal sidebar. */
        readonly tabName: "Private Mode";
        /** Section heading inside the tab body. */
        readonly sectionHeading: "Default Private Mode";
        /** Label text on each radio card. Kept in case the test wants to assert
         *  copy explicitly — the click + read paths use the testid instead. */
        readonly cards: {
            readonly normal: "Normal";
            readonly anonymized: "Anonymized";
            readonly disabled: "Disabled";
        };
    };
    readonly tenantToggle: {
        /** Visible row label. */
        readonly rowLabel: "Allow users to control chat privacy";
    };
};
/** The four `effective.source` values the chat-privacy resolver returns. */
export type ChatPrivacySource = 'mentor' | 'tenant' | 'user' | 'session' | 'default';
/** The user-pickable modes on the profile tab. */
export type ChatPrivacyMode = 'normal' | 'anonymized' | 'disabled';
/** `data-state` on the header toggle. */
export type ChatPrivacyToggleState = 'on' | 'off';
/**
 * Locator for the nav-bar Private-Mode toggle. The toggle is hidden below
 * the `md` breakpoint — assertions in mobile contexts should use
 * `expectChatPrivacyToggleVisible(scope, false)`.
 */
export declare function getChatPrivacyToggle(scope: Page | Locator): Locator;
export declare function expectChatPrivacyToggleVisible(scope: Page | Locator, visible: boolean): Promise<void>;
/**
 * Assert the toggle is on / off via `data-state` (driven by the resolved
 * effective mode + the local optimistic overlay).
 */
export declare function expectChatPrivacyState(scope: Page | Locator, state: ChatPrivacyToggleState): Promise<void>;
/**
 * Assert the resolved precedence-source via `data-source` (mentor / tenant
 * / user / session / default). Useful for verifying the chat-privacy-
 * effective endpoint resolved to the expected tier.
 */
export declare function expectChatPrivacySource(scope: Page | Locator, source: ChatPrivacySource): Promise<void>;
/**
 * Lock state is signalled via `aria-disabled` (the component uses
 * `aria-disabled` instead of native `disabled` so the source-aware tooltip
 * stays reachable on the locked pill).
 */
export declare function expectChatPrivacyLocked(scope: Page | Locator, locked: boolean): Promise<void>;
/**
 * Click the toggle. Covers two scenarios:
 *  - Off → on (with no user messages) → starts a fresh private session.
 *  - On (user-initiated, no user messages) → starts a fresh normal session.
 * Use `confirmEnableChatPrivacyMidSession` for the mid-conversation flow.
 */
export declare function clickChatPrivacyToggle(scope: Page | Locator): Promise<void>;
/** Locator for the AlertDialog content that the mid-session enable opens. */
export declare function getChatPrivacyConfirmDialog(scope: Page | Locator): Locator;
export declare function expectChatPrivacyConfirmDialogOpen(scope: Page | Locator, open: boolean): Promise<void>;
/**
 * Mid-conversation enable flow:
 *  1. Click the toggle (opens the confirm dialog).
 *  2. Click the "Enable Private Mode" action.
 * The session-level disable-chathistory POST is one-way per spec; the
 * helper resolves once the dialog closes after a successful confirm.
 */
export declare function confirmEnableChatPrivacyMidSession(scope: Page | Locator): Promise<void>;
/** Cancel the confirm dialog without enabling. */
export declare function cancelEnableChatPrivacyMidSession(scope: Page | Locator): Promise<void>;
/**
 * Switch to the Private Mode tab inside the user profile modal. Assumes
 * the modal is already open. The tab only appears when the tenant has
 * `allow_user_chat_privacy_control` on, so a `false` return from
 * `isPrivateModeTabVisible` is a meaningful state, not an error.
 */
export declare function isPrivateModeTabVisible(page: Page): Promise<boolean>;
export declare function switchToPrivateModeTab(page: Page): Promise<void>;
/** Locator for one of the three radio cards. */
export declare function getPrivateModeCard(scope: Page | Locator, mode: ChatPrivacyMode): Locator;
/**
 * Pick a mode by clicking its card. Resolves once the card flips into
 * the selected state via `aria-pressed="true"` — i.e. the mutation came
 * back and the local pending state caught up.
 */
export declare function selectPrivateMode(scope: Page | Locator, mode: ChatPrivacyMode): Promise<void>;
/** Assert which mode is currently selected. Uses `aria-pressed` + `data-state`. */
export declare function expectPrivateModeSelected(scope: Page | Locator, mode: ChatPrivacyMode): Promise<void>;
/** Assert every card is rendered. Useful as a "tab loaded" sanity check. */
export declare function expectPrivateModeTabReady(scope: Page | Locator): Promise<void>;
/** Locator for the tenant-wide "Allow users to control chat privacy" switch. */
export declare function getTenantChatPrivacySwitch(scope: Page | Locator): Locator;
/** Locator for the surrounding row (useful for scoping label / spinner queries). */
export declare function getTenantChatPrivacyRow(scope: Page | Locator): Locator;
export declare function expectTenantChatPrivacyVisible(scope: Page | Locator, visible: boolean): Promise<void>;
/** Assert the tenant gate's current state via `aria-checked` on the Radix switch. */
export declare function expectTenantChatPrivacyEnabled(scope: Page | Locator, enabled: boolean): Promise<void>;
/**
 * Flip the tenant gate to the desired state. Idempotent — does nothing if
 * the switch is already in the target state. Backend rejects this for
 * non-admins (403) and the component surfaces an error toast in that case.
 */
export declare function setTenantChatPrivacyEnabled(scope: Page | Locator, enabled: boolean): Promise<void>;
