import * as _playwright_test from '@playwright/test';
import { Page, APIRequestContext, Response, APIResponse, Fixtures, PlaywrightWorkerArgs, PlaywrightWorkerOptions, PlaywrightTestArgs, PlaywrightTestOptions, Browser, BrowserContext, FrameLocator, Locator, CDPSession } from '@playwright/test';
import * as mailosaur_lib_models from 'mailosaur/lib/models';
import MailosaurClient from 'mailosaur';
import { I18nPlaywrightFixture } from 'playwright-i18next-fixture';
import { TFunction } from 'i18next';
import { Protocol } from 'playwright-core/types/protocol';
import * as ts_toolbelt_out_Function_Curry from 'ts-toolbelt/out/Function/Curry';
import * as playwright_core from 'playwright-core';
import { Secret, TOTP } from 'otpauth';

interface InterceptMultipleResponsesParams {
    responseUrl: string;
    times: number;
    baseUrl: string;
    customPageContext: Page | undefined;
    timeout: number;
    responseStatus: number;
}
type GenericCallback = (...params: any[]) => Promise<unknown> | unknown;
interface ExecuteRecursivelyParams {
    callback: GenericCallback;
    condition: GenericCallback;
    timeout: number;
}
type ExecuteRecursively = (params: ExecuteRecursivelyParams) => Promise<void>;
interface VerifySuccessToastParams {
    message: string;
    closeAfterVerification: boolean;
}
type ConditionProps = Record<string, string>[];
type FilterProps = Record<string, ConditionProps>;
type ParamFilters = FilterProps[];
type BasicTypesInterface = Record<string, number | string | boolean>;
type ParamProps = Record<string, number | string | boolean | ParamFilters>;
type HttpMethods = "get" | "patch" | "post" | "put" | "delete";
interface ApiRequestProps {
    url: string;
    failOnStatusCode?: boolean;
    headers?: BasicTypesInterface;
    data?: Record<string, unknown>;
    method?: HttpMethods;
    params?: ParamProps;
}
interface WaitForPageLoadParams {
    visiblityTimeout: number;
    retryTimeout: number;
    customPageContext: Page | undefined;
}
type ApiRequest = (props: ApiRequestProps & Record<string, unknown>) => Promise<APIResponse | undefined>;
interface FieldValue {
    field: string;
    value: string;
}
type VerifyFieldValue = (values: FieldValue | FieldValue[]) => Promise<void> | Promise<void[]>;
interface SelectOptionFromDropdownParams {
    selectValueContainer: string;
    selectMenu: string;
    value: string;
    options?: Partial<{
        visiblityTimeout: number;
        textAssertionTimeout: number;
        retryTimeout: number;
    }>;
}
declare class CustomCommands {
    page: Page;
    responses: string[];
    request: APIRequestContext;
    baseURL: string | undefined;
    constructor(page: Page, request: APIRequestContext, baseURL?: string | undefined);
    interceptMultipleResponses: ({ responseUrl, responseStatus, times, baseUrl, customPageContext, timeout, }?: Partial<InterceptMultipleResponsesParams>) => Promise<Response[]>;
    private recursiveMethod;
    executeRecursively: ExecuteRecursively;
    verifySuccessToast: ({ message, closeAfterVerification, }?: Partial<VerifySuccessToastParams>) => Promise<void>;
    reloadAndWait: (requestCount: number, customPageContext?: Page, interceptMultipleResponsesProps?: Partial<Omit<InterceptMultipleResponsesParams, "times">>) => Promise<void>;
    waitForPageLoad: ({ visiblityTimeout, customPageContext, }: WaitForPageLoadParams) => Promise<void>;
    apiRequest: ApiRequest;
    selectOptionFromDropdown: ({ selectValueContainer, selectMenu, value, options, }: SelectOptionFromDropdownParams) => Promise<void>;
    verifyFieldValue: VerifyFieldValue;
}

interface EmailContentParams {
    email: string;
    subjectSubstring?: string;
    timeout?: number;
    receivedAfter?: Date;
}
type FetchOtpFromEmail = (props: EmailContentParams) => Promise<string | undefined>;
declare class MailosaurUtils {
    mailosaur: MailosaurClient;
    serverId: string;
    constructor(mailosaur: MailosaurClient);
    getEmailContent: ({ email, subjectSubstring, timeout, receivedAfter, }: EmailContentParams) => Promise<mailosaur_lib_models.Message>;
    fetchOtpFromEmail: FetchOtpFromEmail;
    generateRandomMailosaurEmail: () => string;
}

interface CustomFixture {
    neetoPlaywrightUtilities: CustomCommands;
    page: Page;
    mailosaur: MailosaurClient;
    mailosaurUtils: MailosaurUtils;
}
type Commands = Fixtures<CustomFixture, PlaywrightWorkerArgs & PlaywrightWorkerOptions, PlaywrightTestArgs & PlaywrightTestOptions, PlaywrightWorkerArgs & PlaywrightWorkerOptions>;
declare const commands: Commands;

declare const generateStagingData: (product?: string) => {
    firstName: string;
    lastName: string;
    otp: number;
    domain: string;
    currentUserName: string;
    businessName: string;
    subdomainName: string;
    email: string;
};

declare const _default: _playwright_test.TestType<_playwright_test.PlaywrightTestArgs & _playwright_test.PlaywrightTestOptions & Browser, _playwright_test.PlaywrightWorkerArgs & _playwright_test.PlaywrightWorkerOptions>;

declare const i18nFixture: Fixtures<I18nPlaywrightFixture, PlaywrightWorkerArgs & PlaywrightWorkerOptions, PlaywrightTestArgs & PlaywrightTestOptions, PlaywrightWorkerArgs & PlaywrightWorkerOptions>;

type EmbedType = "inline" | "floatingPopup" | "elementClick";
type GetByRoleOptions = {
    checked?: boolean;
    disabled?: boolean;
    exact?: boolean;
    expanded?: boolean;
    includeHidden?: boolean;
    level?: number;
    name?: string | RegExp;
    pressed?: boolean;
    selected?: boolean;
};
type InlineCustomizationOptions = {
    embedHeight: string;
    embedWidth: string;
    embedDivContainerId: string;
};
type VerifyInlineCustomizationParams = {
    headingTestId: string;
    inlineEmbedInterceptParams: Partial<InterceptMultipleResponsesParams>;
    customizationOptions: InlineCustomizationOptions;
};
type FloatingPopupCustomizationOptions = {
    buttonText: string;
    buttonColorHex: string;
    buttonTextColorHex: string;
    buttonPosition: "Bottom left" | "Bottom right";
};
type ElementClickCustomizationOptions = {
    customId: string;
};
type initializeEmbedPageParams = {
    embedType: EmbedType;
    embedCode: string;
    customElementText?: string;
};
type EmbedBasePageConstructorParams = {
    context: BrowserContext;
    page: Page;
    neetoPlaywrightUtilities: CustomCommands;
    appName: string;
};
declare class EmbedBase {
    context: BrowserContext;
    page: Page;
    neetoPlaywrightUtilities: CustomCommands;
    appName: string;
    t: TFunction;
    embedTestPage: Page;
    embedTestPageType: EmbedType;
    embeddedFrame: FrameLocator;
    filePath: string;
    codeBlock: Locator;
    previewTab: Locator;
    constructor({ context, page, neetoPlaywrightUtilities, appName, }: EmbedBasePageConstructorParams);
    initializeEmbedPage: ({ embedType, embedCode, customElementText, }: initializeEmbedPageParams) => Promise<Page>;
    closeEmbedModalAndPage: () => Promise<void>;
    clickOnPopupButton: (popUpButtonSelectorOptions: GetByRoleOptions) => Promise<void>;
    copyEmbedScript: ({ embedLabel }: {
        embedLabel: string;
    }) => Promise<string>;
    selectEmbedType: (embedLabel: string) => Promise<void>;
    verifyInlineCustomization: ({ headingTestId, inlineEmbedInterceptParams, customizationOptions, }: VerifyInlineCustomizationParams) => Promise<void>;
    verifyFloatingPopupCustomization: (customizationOptions: FloatingPopupCustomizationOptions) => Promise<void>;
    verifyElementClickCustomization: (customizationOptions: ElementClickCustomizationOptions) => Promise<void>;
    expectMultipleTextsInCodeblock: (containTextOptions: [
        string | RegExp,
        string | RegExp,
        ...(string | RegExp)[]
    ]) => Promise<void>;
}

interface HelpAndProfilePageInitializerProps {
    page: Page;
    neetoPlaywrightUtilities: CustomCommands;
    chatApiBaseURL: string;
    kbDocsBaseURL: string;
    changelogBaseURL: string;
}
declare class HelpAndProfilePage {
    page: Page;
    neetoPlaywrightUtilities: CustomCommands;
    chatApiBaseURL: string;
    kbDocsBaseURL: string;
    changelogBaseURL: string;
    neetoChatWidget: Locator;
    neetoChatFrame: FrameLocator;
    neetoChatSpinner: Locator;
    t: TFunction;
    profileSectionButton: Locator;
    constructor({ page, neetoPlaywrightUtilities, chatApiBaseURL, kbDocsBaseURL, changelogBaseURL, }: HelpAndProfilePageInitializerProps);
    private hoverOnBody;
    openHelpCenterV2: () => Promise<void>;
    private openLiveChatAndVerify;
    openAndVerifyChatWidgetV2: () => Promise<void>;
    openAndVerifyHelpArticlesV2: () => Promise<void>;
    private openChangelogPaneV2;
    openAndVerifyChangelogV2: () => Promise<void>;
    private formatKeyboardShortcut;
    openAndVerifyKeyboardShortcutsPaneV2: (productShortcuts: {
        description: string;
        sequence: string;
    }[], osPlatform?: "mac" | "windows") => Promise<void>;
    openAppSwitcherAndVerifyV2: () => Promise<void>;
    private openAuthLinkAndVerify;
    verifyProfileAndOrganizationLinksV2: () => Promise<void>;
    verifyLogoutV2: () => Promise<void>;
}

type Integration = "dailyco" | "github" | "google-calendar" | "google-analytics" | "google-sheets" | "microsoft-teams" | "neeto-chat" | "neeto-crm" | "slack" | "twilio" | "whereby" | "zapier" | "zoom";
type IntegrationStatus = "connected" | "disconnected";
type PartialInterceptMultipleResponsesParams$1 = Partial<InterceptMultipleResponsesParams>;
interface IntegrationBaseParams {
    page: Page;
    neetoPlaywrightUtilities: CustomCommands;
    integration: Integration;
    connectedHeader?: string;
    connectHeader?: string;
    pageloaderTimeout?: number;
    integrationRouteIndex?: string;
    integrationRouteResponsesParams?: PartialInterceptMultipleResponsesParams$1;
}
declare class IntegrationBase {
    readonly page: Page;
    readonly neetoPlaywrightUtilities: CustomCommands;
    readonly t: TFunction;
    readonly integration: Integration;
    readonly integrationCard: Locator;
    readonly connectHeader: string;
    readonly connectedHeader: string;
    pageloaderTimeout: number;
    integrationRouteIndex: string;
    integrationRouteResponsesParams: PartialInterceptMultipleResponsesParams$1;
    constructor({ page, neetoPlaywrightUtilities, integration, connectHeader, connectedHeader, pageloaderTimeout, integrationRouteIndex, integrationRouteResponsesParams, }: IntegrationBaseParams);
    disconnect: (interceptMultipleResponsesParams?: PartialInterceptMultipleResponsesParams$1) => Promise<void>;
    connect: (skipGoTo?: boolean) => Promise<void>;
    verifyIntegrationStatus: (status?: IntegrationStatus) => Promise<void>;
    clickOnIntegrationCard: () => Promise<void>;
    gotoIntegrationIndex: () => Promise<void>;
}

type AsyncNoArgsFunction = () => Promise<void>;
type RedirectUrl = string | RegExp | ((url: URL) => boolean);
type PartialInterceptMultipleResponsesParams = Partial<InterceptMultipleResponsesParams>;
type UpdateConfigureSlackChannelParams = {
    newSlackChannel: string;
    interceptMultipleResponsesParams?: PartialInterceptMultipleResponsesParams;
    refreshInterceptMultipleResponsesParams?: PartialInterceptMultipleResponsesParams;
    refreshChannelList?: boolean;
};
type SlackPageParams = {
    page: Page;
    neetoPlaywrightUtilities: CustomCommands;
    integrationRouteIndex?: string;
};
declare class SlackPage extends IntegrationBase {
    slackWebappPage: Page;
    slackWebappPageDataQa: (dataQa: string | [string, string]) => Locator;
    constructor({ page, neetoPlaywrightUtilities, integrationRouteIndex, }: SlackPageParams);
    connectAndVerifyIntegration: (redirectUrl: RedirectUrl, customSteps?: AsyncNoArgsFunction, channelToConfigure?: string) => Promise<void>;
    disconnectAndVerifyIntegration: () => Promise<void>;
    updateConfigureSlackChannel: ({ newSlackChannel, interceptMultipleResponsesParams, refreshInterceptMultipleResponsesParams, refreshChannelList, }: UpdateConfigureSlackChannelParams) => Promise<void>;
    clickOnChannelListRefreshButton: (refreshInterceptMultipleResponsesParams?: PartialInterceptMultipleResponsesParams) => Promise<void>;
    loginToSlackWebapp: (slackWebappPage: Page, customCredentials?: Record<"workspace" | "loginPassword" | "loginEmail", string | undefined>) => Promise<void>;
    logoutFromSlackWebApp: () => Promise<void>;
    goToSlackChannel: (slackChannel: string) => Promise<void>;
    createNewSlackChannel: ({ channelName, kind, }: {
        channelName: string;
        kind?: "public" | "private" | undefined;
    }) => Promise<void>;
    deleteSlackChannel: (channel: string) => Promise<void>;
}

interface WebhooksPageParams {
    page: Page;
    request: APIRequestContext;
    neetoPlaywrightUtilities: CustomCommands;
    context: BrowserContext;
}
type CallbackFunction = (args: Record<string, unknown>) => void;
interface VerifyWebhookResponseParams extends Record<string, unknown> {
    callback?: CallbackFunction;
    webhookToken: string;
}
interface VerifyWebhookDeliveriesParams extends Record<string, unknown> {
    callback: CallbackFunction;
}
interface VerifyWebhookDeliveryByEventParams extends Record<string, unknown> {
    event: string;
    callbackToVerifyDeliveries: (args: Record<string, unknown>) => void;
}
declare class WebhooksPage {
    page: Page;
    request: APIRequestContext;
    context: BrowserContext;
    neetoPlaywrightUtilities: CustomCommands;
    t: TFunction;
    constructor({ page, request, neetoPlaywrightUtilities, context, }: WebhooksPageParams);
    getWebhookURL: () => Promise<{
        webhookSiteURL: string;
        webhookToken: string | undefined;
    }>;
    addWebhook: ({ webhookSiteURL }: {
        webhookSiteURL: string;
    }) => Promise<void>;
    verifyLatestWebhookResponse: ({ callback, webhookToken, ...otherParams }: VerifyWebhookResponseParams) => Promise<void>;
    verifyWebhookDeliveries: ({ callback, ...otherParams }: VerifyWebhookDeliveriesParams) => Promise<void>;
    verifyWebhookDeliveryByEvent: ({ event, callbackToVerifyDeliveries, ...fieldsToBeVerified }: VerifyWebhookDeliveryByEventParams) => Promise<void>;
}

interface CreateOrganizationProps {
    email: string;
    businessName: string;
    subdomainName: string;
    firstName: string;
    lastName: string;
    appName: string;
}
declare class OrganizationPage {
    page: Page;
    neetoPlaywrightUtilities: CustomCommands;
    constructor(page: Page, neetoPlaywrightUtilities: CustomCommands);
    baseUrlGenerator: (appName: string) => string;
    createOrganization: ({ email, businessName, subdomainName, firstName, lastName, appName, }: CreateOrganizationProps) => Promise<void>;
    setupOrganization: (product: string) => Promise<void>;
    updateSubdomainIfExists: (appName: string) => Promise<void>;
}

declare class SidebarSection {
    page: Page;
    neetoPlaywrightUtilities: CustomCommands;
    t: TFunction;
    constructor(page: Page, neetoPlaywrightUtilities: CustomCommands);
    clickOnSubLink: (label: string) => Promise<void>;
    clickOnGoBackButton: (label: string) => Promise<void>;
}

declare const ENVIRONMENT: {
    development: string;
    staging: string;
    review: string;
};
declare const IS_STAGING_ENV: boolean;
declare const STORAGE_STATE = "./e2e/auth/user.json";
declare const GLOBAL_TRANSLATIONS_PATTERN = "../node_modules/@bigbinary/**/translations/en.json";
declare const PROJECT_TRANSLATIONS_PATH = "../app/javascript/src/translations/en.json";
declare const CREDENTIALS: {
    name: string;
    email: string;
    password: string;
};
declare const OTP_EMAIL_PATTERN = "is your login code";
declare const SLACK_DEFAULT_CHANNEL = "general";

declare const USER_AGENTS: {
    windows: string;
    mac: string;
};

declare const BASE_URL = "/api/v1";
declare const NEETO_AUTH_BASE_URL: (subdomain?: string) => string;
declare const ROUTES: {
    neetoAuthSignup: string;
    neetoAuth: string;
    loginLink: string;
    profile: string;
    myProfile: string;
    authSettings: string;
    webhooks: string;
    login: string;
    signup: string;
    subdomainAvailability: string;
    countries: string;
    neetoApps: string;
    teamMembers: {
        all: string;
        bulkUpdate: string;
        index: string;
        show: (id: string) => string;
    };
};
declare const API_ROUTES: {
    teamMembers: {
        all: string;
        bulkUpdate: string;
        index: string;
        show: (id: string) => string;
    };
};
declare const THIRD_PARTY_ROUTES: {
    webhooks: {
        site: string;
    };
    slack: {
        loginWithPassword: (workspace: string) => string;
    };
};

declare const networkConditions: Record<"Slow 3G" | "Fast 3G" | "No Throttling", Protocol.Network.emulateNetworkConditionsParameters>;

declare const COMMON_SELECTORS: {
    copyButton: string;
    spinner: string;
    subheaderText: string;
    alertTitle: string;
    alertModalMessage: string;
    alertModalSubmitButton: string;
    checkbox: string;
    checkboxLabel: string;
    dropdownContainer: string;
    dropdownIcon: string;
    heading: string;
    paneBody: string;
    paneHeader: string;
    profileSidebar: string;
    selectOption: (label: string) => string;
    radioLabel: (embedLabel: string) => string;
    toastMessage: string;
    toastCloseButton: string;
    windowAlert: string;
    body: string;
    toastIcon: string;
    paneModalCrossIcon: string;
    inputField: string;
    alertConfirmationText: string;
    alertCancelButton: string;
    alertModalCrossIcon: string;
    saveChangesButton: string;
    cancelButton: string;
    inputFieldError: string;
    selectDropDownError: string;
    subTitleHeading: string;
    noDataTitle: string;
    noDataDescription: string;
    backdrop: string;
    menuBarHeading: string;
    dropdownWrapper: string;
    toggleButton: string;
    tooltip: string;
    articlePageTitle: string;
    tabItem: string;
    labelInputError: string;
    urlInputError: string;
    noDataPrimaryButton: string;
    modalHeader: string;
    nameInputError: string;
    selectContainer: string;
    selectValueContainer: string;
    dropdownMenu: string;
    sidebarToggle: string;
    subheader: string;
    settingsLink: string;
    ticketFieldTextInput: (label: string | number) => string;
    appSwitcherButton: string;
    appSwitcherWrapper: string;
    tableSpinner: string;
    pageLoader: string;
    homeButton: string;
    neetoUiSwitch: string;
    floatingActionMenuButton: string;
    columnsDropdownContainer: string;
    columnsDropdownButton: string;
    breadcrumbHeader: string;
    header: string;
    sidebarSubLink: (label: string) => string;
    sidebarGoBackButton: (label: string) => string;
};

declare const NEETO_EDITOR_SELECTORS: {
    boldOption: string;
    italicOption: string;
    underlineOption: string;
    strikeOption: string;
    codeBlockOption: string;
    highlightOption: string;
    linkInput: string;
    linkSubmitButton: string;
    commandList: (index: number) => string;
    imageUploadUrlSubmitButton: string;
    imageUploadUrlInputTextField: string;
    uploadInput: string;
    editorMenuBarWrapper: string;
    undoOption: string;
    redoOption: string;
    imageWrapper: string;
    contentField: string;
    addLinkButton: string;
    addLinkTextField: string;
    addURLTextField: string;
    submitLinkButton: string;
};

declare const NEETO_FILTERS_SELECTORS: {
    emailSelectContainer: string;
    filterPaneHeading: string;
    neetoFiltersEmailBlock: string;
    neetoFiltersRoleBlock: string;
    neetoFiltersBarClearButton: string;
    neetoFiltersNameFilterField: string;
    neetoFilterNameBlock: string;
    roleSelectContainer: string;
    filterButton: string;
    filtersClearButton: string;
    filterDoneButton: string;
    filteredMembersCount: string;
    allMenubarBlock: string;
    filtersEmailFilter: string;
    paneModalCrossIcon: string;
};

declare const HELP_CENTER_SELECTORS: {
    helpButton: string;
    documentationButton: string;
    keyboardShortcutButton: string;
    chatButton: string;
    whatsNewButton: string;
    whatsNewWidgetInfo: string;
    whatsNewWidgetCloseButton: string;
    keyboardShortcutPaneHeading: string;
    keyboardShortcutPaneCrossIcon: string;
};

declare const LOGIN_SELECTORS: {
    appleAuthenticationButton: string;
    emailTextField: string;
    googleAuthenticationButton: string;
    githubAuthenticationButton: string;
    loginViaEmailButton: string;
    passwordTextField: string;
    rememberMeCheckBox: string;
    submitButton: string;
    twitterAuthenticationButton: string;
};

declare const MEMBER_SELECTORS: {
    membersTab: string;
    newButton: string;
    continueButton: string;
    submitButton: string;
    searchTextField: string;
    deactivatedAgentsButton: string;
    activatedMembersButton: string;
    columnCheckBox: string;
    roleLabel: (role: string) => string;
    dropDownIcon: string;
    editButton: string;
    menuBarHeading: string;
    activateOrDeactivateMember: string;
    columnsButton: string;
    columnsDropdownContainer: string;
    emailDropdownItemLabel: string;
    roleDropdownItemLabel: string;
    inviteStatusDropdownItemLabel: string;
    heading: string;
    activateButton: string;
    deactivateButton: string;
    rolesButton: string;
    statusTag: string;
};
declare const MEMBER_FORM_SELECTORS: {
    emailTextField: string;
    firstNameTextField: string;
    lastNameTextField: string;
    emailInput: string;
    emailErrorField: string;
    cancelButton: string;
};

declare const ROLES_SELECTORS: {
    newButton: string;
    proceedButton: string;
    cancelButton: string;
    tableHeaderRoleName: string;
    nameTextField: string;
    searchTextField: string;
    updateRolePaneHeading: string;
    updateRoleCancelButton: string;
    descriptionTextField: string;
    permissionCategoryTitle: string;
    headerColumn: string;
    dropDownIcon: string;
    tableHeaderRoleTitle: string;
    permissionCheckbox: string;
    editRoleButton: string;
    deleteRoleButton: string;
    permissionCard: string;
};

declare const SIGNUP_SELECTORS: {
    emailTextField: string;
    firstNameTextField: string;
    lastNameTextField: string;
    organizationNameTextField: string;
    organizationSubmitButton: string;
    otpTextBox: string;
    profileSubmitButton: string;
    signupViaEmailButton: string;
    submitButton: string;
    subdomainNameTextField: string;
    subdomainError: string;
    tryFreeButton: string;
    unregisterdEmailError: string;
};

declare const TAGS_SELECTORS: {
    newTagButton: string;
    tagNameTextField: string;
    editButton: string;
    deleteButton: string;
    cancelButton: string;
    submitButton: string;
    searchTextField: string;
    descriptionTextArea: string;
};
declare const MERGE_TAGS_SELECTORS: {
    mergeTagsButton: string;
    mergeButton: string;
    sourceSearchTextField: string;
    sourceTagsList: string;
    destinationTagsList: string;
    destinationSearchTextField: string;
    cancelButton: string;
    proceedButton: string;
    disabledTag: string;
};

declare const CHAT_WIDGET_SELECTORS: {
    iframe: string;
    spinner: string;
    helpButton: string;
    preChatEmailInput: string;
    preChatSubmitButton: string;
    chatBubble: string;
    closeChat: string;
};
declare const CHANGELOG_WIDGET_SELECTORS: {
    changelogWrapper: string;
    closeButton: string;
    publicUrlLink: string;
};
declare const KEYBOARD_SHORTCUTS_SELECTORS: {
    keyboardShortcutsPane: string;
    closePaneButton: string;
    hotKeyItem: string;
};

declare const PROFILE_SECTION_SELECTORS: {
    profileSectionButton: string;
    profilePopup: string;
    myProfileButton: string;
    profileOrganizationSettingsButton: string;
    logoutButton: string;
    neetoAuthLink: string;
    profileSidebarCancelButton: string;
};

declare const SLACK_SELECTORS: {
    messageContainer: string;
    loginEmail: string;
    loginPassword: string;
    signInButton: string;
    teamPicketButtonContent: string;
    redirectOpenInBrowser: string;
    workspaceActionsButton: string;
    teamMenuTrigger: string;
    menuItemButton: string;
    threadsFlexpane: string;
    replyBar: string;
    markdownElement: string;
    virtualListItem: string;
    channelItems: string;
};
declare const SLACK_DATA_QA_SELECTORS: {
    sectionHeadingButton: string;
    channelSectionSubmenuCreate: string;
    channelSectionMenuCreateChannel: string;
    skModalContent: string;
    infiniteSpinner: string;
    channelNameOptionsList: string;
    channelNameInput: string;
    createChannelNextButton: string;
    inviteToWorkspaceSkipButton: string;
    menuItems: string;
    channelDetailsModal: string;
    channelDetailsSettingsTab: string;
};

declare const INTEGRATION_SELECTORS: {
    integrationCard: (integration: string) => string;
    connectButton: string;
    integrationStatusTag: string;
    disconnectButton: string;
    manageButton: string;
};

declare const CHAT_WIDGET_TEXTS: {
    newConversation: string;
    welcomeChatBubble: string;
};
declare const MEMBER_TEXTS: {
    agent: string;
};
declare const INTEGRATIONS_TEXTS: {
    connectHeader: (integration: string) => string;
    connectedHeader: (integration: string) => string;
};
declare const SLACK_WEB_TEXTS: {
    signOut: string;
    allow: string;
    loadingThread: string;
    name: string;
    deleteThisChannel: string;
    permanentlyDeleteTheChannel: string;
    deleteChannel: string;
};

declare const initializeCredentials: (product: string) => void;

interface KeyValue {
    key: string;
    value: string;
}
type JoinString = (string1: string, string2: string, string3?: string, separator?: string) => string;
interface UserContext {
    user: Record<string, string>;
    headers: Record<string, unknown>;
}
type ReadFileSyncIfExists = (path?: string) => UserContext & Record<string, object>;
type WriteDataToFile = (data: string) => boolean;
type UpdateCredentials = ({ key, value }: KeyValue) => boolean;
type ClearCredentials = () => void;
type Hyphenize = (input: number | string) => string;
type JoinHyphenCase = (args: string) => string;
declare const joinString: JoinString;
declare const readFileSyncIfExists: ReadFileSyncIfExists;
declare const getGlobalUserState: () => Record<string, string>;
declare const writeDataToFile: WriteDataToFile;
declare const updateCredentials: UpdateCredentials;
declare const removeCredentialFile: ClearCredentials;
declare const clearCredentials: ClearCredentials;
declare const hyphenize: Hyphenize;
declare const joinHyphenCase: JoinHyphenCase;
declare const skipTest: {
    forDevelopmentEnv: () => void;
    forReviewEnv: () => void;
    forAllExceptStagingEnv: () => void;
    forNonNightlyRun: () => void;
    ifNotWithinAllowedNightlyHours: ({ reason, allowedNightlyRunHours, }: {
        reason: string;
        allowedNightlyRunHours?: number[] | undefined;
    }) => void;
};
declare const shouldSkipSetupAndTeardown: () => boolean | "";
declare const squish: (text: string) => string;
declare const toCamelCase: (string: string) => string;
declare const getByDataQA: ts_toolbelt_out_Function_Curry.Curry<(page: Page, dataQa: string | [string, string]) => playwright_core.Locator>;

interface LoginProps {
    page: Page;
    neetoPlaywrightUtilities: CustomCommands;
    loginPath?: string;
}
declare const loginWithoutSSO: ({ page, neetoPlaywrightUtilities, loginPath, }: LoginProps) => Promise<void>;
declare const login: ({ page, neetoPlaywrightUtilities, loginPath, }: LoginProps) => Promise<false | void>;

declare const extractSubdomainFromError: (errorString: string) => string;

interface AddMemberProps {
    email: string;
    role?: string;
    appName: string;
    requestCount?: number;
    neetoPlaywrightUtilities: CustomCommands;
}
interface EditMemberProps {
    email: string;
    firstName?: string;
    lastName?: string;
    newRole?: string;
    requestCount?: number;
    neetoPlaywrightUtilities: CustomCommands;
}
interface DeactiveMemberProps {
    email: string;
    neetoPlaywrightUtilities: CustomCommands;
    requestCount?: number;
}
declare const memberUtils: {
    addMemberViaRequest: ({ email, role, appName, neetoPlaywrightUtilities, }: AddMemberProps) => Promise<playwright_core.APIResponse | undefined>;
    editMemberViaRequest: ({ email, firstName, lastName, newRole, neetoPlaywrightUtilities, }: EditMemberProps) => Promise<void>;
    deactivateMemberViaRequest: ({ email, neetoPlaywrightUtilities, }: DeactiveMemberProps) => Promise<playwright_core.APIResponse | undefined>;
};

interface AssertColumnHeaderVisibilityProps {
    page: Page;
    columnName: string;
    shouldBeVisible: boolean;
}
interface ToggleColumnCheckboxAndVerifyVisibilityProps {
    page: Page;
    tableColumns: string[];
    shouldBeChecked: boolean;
}
declare const tableUtils: {
    verifyTableColumnsExistence: ({ page, columnNames, }: {
        page: Page;
        columnNames: string[];
    }) => Promise<void>;
    assertColumnHeaderVisibility: ({ page, columnName, shouldBeVisible, }: AssertColumnHeaderVisibilityProps) => Promise<void>;
    toggleColumnCheckboxAndVerifyVisibility: ({ page, tableColumns, shouldBeChecked, }: ToggleColumnCheckboxAndVerifyVisibilityProps) => Promise<void>;
};

interface BreadcrumbTitleAndRoute {
    title: string;
    route: string;
}
interface VerifyBreadcrumbProps {
    page: Page;
    titlesAndRoutes: BreadcrumbTitleAndRoute[];
}
declare const headerUtils: {
    verifyBreadcrumbs: ({ page, titlesAndRoutes, }: VerifyBreadcrumbProps) => Promise<void>;
};

declare const decodeQRCodeFromFile: (filePath: string) => Promise<string | undefined>;

declare const initializeTotp: ({ issuer, secret, }: {
    issuer: string;
    secret: string | Secret;
}) => TOTP;

type EmulateNetworkConditionsParameters = Protocol.Network.emulateNetworkConditionsParameters;
type NetworkThrottlingUsingCdpParams = {
    cdpSession: CDPSession;
    emulateNetworkConditionsParameters?: EmulateNetworkConditionsParameters;
};
declare const networkThrottlingUsingCDP: ({ cdpSession, emulateNetworkConditionsParameters, }: NetworkThrottlingUsingCdpParams) => Promise<Protocol.Network.emulateNetworkConditionsReturnValue>;
type CpuThrottlingUsingCdpParams = {
    cdpSession: CDPSession;
    rate?: number;
};
declare const cpuThrottlingUsingCDP: ({ cdpSession, rate, }: CpuThrottlingUsingCdpParams) => Promise<Protocol.Emulation.setCPUThrottlingRateReturnValue>;
interface ExecuteWithThrottledResourcesParams {
    kind?: "both" | "network" | "cpu";
    code: () => Promise<void>;
    networkCondition?: EmulateNetworkConditionsParameters;
    cpuThrottlingRate?: number;
    cdpSession: CDPSession;
}
declare const executeWithThrottledResources: ({ code: emulatedCode, kind, networkCondition, cpuThrottlingRate, cdpSession, }: ExecuteWithThrottledResourcesParams) => Promise<void>;

interface CurrentsOverrides {
    projectId: string;
}
interface Overrides {
    globalOverrides?: Record<string, unknown>;
    useOverrides?: Record<string, unknown>;
    useCustomProjects?: boolean;
    projectOverrides?: Record<string, unknown>[];
    currentsOverrides: CurrentsOverrides & Record<string, unknown>;
}
declare const definePlaywrightConfig: (overrides: Overrides) => _playwright_test.PlaywrightTestConfig<{}, {}>;

export { API_ROUTES, BASE_URL, CHANGELOG_WIDGET_SELECTORS, CHAT_WIDGET_SELECTORS, CHAT_WIDGET_TEXTS, COMMON_SELECTORS, CREDENTIALS, CustomCommands, type CustomFixture, ENVIRONMENT, EmbedBase, GLOBAL_TRANSLATIONS_PATTERN, HELP_CENTER_SELECTORS, HelpAndProfilePage, INTEGRATIONS_TEXTS, INTEGRATION_SELECTORS, IS_STAGING_ENV, IntegrationBase, KEYBOARD_SHORTCUTS_SELECTORS, LOGIN_SELECTORS, MEMBER_FORM_SELECTORS, MEMBER_SELECTORS, MEMBER_TEXTS, MERGE_TAGS_SELECTORS, MailosaurUtils, NEETO_AUTH_BASE_URL, NEETO_EDITOR_SELECTORS, NEETO_FILTERS_SELECTORS, OTP_EMAIL_PATTERN, OrganizationPage, PROFILE_SECTION_SELECTORS, PROJECT_TRANSLATIONS_PATH, ROLES_SELECTORS, ROUTES, SIGNUP_SELECTORS, SLACK_DATA_QA_SELECTORS, SLACK_DEFAULT_CHANNEL, SLACK_SELECTORS, SLACK_WEB_TEXTS, STORAGE_STATE, SidebarSection, SlackPage, TAGS_SELECTORS, THIRD_PARTY_ROUTES, USER_AGENTS, WebhooksPage, clearCredentials, commands, cpuThrottlingUsingCDP, decodeQRCodeFromFile, definePlaywrightConfig, executeWithThrottledResources, extractSubdomainFromError, generateStagingData, getByDataQA, getGlobalUserState, headerUtils, hyphenize, i18nFixture, initializeCredentials, initializeTotp, joinHyphenCase, joinString, login, loginWithoutSSO, memberUtils, networkConditions, networkThrottlingUsingCDP, readFileSyncIfExists, removeCredentialFile, shouldSkipSetupAndTeardown, skipTest, squish, _default as stealthTest, tableUtils, toCamelCase, updateCredentials, writeDataToFile };
