import * as axe_core from 'axe-core';
import * as _playwright_test from '@playwright/test';
import { APIRequestContext, APIResponse, Page, BrowserContext, Locator } from '@playwright/test';
export * from '@playwright/test';
import { components } from '@shopware/api-client/admin-api-types';
import { Image } from 'image-js';

type Task = (...args: any[]) => () => Promise<void>;

interface RequestOptions$1<PAYLOAD> {
    [key: string]: unknown;
    data?: PAYLOAD;
}
interface AdminApiContextOptions {
    app_url?: string;
    client_id?: string;
    client_secret?: string;
    access_token?: string;
    admin_username?: string;
    admin_password?: string;
    ignoreHTTPSErrors?: boolean;
}
declare class AdminApiContext {
    context: APIRequestContext;
    readonly options: AdminApiContextOptions;
    private static readonly defaultOptions;
    constructor(context: APIRequestContext, options: AdminApiContextOptions);
    static create(options?: AdminApiContextOptions): Promise<AdminApiContext>;
    private static createApiRequestContext;
    static authenticateWithClientCredentials(context: APIRequestContext, options: AdminApiContextOptions): Promise<string>;
    static authenticateWithUserPassword(context: APIRequestContext, options: AdminApiContextOptions): Promise<string>;
    isAuthenticated(): boolean;
    refreshAccessToken(): Promise<void>;
    get<PAYLOAD>(url: string, options?: RequestOptions$1<PAYLOAD>): Promise<APIResponse>;
    post<PAYLOAD>(url: string, options?: RequestOptions$1<PAYLOAD>): Promise<APIResponse>;
    patch<PAYLOAD>(url: string, options?: RequestOptions$1<PAYLOAD>): Promise<APIResponse>;
    delete<PAYLOAD>(url: string, options?: RequestOptions$1<PAYLOAD>): Promise<APIResponse>;
    fetch<PAYLOAD>(url: string, options?: RequestOptions$1<PAYLOAD>): Promise<APIResponse>;
    head<PAYLOAD>(url: string, options?: RequestOptions$1<PAYLOAD>): Promise<APIResponse>;
    private handleRequest;
}

interface RequestOptions<PAYLOAD> {
    [key: string]: unknown;
    data?: PAYLOAD;
}
interface StoreUser {
    email: string;
    password: string;
}
interface StoreApiContextOptions {
    'app_url'?: string;
    'sw-access-key'?: string;
    'sw-context-token'?: string;
    ignoreHTTPSErrors?: boolean;
}
declare class StoreApiContext {
    private context;
    private readonly options;
    private static readonly defaultOptions;
    constructor(context: APIRequestContext, options: StoreApiContextOptions);
    static create(options?: StoreApiContextOptions): Promise<StoreApiContext>;
    private static createContext;
    login(user: StoreUser): Promise<{
        [key: string]: string;
    }>;
    get<PAYLOAD>(url: string, options?: RequestOptions<PAYLOAD>): Promise<APIResponse>;
    post<PAYLOAD>(url: string, options?: RequestOptions<PAYLOAD>): Promise<APIResponse>;
    patch<PAYLOAD>(url: string, options?: RequestOptions<PAYLOAD>): Promise<APIResponse>;
    delete<PAYLOAD>(url: string, options?: RequestOptions<PAYLOAD>): Promise<APIResponse>;
    fetch<PAYLOAD>(url: string, options?: RequestOptions<PAYLOAD>): Promise<APIResponse>;
    head<PAYLOAD>(url: string, options?: RequestOptions<PAYLOAD>): Promise<APIResponse>;
}

interface Email {
    fromName: string;
    fromAddress: string;
    toName: string;
    toAddress: string;
    subject: string;
    emailId: string;
}
declare class MailpitApiContext {
    context: APIRequestContext;
    constructor(context: APIRequestContext);
    /**
     * Fetches email headers based on the recipient's email address.
     * @param email - The email address of the recipient.
     * @returns An Email object containing the email headers.
     */
    getEmailHeaders(email: string): Promise<Email>;
    /**
     * Retrieves the body content of the email as an HTML string.
     * @param email - The email address of the recipient.
     * @returns A promise that resolves to the HTML content of the email.
     */
    getEmailBody(email: string): Promise<string>;
    /**
     * Generates the full email content, combining headers and body.
     * @param email - The email address to fetch headers for.
     * @returns A promise that resolves to the full email content as a string.
     */
    generateEmailContent(email: string): Promise<string>;
    /**
     * Retrieves the plain text content of the email.
     * @param email - The email address of the recipient.
     * @returns A promise that resolves to the plain text content of the email.
     */
    getRenderMessageTxt(email: string): Promise<string>;
    /**
     * Extracts the first URL found in the plain text content of the latest email.
     * @param email - The email address of the recipient.
     * @returns A promise that resolves to the first URL found in the email content.
     * @throws An error if no URL is found in the email content.
     */
    getLinkFromMail(email: string): Promise<string>;
    /**
     * Deletes a specific email by ID if provided, or deletes all emails if no ID is provided.
     * @param emailId - The ID of the email to delete (optional).
     */
    deleteMail(emailId?: string): Promise<void>;
    /**
     * Creates a new MailpitApiContext instance with the appropriate configuration.
     * @param baseURL - The base URL for the API.
     * @returns A promise that resolves to a MailpitApiContext instance.
     */
    static create(baseURL: string): Promise<MailpitApiContext>;
}

interface ApiContextTypes {
    AdminApiContext: AdminApiContext;
    StoreApiContext: StoreApiContext;
    MailpitApiContext: MailpitApiContext;
}

interface PageContextTypes {
    AdminPage: Page;
    StorefrontPage: Page;
    InstallPage: Page;
    page: Page;
    context: BrowserContext;
}

declare class Actor {
    page: Page;
    readonly name: string;
    baseURL: string | undefined;
    constructor(name: string, page: Page, baseURL?: string);
    expects: _playwright_test.Expect<{}>;
    attemptsTo(task: () => Promise<void>): Promise<void>;
    goesTo(url: string, forceReload?: boolean): Promise<void>;
    private camelCaseToLowerCase;
}

interface ActorFixtureTypes {
    ShopCustomer: Actor;
    ShopAdmin: Actor;
}

interface IdPair {
    id: string;
    uuid: string;
}
declare class IdProvider {
    private readonly workerIndex;
    private readonly seed;
    constructor(workerIndex: number, seed: string);
    getIdPair(): IdPair;
    getUniqueName(): string;
    getWorkerDerivedStableId(key: string): IdPair;
}

type SalesChannel = components['schemas']['SalesChannel'] & {
    id: string;
};
type SalesChannelDomain = components['schemas']['SalesChannelDomain'] & {
    id: string;
};
type Customer = Omit<components['schemas']['Customer'], 'defaultShippingAddress' | 'defaultBillingAddress'> & {
    id: string;
    password: string;
    defaultShippingAddress: {
        firstName: string;
        lastName: string;
        city: string;
        street: string;
        zipcode: string;
        countryId: string;
        salutationId: string;
    };
    defaultBillingAddress: {
        firstName: string;
        lastName: string;
        city: string;
        street: string;
        zipcode: string;
        countryId: string;
        salutationId: string;
    };
};
type CustomerAddress = components['schemas']['CustomerAddress'] & {
    id: string;
};
interface Address {
    salutation: string;
    firstName: string;
    lastName: string;
    company: string;
    department: string;
    street: string;
    city: string;
    zipCode: string;
    country: string;
    state: string;
}
type Salutation = components['schemas']['Salutation'] & {
    id: string;
};
interface Price {
    gross: number;
    net: number;
    linked: boolean;
    currencyId: string;
}
interface VariantListingConfig {
    displayParent: boolean;
}
interface ProductPrice {
    productId?: string;
    ruleId: string;
    price: Price[];
    quantityStart: number;
    quantityEnd: number | null;
}
type Product = Omit<components['schemas']['Product'], 'price' | 'prices' | 'options' | 'tags' | 'visibilities' | 'variantListingConfig'> & {
    id: string;
    price: Price[];
    prices?: ProductPrice[];
    translated: {
        name: string;
    };
    options?: Record<string, string>[];
    tags?: Record<string, string>[];
    visibilities?: Record<string, unknown>[];
    variantListingConfig?: VariantListingConfig;
};
type ProductReview = components['schemas']['ProductReview'] & {
    id: string;
    productId: string;
    salesChannelId: string;
    title: string;
    content: string;
    points: number;
};
type OrderDelivery = Omit<components['schemas']['OrderDelivery'], 'shippingOrderAddress' | 'shippingCosts'> & {
    id: string;
    shippingOrderAddress: Partial<components['schemas']['OrderAddress']>;
    shippingCosts: {
        unitPrice: number;
        totalPrice: number;
        quantity: number;
        calculatedTaxes: CalculatedTaxes[];
        taxRules: TaxRules[];
    };
};
type Manufacturer = components['schemas']['ProductManufacturer'] & {
    id: string;
};
type PropertyGroup = components['schemas']['PropertyGroup'] & {
    id: string;
};
type Category$1 = components['schemas']['Category'] & {
    id: string;
};
type Media = components['schemas']['Media'] & {
    id: string;
};
type Tag = components['schemas']['Tag'] & {
    id: string;
};
type Rule = components['schemas']['Rule'] & {
    id: string;
};
type Currency$2 = components['schemas']['Currency'] & {
    id: string;
};
type Country$1 = Omit<components['schemas']['Country'], 'states'> & {
    id: string;
    states: [
        {
            name: string;
            shortCode: string;
        }
    ];
};
type SystemConfig = components['schemas']['SystemConfig'] & {
    id: string;
};
type ProductCrossSelling = components['schemas']['ProductCrossSelling'] & {
    id: string;
};
interface CalculatedTaxes {
    tax: number;
    taxRate: number;
    price: number;
}
interface TaxRules {
    taxRate: number;
    percentage: number;
}
type Order = Omit<components['schemas']['Order'], 'deliveries' | 'price'> & {
    id: string;
    orderCustomer: {
        firstName: string;
        lastName: string;
        email: string;
    };
    price: {
        netPrice: number;
        positionPrice: number;
        rawTotal: number;
        taxStatus: string;
        totalPrice: number;
        calculatedTaxes: CalculatedTaxes[];
        taxRules: TaxRules[];
    };
    deliveries: Record<string, unknown>[];
};
type ShippingMethod$1 = components['schemas']['ShippingMethod'] & {
    id: string;
};
type PaymentMethod$1 = components['schemas']['PaymentMethod'] & {
    id: string;
};
type StateMachine = components['schemas']['StateMachine'] & {
    id: string;
};
type StateMachineState = components['schemas']['StateMachineState'] & {
    id: string;
};
type Promotion = Omit<components['schemas']['Promotion'], 'discounts'> & {
    id: string;
    discounts: [
        {
            id?: string;
            scope: string;
            type: string;
            value: number;
            considerAdvancedRules: boolean;
        }
    ];
};
type PromotionDiscount = components['schemas']['PromotionDiscount'] & {
    id: string;
};
type OrderLineItem = components['schemas']['OrderLineItem'] & {
    id: string;
};
type PropertyGroupOption = components['schemas']['PropertyGroupOption'] & {
    id: string;
};
type DeliveryTime = components['schemas']['DeliveryTime'] & {
    id: string;
};
type CmsPage = components['schemas']['CmsPage'] & {
    id: string;
};
type CustomerGroup = components['schemas']['CustomerGroup'] & {
    id: string;
};
type SalesChannelAnalytics = components['schemas']['SalesChannelAnalytics'] & {
    id: string;
};
interface RegistrationData {
    isCommercial: boolean;
    isGuest: boolean;
    salutation: string;
    firstName: string;
    lastName: string;
    email: string;
    password: string;
    street: string;
    city: string;
    country: string;
    postalCode: string;
    company: string;
    department: string;
    vatRegNo: string;
}
type Language$2 = components['schemas']['Language'] & {
    id: string;
};
type CustomFieldSet = components['schemas']['CustomFieldSet'] & {
    id: string;
};
type CustomField = Omit<components['schemas']['CustomField'], 'config'> & {
    id: string;
    config: {
        label: {
            'en-GB': string;
        };
    };
};
type Tax$1 = components['schemas']['Tax'] & {
    id: string;
};
declare enum RuleType {
    shippingAvailability = "shippingMethodAvailabilityRule",
    taxAvailability = "taxProviderAvailabilityRule",
    paymentAvailability = "paymentMethodAvailabilityRule",
    promotionOrder = "promotionOrderRule",
    promotionCustomer = "promotionCustomerRule",
    promotionCart = "promotionCartRule"
}
interface RuleAssignmentEntity {
    entity: {
        id: string;
        name: string;
    };
    ruleType: RuleType;
}
interface CategoryData {
    name: string;
    categoryType: 'Link' | 'Page / List' | 'Structuring element / Entry point';
    status: boolean;
}
interface CategoryCustomizableLinkData {
    linkType: 'Internal' | 'External';
    entity: 'Category' | 'Product' | 'Landing page';
    category?: string;
    product?: string;
    landingPage?: string;
    openInNewTab: boolean;
}
interface AccountData {
    customerGroup?: string;
    accountStatus?: boolean;
    language?: string;
    replyToCustomerGroupRequest?: string;
}
interface TagData {
    changeType: 'Overwrite' | 'Clear' | 'Add' | 'Remove';
    tags: string[];
}
interface CustomFieldData {
    customFieldSetName: string;
    customFieldValue: string;
}
interface FlowTemplate {
    id: string;
    name: string;
    config: {
        eventName: string;
        sequences: [
            {
                actionName: string;
                config: string;
            }
        ];
    };
}
interface Flow {
    id: string;
    name: string;
    eventName: string;
    sequences: [
        {
            actionName: string;
            config: string;
        }
    ];
}

interface SalesChannelRecord {
    salesChannelId: string;
    field: string;
}
interface CreatedRecord {
    resource: string;
    payload: Record<string, string>;
}
interface SimpleLineItem {
    product: Product | Promotion;
    quantity?: number;
    position?: number;
    overrides?: Partial<OrderLineItem>;
}
interface SyncApiOperation {
    entity: string;
    action: 'upsert' | 'delete';
    payload: Record<string, unknown>[];
}
interface DataServiceOptions {
    namePrefix?: string;
    nameSuffix?: string;
    defaultSalesChannel: SalesChannel;
    defaultTaxId: string;
    defaultCurrencyId: string;
    defaultCategoryId: string;
    defaultLanguageId: string;
    defaultCountryId: string;
    defaultCustomerGroupId: string;
}
declare class TestDataService {
    readonly AdminApiClient: AdminApiContext;
    readonly IdProvider: IdProvider;
    readonly namePrefix: string;
    readonly nameSuffix: string;
    readonly defaultSalesChannel: SalesChannel;
    readonly defaultTaxId: string;
    readonly defaultCurrencyId: string;
    readonly defaultCategoryId: string;
    readonly defaultLanguageId: string;
    readonly defaultCountryId: string;
    readonly defaultCustomerGroupId: string;
    /**
     * Configures if an automated cleanup of the data should be executed.
     *
     * @private
     */
    private shouldCleanUp;
    /**
     * Configuration of higher priority entities for the cleanup operation.
     * These entities will be deleted before others.
     * This will prevent restricted delete operations of associated entities.
     *
     * @private
     */
    private highPriorityEntities;
    /**
     * A registry of all created records.
     *
     * @private
     */
    private createdRecords;
    private restoreSystemConfig;
    /**
     * A registry of all created sales channel records.
     *
     * @private
     */
    private createdSalesChannelRecords;
    constructor(AdminApiClient: AdminApiContext, IdProvider: IdProvider, options: DataServiceOptions);
    /**
     * Creates a basic product without images or other special configuration.
     * The product will be added to the default sales channel category if configured.
     *
     * @param overrides - Specific data overrides that will be applied to the product data struct.
     * @param taxId - The uuid of the tax rule to use for the product pricing.
     * @param currencyId - The uuid of the currency to use for the product pricing.
     */
    createBasicProduct(overrides?: Partial<Product>, taxId?: string, currencyId?: string): Promise<Product>;
    /**
     * Creates a basic product cross-selling entity without products.
     *
     * @param productId - The uuid of the product to which the pproduct cross-selling should be assigned.
     * @param overrides - Specific data overrides that will be applied to the property group data struct.
     */
    createProductCrossSelling(productId: string, overrides?: Partial<ProductCrossSelling>): Promise<ProductCrossSelling>;
    /**
     * Creates a basic product with one randomly generated image.
     * The product will be added to the default sales channel category if configured.
     *
     * @param overrides - Specific data overrides that will be applied to the product data struct.
     * @param taxId - The uuid of the tax rule to use for the product pricing.
     * @param currencyId - The uuid of the currency to use for the product pricing.
     */
    createProductWithImage(overrides?: Partial<Product>, taxId?: string, currencyId?: string): Promise<Product>;
    /**
     * Creates a digital product with a text file as its download.
     * The product will be added to the default sales channel category if configured.
     *
     * @param content - The content of the text file for the product download.
     * @param overrides - Specific data overrides that will be applied to the product data struct.
     * @param taxId - The uuid of the tax rule to use for the product pricing.
     * @param currencyId - The uuid of the currency to use for the product pricing.
     */
    createDigitalProduct(content?: string, overrides?: Partial<Product>, taxId?: string, currencyId?: string): Promise<Product>;
    /**
     * Creates a basic product with a price range matrix.
     * The product will be added to the default sales channel category if configured.
     *
     * @param overrides - Specific data overrides that will be applied to the product data struct.
     * @param taxId - The uuid of the tax rule to use for the product pricing.
     * @param currencyId - The uuid of the currency to use for the product pricing.
     */
    createProductWithPriceRange(overrides?: Partial<Product>, taxId?: string, currencyId?: string): Promise<Product>;
    /**
     * Creates basic variant products based on property group.
     *
     * @param parentProduct Parent product of the variants
     * @param propertyGroups Property group collection which contain options
     * @param overrides - Specific data overrides that will be applied to the variant data struct.
     */
    createVariantProducts(parentProduct: Product, propertyGroups: PropertyGroup[], overrides?: Partial<Product>): Promise<Product[]>;
    /**
     * Creates a product review
     *
     * @param productId - The uuid of the product to which the review should be assigned.
     * @param overrides - Specific data overrides that will be applied to the review data struct.
     */
    createProductReview(productId: string, overrides?: Partial<ProductReview>): Promise<ProductReview>;
    /**
     * Creates a basic manufacturer without images or other special configuration.
     *
     * @param overrides - Specific data overrides that will be applied to the manufacturer data struct.
     */
    createBasicManufacturer(overrides?: Partial<Manufacturer>): Promise<Manufacturer>;
    /**
     * Creates a basic manufacturer with one randomly generated image.
     *
     * @param overrides - Specific data overrides that will be applied to the manufacturer data struct.
     */
    createManufacturerWithImage(overrides?: Partial<Manufacturer>): Promise<Manufacturer>;
    /**
     * Creates a basic product category to assign products to.
     *
     * @param parentId - The uuid of the parent category.
     * @param overrides - Specific data overrides that will be applied to the category data struct.
     */
    createCategory(overrides?: Partial<Category$1>, parentId?: string): Promise<Category$1>;
    /**
     * Creates a new media resource containing a random generated PNG image.
     *
     * @param width - The width of the image in pixel. Default is 800.
     * @param height - The height of the image in pixel. Default is 600.
     */
    createMediaPNG(width?: number, height?: number): Promise<Media>;
    /**
     * Creates a new media resource containing a text file.
     *
     * @param content - The content of the text file.
     */
    createMediaTXT(content?: string): Promise<Media>;
    /**
     * Creates a new empty media resource.
     * This method is mostly used to combine it with a certain file upload.
     */
    createMediaResource(): Promise<Media>;
    /**
     * Creates a new property group with color type options.
     *
     * @param overrides - Specific data overrides that will be applied to the property group data struct.
     */
    createColorPropertyGroup(overrides?: Partial<PropertyGroup>): Promise<PropertyGroup>;
    /**
     * Creates a new property group with text type options.
     *
     * @param overrides - Specific data overrides that will be applied to the property group data struct.
     */
    createTextPropertyGroup(overrides?: Partial<PropertyGroup>): Promise<PropertyGroup>;
    /**
     * Creates a new tag which can be assigned to other entities.
     *
     * @param tagName - The name of the tag.
     */
    createTag(tagName: string): Promise<Tag>;
    /**
     * Creates a new shop customer.
     *
     * @param overrides - Specific data overrides that will be applied to the customer data struct.
     * @param salutationKey - The key of the salutation that should be used for the customer. Default is "mr".
     * @param salesChannel - The sales channel for which the customer should be registered.
     */
    createCustomer(overrides?: Partial<Customer>, salutationKey?: string, salesChannel?: SalesChannel): Promise<Customer>;
    /**
     * Creates a new order. This order is created on pure data and prices are not guaranteed to be calculated correctly.
     *
     * @param lineItems - Products that should be added to the order.
     * @param customer - The customer to which the order should be assigned.
     * @param overrides - Specific data overrides that will be applied to the order data struct.
     * @param salesChannel - The sales channel in which the order should be created.
     */
    createOrder(lineItems: SimpleLineItem[], customer: Customer, overrides?: Partial<Order>, salesChannel?: SalesChannel): Promise<Order>;
    /**
     * Creates a new promotion with a promotion code and only single discount option.
     *
     * @param overrides - Specific data overrides that will be applied to the promotion data struct.
     * @param salesChannelId - The uuid of the sales channel in which the promotion should be active.
     */
    createPromotionWithCode(overrides?: Partial<Promotion>, salesChannelId?: string): Promise<Promotion>;
    /**
     * Creates a new basic payment method.
     *
     * @param overrides - Specific data overrides that will be applied to the payment method data struct.
     */
    createBasicPaymentMethod(overrides?: Partial<PaymentMethod$1>): Promise<PaymentMethod$1>;
    /**
     * Creates a payment method with one randomly generated image.
     *
     * @param overrides - Specific data overrides that will be applied to the payment method data struct.
     */
    createPaymentMethodWithImage(overrides?: Partial<PaymentMethod$1>): Promise<PaymentMethod$1>;
    /**
     * Creates a new basic shipping method with random delivery time.
     *
     * @param overrides - Specific data overrides that will be applied to the shipping method data struct.
     */
    createBasicShippingMethod(overrides?: Partial<ShippingMethod$1>): Promise<ShippingMethod$1>;
    /**
     * Creates a shipping method with one randomly generated image.
     *
     * @param overrides - Specific data overrides that will be applied to the shipping method data struct.
     */
    createShippingMethodWithImage(overrides?: Partial<ShippingMethod$1>): Promise<ShippingMethod$1>;
    /**
     * Creates a new basic rule with the condition cart amount >= 1.
     *
     * @param overrides - Specific data overrides that will be applied to the payment method data struct.
     */
    createBasicRule(overrides?: Partial<Rule>, conditionType?: string, operator?: string, amount?: number): Promise<Rule>;
    /**
     * Creates a new basic page layout.
     *
     * @param cmsPageType - The type of the cms page layout (page/landingpage/product_detail/product_list).
     * @param overrides - Specific data overrides that will be applied to the cms page layout data struct.
     */
    createBasicPageLayout(cmsPageType: string, overrides?: Partial<CmsPage>): Promise<CmsPage>;
    /**
     * Creates a random country
     *
     * @param overrides - Specific data overrides that will be applied to the country data struct.
     */
    createCountry(overrides?: Partial<Country$1>): Promise<Country$1>;
    /**
     * Creates a random currency with default rounding of 2 decimals
     *
     * @param roundingDecimals - Decimals of the rounding shown in Storefront, default value 2
     * @param overrides - Specific data overrides that will be applied to the currency data struct.
     */
    createCurrency(overrides?: Partial<Currency$2>, roundingDecimals?: number): Promise<Currency$2>;
    /**
     * Creates a random customer group
     *
     * @param overrides - Specific data overrides that will be applied to the customer group data struct.
     */
    createCustomerGroup(overrides?: Partial<CustomerGroup>): Promise<CustomerGroup>;
    /**
     * Set system config for default sales channel
     *
     * @param configs - Key value pairs to set
     */
    setSystemConfig(configs: Record<string, unknown>): Promise<void>;
    /**
     * Creates a random sales channel analytics entity
     *
     * @param overrides - Specific data overrides that will be applied to the sales channel analytics data struct.
     */
    createSalesChannelAnalytics(overrides?: Partial<SalesChannelAnalytics>): Promise<SalesChannelAnalytics>;
    /**
     * Creates a custom field
     *
     * @param customFieldSetId - The uuid of the custom field set.
     * @param overrides - Specific data overrides that will be applied to the custom field data struct.
     */
    createCustomField(customFieldSetId: string, overrides?: Partial<CustomField>): Promise<CustomField>;
    /**
     * Creates a custom field set
     *
     * @param overrides - Specific data overrides that will be applied to the custom field set data struct.
     */
    createCustomFieldSet(overrides?: Partial<CustomFieldSet>): Promise<CustomFieldSet>;
    /**
     * Creates a new domain for a sales channel.
     *
     * @param overrides - Specific data overrides that will be applied to the sales channel domain data struct.
     */
    createSalesChannelDomain(overrides?: Partial<SalesChannelDomain>): Promise<SalesChannelDomain>;
    /**
     * Creates a new tax rate (19%) with a random name.
     *
     * @param overrides - Specific data overrides that will be applied to the tax data struct.
     */
    createTaxRate(overrides?: Partial<Tax$1>): Promise<Tax$1>;
    /**
     * Assigns a media resource as the download of a digital product.
     *
     * @param productId - The uuid of the product.
     * @param mediaId - The uuid of the media resource.
     */
    assignProductDownload(productId: string, mediaId: string): Promise<any>;
    /**
     * Assigns a media resource to a product as the product image.
     *
     * @param productId - The uuid of the product.
     * @param mediaId - The uuid of the media resource.
     */
    assignProductMedia(productId: string, mediaId: string): Promise<any>;
    /**
     * Assigns a manufacturer to a product.
     *
     * @param productId - The uuid of the product.
     * @param manufacturerId - The uuid of the manufacturer.
     */
    assignProductManufacturer(productId: string, manufacturerId: string): Promise<void>;
    /**
     * Assigns a country to a currency with default roundings of 2.
     *
     * @param currencyId - The uuid of currency.
     * @param countryId - The uuid of country.
     * @param roundingDecimals - The roundings of item and total values in storefront, default 2 decimals
     */
    assignCurrencyCountryRounding(currencyId: string, countryId: string, roundingDecimals?: number): Promise<any>;
    /**
     * Assigns a product to a category.
     *
     * @param productId - The uuid of the product.
     * @param categoryId - The uuid of the category.
     */
    assignProductCategory(productId: string, categoryId: string): Promise<_playwright_test.APIResponse>;
    /**
     * Assigns a tag to a product.
     *
     * @param productId - The uuid of the product.
     * @param tagId - The uuid of the tag.
     */
    assignProductTag(productId: string, tagId: string): Promise<_playwright_test.APIResponse>;
    /**
     * Assigns a media resource to a manufacturer as a logo.
     *
     * @param manufacturerId - The uuid of the manufacturer.
     * @param mediaId - The uuid of the media resource.
     */
    assignManufacturerMedia(manufacturerId: string, mediaId: string): Promise<any>;
    /**
     * Assigns a manufacturer to a product.
     *
     * @deprecated - Use `assignProductManufacturer` instead.
     *
     * @param manufacturerId - The uuid of the manufacturer.
     * @param productId - The uuid of the product.
     */
    assignManufacturerProduct(manufacturerId: string, productId: string): Promise<void>;
    /**
     * Assigns a currency to a sales channel.
     *
     * @param salesChannelId - The uuid of the sales channel.
     * @param currencyId - The uuid of the currency.
     */
    assignSalesChannelCurrency(salesChannelId: string, currencyId: string): Promise<any>;
    /**
     * Assigns a sales channel analytics entity to a sales channel.
     *
     * @param salesChannelId - The uuid of the sales channel.
     * @param salesChannelAnalyticsId - The uuid of the sales channel analytics entity.
     */
    assignSalesChannelAnalytics(salesChannelId: string, salesChannelAnalyticsId: string): Promise<SalesChannel>;
    /**
     * Assigns a country to a sales channel.
     *
     * @param salesChannelId - The uuid of the sales channel.
     * @param countryId - The uuid of the country.
     */
    assignSalesChannelCountry(salesChannelId: string, countryId: string): Promise<any>;
    /**
     * Assigns a language to a sales channel.
     *
     * @param salesChannelId - The uuid of the sales channel.
     * @param languageId - The uuid of the language.
     */
    assignSalesChannelLanguage(salesChannelId: string, languageId: string): Promise<any>;
    /**
     * Assigns a payment method to a sales channel.
     *
     * @param salesChannelId - The uuid of the sales channel.
     * @param paymentMethodId - The uuid of the currency.
     */
    assignSalesChannelPaymentMethod(salesChannelId: string, paymentMethodId: string): Promise<any>;
    /**
     * Assigns a media resource to a payment method as a logo.
     *
     * @param paymentMethodId - The uuid of the payment method.
     * @param mediaId - The uuid of the media resource.
     */
    assignPaymentMethodMedia(paymentMethodId: string, mediaId: string): Promise<any>;
    /**
     * Assigns a media resource to a shipping method as a logo.
     *
     * @param shippingMethodId - The uuid of the shipping method.
     * @param mediaId - The uuid of the media resource.
     */
    assignShippingMethodMedia(shippingMethodId: string, mediaId: string): Promise<any>;
    /**
     * Retrieves a language based on its code.
     * @param languageCode
     */
    getLanguageData(languageCode: string): Promise<Language$2>;
    /**
     * Retrieves a currency based on its ISO code.
     *
     * @param isoCode - The ISO code of the currency, for example "EUR".
     */
    getCurrency(isoCode: string): Promise<Currency$2>;
    /**
     * Retrieves a rule based on its name.
     *
     * @param name - The name of the rule.
     */
    getRule(name: string): Promise<Rule>;
    /**
     * Retrieves a shipping method by its name.
     *
     * @param name - The name of the shipping method. Default is "Standard".
     */
    getShippingMethod(name?: string): Promise<ShippingMethod$1>;
    /**
     * Retrieves all delivery time resources.
     */
    getAllDeliveryTimeResources(): Promise<DeliveryTime[]>;
    /**
     * Retrieves a payment method by its name.
     *
     * @param name - The name of the payment method. Default is "Invoice".
     */
    getPaymentMethod(name?: string): Promise<PaymentMethod$1>;
    /**
     * Retrieves the address of a customer by its uuid.
     *
     * @param addressId - The uuid of the customer address.
     */
    getCustomerAddress(addressId: string): Promise<CustomerAddress>;
    /**
     * Retrieves a customer by its email address.
     *
     * @param email - The email address of the customer.
     * @returns The customer object.
     */
    getCustomerByEmail(email: string): Promise<Customer>;
    /**
     * Retrieves a customer salutations by its key.
     *
     * @param key - The key of the salutation. Default is "mr".
     */
    getSalutation(key?: string): Promise<any>;
    /**
     * Retrieves the state machine for order states.
     */
    getOrderStateMachine(): Promise<StateMachine>;
    /**
     * Retrieves the state machine for delivery states.
     */
    getDeliveryStateMachine(): Promise<StateMachine>;
    /**
     * Retrieves the state machine for transaction states.
     */
    getTransactionStateMachine(): Promise<StateMachine>;
    /**
     * Retrieves a state machine by its name.
     *
     * @param name - The name of the state machine.
     */
    getStateMachine(name: string): Promise<StateMachine>;
    /**
     * Retrieves the state of a state machine.
     *
     * @param stateMachineId - The uuid of the state machine.
     * @param stateName - The name of the state. Default is "open".
     */
    getStateMachineState(stateMachineId: string, stateName?: 'open' | 'completed' | 'in_progress' | 'cancelled'): Promise<StateMachineState>;
    /**
     * Retrieves all corresponding property group options.
     *
     * @param propertyGroupId - The uuid of the property group.
     */
    getPropertyGroupOptions(propertyGroupId: string): Promise<PropertyGroupOption[]>;
    /**
     * Retrieves a customer group by its id.
     *
     * @param customerGroupId - The id of the property group.
     */
    getCustomerGroupById(customerGroupId: string): Promise<CustomerGroup>;
    /**
     * Retrieves list of customer groups
     */
    getCustomerGroups(): Promise<CustomerGroup[]>;
    /**
     * Retrieves a language by its id.
     *
     * @param languageId - The id of the property group.
     */
    getLanguageById(languageId: string): Promise<Language$2>;
    /**
     * Adds an entity reference to the registry of created records.
     * All entities added to the registry will be deleted by the cleanup call.
     *
     * @param resource - The resource name of the entity.
     * @param payload - You can pass a payload object for the delete operation or simply pass the uuid of the entity.
     */
    addCreatedRecord(resource: string, payload: string | Record<string, string>): void;
    /**
     * Adds a sales channel related property to the registry of created sales channel records.
     * The property added to the registry will be overridden with null value by the cleanup call.
     *
     * @param salesChannelId - The sales channel id where the property pair is located
     * @param field - The database field which has to be overridden
     */
    addCreatedSalesChannelRecord(salesChannelId: string, field: string): void;
    /**
     * Set the configuration of automated data clean up.
     * If set to "true" the data service will delete all entities created by it.
     *
     * @param shouldCleanUp - The config setting for the automated data clean up. Default is "true".
     */
    setCleanUp(shouldCleanUp?: boolean): void;
    /**
     * Will delete all entities created by the data service via sync API.
     */
    cleanUp(): Promise<_playwright_test.APIResponse | null>;
    isProduct(item: Product | Promotion): item is Product;
    isPromotion(item: Product | Promotion): item is Promotion;
    /**
     * Convert a JS date object into a date-time compatible string.
     *
     * @param date - The JS date object from which the date-time should be retrieved.
     */
    convertDateTime(date: Date): string;
    /**
     * Function that generates combinations from n number of arrays
     * with m number of elements in them.
     * @param array
     */
    combineAll: (array: Record<string, string>[][]) => Record<string, string>[][];
    /**
     * @deprecated Use `getCountry` instead.
     * Retrieves a country Id based on its iso2 code.
     *
     * @param iso2 - The iso2 code of the country, for example "DE".
     */
    getCountryId(iso2: string): Promise<Country$1>;
    /**
     * Retrieves a country based on its iso2 code.
     *
     * @param iso2 - The iso2 code of the country, for example "DE".
     */
    getCountry(iso2: string): Promise<Country$1>;
    getCountryStruct(overrides?: Partial<Country$1>): Partial<Country$1>;
    getCurrencyStruct(overrides: Partial<Currency$2> | undefined, roundingDecimals: number): Partial<Currency$2>;
    getBasicProductStruct(taxId?: string, currencyId?: string, overrides?: Partial<Product>): Partial<Product>;
    getBasicRuleStruct(overrides: Partial<Rule> | undefined, conditionType: string, operator: string, amount: number): Partial<Rule>;
    getProductPriceRangeStruct(currencyId: string, ruleId: string): Partial<Product>;
    getBasicManufacturerStruct(overrides?: Partial<Manufacturer>): Partial<Manufacturer>;
    getBasicPaymentMethodStruct(overrides?: Partial<PaymentMethod$1>): {
        id: string;
        name: string;
        technicalName: string;
        active: boolean;
    } & Partial<PaymentMethod$1>;
    getBasicCategoryStruct(overrides?: Partial<Category$1>, parentId?: string): {
        id: string;
        name: string;
        parentId: string | null;
        displayNestedProducts: boolean;
        type: string;
        productAssignmentType: string;
        visible: boolean;
        active: boolean;
    } & Partial<Category$1>;
    getBasicCustomerStruct(salesChannelId: string, customerGroupId: string, languageId: string, countryId: string, defaultPaymentMethodId: string, salutationId: string, overrides?: Partial<Customer>): Partial<Customer>;
    getBasicOrderDeliveryStruct(deliveryState: StateMachineState, shippingMethod: ShippingMethod$1, customerAddress: CustomerAddress): Partial<OrderDelivery>;
    getBasicShippingMethodStruct(deliveryTimeId: string, overrides?: Partial<ShippingMethod$1>): {
        id: string;
        name: string;
        technicalName: string;
        deliveryTimeId: string;
        active: boolean;
    } & Partial<ShippingMethod$1>;
    getBasicOrderStruct(lineItems: SimpleLineItem[], languageId: string, currency: Currency$2, paymentMethod: PaymentMethod$1, shippingMethod: ShippingMethod$1, orderState: StateMachineState, deliveryState: StateMachineState, transactionState: StateMachineState, customer: Customer, customerAddress: CustomerAddress, salesChannelId?: string, overrides?: Partial<Order>): Partial<Order>;
    getBasicProductLineItemStruct(lineItem: SimpleLineItem): {
        productId: string;
        referencedId: string;
        payload: {
            productNumber: string;
        };
        identifier: string;
        type: string;
        label: string;
        quantity: number;
        position: number;
        price: {
            unitPrice: number;
            totalPrice: number;
            quantity: number | undefined;
            calculatedTaxes: {
                tax: number;
                taxRate: number;
                price: number;
            }[];
            taxRules: {
                taxRate: number;
                percentage: number;
            }[];
        };
        priceDefinition: {
            type: string;
            price: number;
            quantity: number;
            taxRules: {
                taxRate: number;
                percentage: number;
            }[];
            listPrice: number;
            isCalculated: boolean;
            referencePriceDefinition: null;
        };
    } & Partial<OrderLineItem>;
    getBasicPromotionLineItemStruct(lineItem: SimpleLineItem): {
        promotionId: string;
        referencedId: string | undefined;
        payload: {
            code: string | undefined;
        };
        identifier: string | undefined;
        type: string;
        label: string;
        description: string;
        quantity: number;
        position: number;
        price: {
            unitPrice: number;
            totalPrice: number;
            quantity: number | undefined;
            calculatedTaxes: {
                tax: number;
                taxRate: number;
                price: number;
            }[];
            taxRules: {
                taxRate: number;
                percentage: number;
            }[];
        };
        priceDefinition: {
            type: string;
            price: number;
            percentage: number | null;
        };
    } & Partial<OrderLineItem>;
    getBasicPromotionStruct(salesChannelId?: string, overrides?: Partial<Promotion>): Partial<Promotion>;
    getBasicCmsStruct(cmsType: string, overrides: Partial<CmsPage>): Partial<CmsPage>;
    getBasicCustomerGroupStruct(overrides?: Partial<CustomerGroup>): Partial<CustomerGroup>;
    getSalesChannelAnalyticsStruct(overrides?: Partial<SalesChannelAnalytics>): Partial<SalesChannelAnalytics>;
    clearCaches(): Promise<void>;
    getBasicCustomFieldSetStruct(overrides?: Partial<CustomFieldSet>): Partial<CustomFieldSet>;
    getBasicCustomFieldStruct(overrides?: Partial<CustomField>): Partial<CustomField>;
    getSalesChannelDomainStruct(salesChannelId: string, currencyId: string, languageId: string, snippetSetId: string, overrides?: Partial<SalesChannelDomain>): Partial<SalesChannelDomain>;
    getTaxStruct(overrides: Partial<Tax$1>): Partial<Tax$1>;
    getBasicCrossSellingStruct(productId: string, overrides?: Partial<ProductCrossSelling>): never;
    getBasicProductReviewStruct(productId: string, overrides?: Partial<ProductReview>): Partial<ProductReview>;
}

interface TestDataFixtureTypes {
    TestDataService: TestDataService;
}

type FeaturesType = Record<string, boolean>;
interface HelperFixtureTypes {
    IdProvider: IdProvider;
    SaaSInstanceSetup: () => Promise<void>;
    InstanceMeta: {
        version: string;
        isSaaS: boolean;
        features: FeaturesType;
    };
}

interface StoreBaseConfig {
    storefrontTypeId: string;
    enGBLocaleId: string;
    enGBLanguageId: string;
    eurCurrencyId: string;
    defaultCurrencyId: string;
    defaultLanguageId: string;
    invoicePaymentMethodId: string;
    defaultShippingMethod: string;
    taxId: string;
    deCountryId: string;
    enGBSnippetSetId: string;
    defaultThemeId: string;
    appUrl: string | undefined;
    adminUrl: string;
}
interface DefaultSalesChannelTypes {
    SalesChannelBaseConfig: StoreBaseConfig;
    DefaultSalesChannel: {
        salesChannel: SalesChannel;
        customer: Customer;
        url: string;
    };
    DefaultStorefront: {
        salesChannel: SalesChannel;
        customer: Customer;
        url: string;
    };
}

interface Country {
    id: string;
}
interface Currency$1 {
    id: string;
}
interface Language$1 {
    id: string;
    translationCode: {
        id: string;
    };
}
interface PaymentMethod {
    id: string;
}
interface ShippingMethod {
    id: string;
}
interface SnippetSet {
    id: string;
}
interface Tax {
    id: string;
}
interface Theme {
    id: string;
}
interface ShopwareDataFixtureTypes {
    Country: Country;
    Currency: Currency$1;
    Language: Language$1;
    PaymentMethod: PaymentMethod;
    ShippingMethod: ShippingMethod;
    SnippetSet: SnippetSet;
    Tax: Tax;
    Theme: Theme;
}

interface PageObject {
    readonly page: Page;
    url(...args: unknown[]): string;
}

declare class Home implements PageObject {
    readonly page: Page;
    readonly categoryTitle: Locator;
    readonly accountMenuButton: Locator;
    readonly closeGuestSessionButton: Locator;
    readonly productImages: Locator;
    readonly productListItems: Locator;
    readonly loader: Locator;
    readonly productVariantCharacteristicsOptions: Locator;
    /**
     * @deprecated Use 'Header/languagesDropdown' instead
     */
    readonly languagesDropdown: Locator;
    /**
     * @deprecated Use 'Header/languagesMenuOptions' instead
     */
    readonly languagesMenuOptions: Locator;
    /**
     * @deprecated Use 'Header/currenciesDropdown' instead
     */
    readonly currenciesDropdown: Locator;
    /**
     * @deprecated Use 'Header/currenciesMenuOptions' instead
     */
    readonly currenciesMenuOptions: Locator;
    readonly consentOnlyTechnicallyRequiredButton: Locator;
    readonly consentConfigureButton: Locator;
    readonly consentAcceptAllCookiesButton: Locator;
    readonly consentCookiePreferences: Locator;
    readonly consentCookiePermissionContent: Locator;
    readonly consentDialog: Locator;
    readonly consentDialogTechnicallyRequiredCheckbox: Locator;
    readonly consentDialogStatisticsCheckbox: Locator;
    /**
     * @deprecated Use 'consentDialogMarketingCheckbox' instead
     */
    readonly consentDialogMarketingdCheckbox: Locator;
    readonly consentDialogMarketingCheckbox: Locator;
    readonly consentDialogAcceptAllCookiesButton: Locator;
    readonly consentDialogSaveButton: Locator;
    readonly consentCookieBannerContainer: Locator;
    readonly offcanvasBackdrop: Locator;
    /**
     * @deprecated Use 'Header/mainNavigationLink' instead
     */
    readonly mainNavigationLink: Locator;
    /**
     * @deprecated Use 'Footer/contactFormLink' instead
     */
    readonly contactFormLink: Locator;
    /**
     * @deprecated Use 'Header/wishlistIcon' instead
     */
    readonly wishlistIcon: Locator;
    /**
     * @deprecated Use 'Header/wishlistBasket' instead
     */
    readonly wishlistBasket: Locator;
    readonly filterMultiSelect: Locator;
    readonly manufacturerFilter: Locator;
    readonly propertyFilters: Locator;
    readonly priceFilterButton: Locator;
    readonly resetAllButton: Locator;
    readonly freeShippingFilter: Locator;
    readonly productList: Locator;
    readonly productItemNames: Locator;
    readonly productRatingButton: Locator;
    readonly productRatingList: Locator;
    constructor(page: Page);
    getRatingItemLocatorByRating(rating: number): Promise<Locator>;
    getFilterItemByFilterName(filterName: string): Promise<Locator>;
    getFilterButtonByFilterName(filterName: string): Promise<Locator>;
    getMenuItemByCategoryName(categoryName: string): Promise<Record<string, Locator>>;
    /**
     * @deprecated - use getListingItemByProductName instead
     */
    getListingItemByProductId(productId: string): Promise<Record<string, Locator>>;
    getListingItemByProductName(productListingName: string): Promise<Record<string, Locator>>;
    url(): string;
}

declare class ProductDetail$1 implements PageObject {
    readonly page: Page;
    readonly addToCartButton: Locator;
    readonly quantitySelect: Locator;
    readonly productSingleImage: Locator;
    readonly productSinglePrice: Locator;
    readonly productPriceRangesRow: Locator;
    readonly productListingPriceBadge: Locator;
    readonly productListingPrice: Locator;
    readonly productListingPricePercentage: Locator;
    readonly offCanvasCartTitle: Locator;
    readonly offCanvasCart: Locator;
    readonly offCanvasCartGoToCheckoutButton: Locator;
    readonly offCanvasLineItemImages: Locator;
    readonly offCanvasSummaryTotalPrice: Locator;
    readonly offCanvas: Locator;
    readonly wishlistAddedButton: Locator;
    readonly wishlistNotAddedButton: Locator;
    readonly productDetailConfigurator: Locator;
    readonly productDetailConfiguratorGroupTitle: Locator;
    readonly productDetailConfiguratorOptionInputs: Locator;
    readonly productName: Locator;
    readonly reviewsTab: Locator;
    readonly reviewTeaserButton: Locator;
    readonly reviewTeaserText: Locator;
    readonly reviewListingItems: Locator;
    readonly reviewEmptyListingText: Locator;
    readonly reviewLoginForm: Locator;
    readonly forgottenPasswordLink: Locator;
    readonly reviewForm: Locator;
    readonly reviewRatingPoints: Locator;
    readonly reviewRatingText: Locator;
    readonly reviewSubmitMessage: Locator;
    readonly reviewCounter: Locator;
    readonly reviewItemRatingPoints: Locator;
    readonly reviewItemTitle: Locator;
    readonly reviewReviewTextInput: Locator;
    readonly reviewItemContent: Locator;
    readonly reviewLoginButton: Locator;
    readonly reviewEmailInput: Locator;
    readonly reviewPasswordInput: Locator;
    readonly reviewTitleInput: Locator;
    readonly reviewSubmitButton: Locator;
    readonly productReviewsLink: Locator;
    readonly productReviewRating: Locator;
    constructor(page: Page);
    getReviewFilterRowOptionsByName(filterOptionName: string): Promise<{
        reviewFilterOptionCheckbox: Locator;
        reviewFilterOptionText: Locator;
        reviewFilterOptionPercentage: Locator;
    }>;
    url(productData: Product): string;
}

declare class Category implements PageObject {
    readonly page: Page;
    readonly sortingSelect: Locator;
    readonly firstProductBuyButton: Locator;
    readonly noProductsFoundAlert: Locator;
    constructor(page: Page);
    url(categoryName: string): string;
}

declare class CheckoutCart implements PageObject {
    readonly page: Page;
    readonly headline: Locator;
    readonly goToCheckoutButton: Locator;
    readonly enterPromoInput: Locator;
    readonly grandTotalPrice: Locator;
    readonly emptyCartAlert: Locator;
    readonly stockReachedAlert: Locator;
    readonly cartLineItemImages: Locator;
    readonly unitPriceInfo: Locator;
    readonly cartQuantityNumber: Locator;
    constructor(page: Page);
    url(): string;
    getLineItemByProductNumber(productNumber: string): Promise<Record<string, Locator>>;
}

declare class OffCanvasCart implements PageObject {
    readonly page: Page;
    readonly headline: Locator;
    readonly itemCount: Locator;
    readonly goToCheckoutButton: Locator;
    readonly goToCartButton: Locator;
    readonly continueShoppingButton: Locator;
    readonly enterPromoInput: Locator;
    readonly submitDiscountButton: Locator;
    readonly subTotalPrice: Locator;
    readonly shippingCosts: Locator;
    readonly cartQuantityNumber: Locator;
    constructor(page: Page);
    url(): string;
    getLineItemByProductNumber(productNumber: string): Promise<Record<string, Locator>>;
}

declare class CheckoutConfirm implements PageObject {
    readonly page: Page;
    readonly headline: Locator;
    readonly termsAndConditionsCheckbox: Locator;
    readonly immediateAccessToDigitalProductCheckbox: Locator;
    readonly grandTotalPrice: Locator;
    readonly taxPrice: Locator;
    readonly submitOrderButton: Locator;
    /**
     * Payment options
     */
    readonly paymentCashOnDelivery: Locator;
    readonly paymentPaidInAdvance: Locator;
    readonly paymentInvoice: Locator;
    /**
     * Shipping options
     */
    readonly shippingStandard: Locator;
    readonly shippingExpress: Locator;
    /**
     * Product details
     */
    readonly cartLineItemImages: Locator;
    constructor(page: Page);
    url(): string;
}

declare class CheckoutFinish implements PageObject {
    readonly page: Page;
    readonly headline: Locator;
    readonly orderNumberText: Locator;
    readonly grandTotalPrice: Locator;
    readonly taxPrice: Locator;
    readonly cartLineItemImages: Locator;
    private readonly orderNumberRegex;
    constructor(page: Page);
    url(): string;
    getOrderNumber(): Promise<string | null>;
    getOrderId(): string | null;
}

declare class CheckoutRegister implements PageObject {
    readonly page: Page;
    readonly cartLineItemImages: Locator;
    constructor(page: Page);
    url(): string;
}

declare class Account implements PageObject {
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes['InstanceMeta'];
    readonly headline: Locator;
    readonly personalDataCardTitle: Locator;
    readonly paymentMethodCardTitle: Locator;
    readonly billingAddressCardTitle: Locator;
    readonly shippingAddressCardTitle: Locator;
    readonly newsletterCheckbox: Locator;
    readonly newsletterRegistrationSuccessMessage: Locator;
    readonly customerGroupRequestMessage: Locator;
    readonly cannotDeliverToCountryAlert: Locator;
    readonly shippingToAddressNotPossibleAlert: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes['InstanceMeta']);
    getCustomerGroupAlert(customerGroup: string): Promise<Locator>;
    url(): string;
}

declare class AccountLogin implements PageObject {
    readonly page: Page;
    readonly emailInput: Locator;
    readonly passwordInput: Locator;
    readonly forgotPasswordLink: Locator;
    readonly loginButton: Locator;
    readonly logoutLink: Locator;
    readonly successAlert: Locator;
    readonly invalidCredentialsAlert: Locator;
    readonly passwordUpdatedAlert: Locator;
    readonly personalFormArea: Locator;
    readonly billingAddressFormArea: Locator;
    readonly accountTypeSelect: Locator;
    readonly salutationSelect: Locator;
    readonly firstNameInput: Locator;
    readonly lastNameInput: Locator;
    readonly companyInput: Locator;
    readonly departmentInput: Locator;
    readonly vatRegNoInput: Locator;
    readonly registerEmailInput: Locator;
    readonly registerPasswordInput: Locator;
    readonly streetAddressInput: Locator;
    readonly cityInput: Locator;
    readonly countryInput: Locator;
    readonly postalCodeInput: Locator;
    readonly registerButton: Locator;
    readonly greCaptchaV2Container: Locator;
    readonly greCaptchaV2Input: Locator;
    readonly greCaptchaV3Input: Locator;
    readonly greCaptchaProtectionInformation: Locator;
    readonly greCaptchaBadge: Locator;
    readonly differentShippingAddressCheckbox: Locator;
    readonly registerShippingAddressFormArea: Locator;
    readonly shippingAddressSalutationSelect: Locator;
    readonly shippingAddressFirstNameInput: Locator;
    readonly shippingAddressLastNameInput: Locator;
    readonly shippingAddressStreetAddressInput: Locator;
    readonly shippingAddressCityInput: Locator;
    readonly shippingAddressCountryInput: Locator;
    readonly shippingAddressPostalCodeInput: Locator;
    readonly shippingAddressStateInput: Locator;
    constructor(page: Page);
    getShippingCountryLocatorByName(countryName: string): Promise<Locator>;
    url(): string;
}

declare class AccountRecover implements PageObject {
    readonly page: Page;
    readonly passwordRecoveryForm: Locator;
    readonly title: Locator;
    readonly subtitle: Locator;
    readonly emailInput: Locator;
    readonly requestEmailButton: Locator;
    readonly backButton: Locator;
    readonly passwordResetEmailSentMessage: Locator;
    readonly newPasswordInput: Locator;
    readonly newPasswordConfirmInput: Locator;
    readonly changePasswordButton: Locator;
    readonly invalidLinkMessage: Locator;
    constructor(page: Page);
    url(recoverLink?: string): string;
}

declare class AccountProfile implements PageObject {
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes['InstanceMeta'];
    readonly salutationSelect: Locator;
    readonly firstNameInput: Locator;
    readonly lastNameInput: Locator;
    readonly saveProfileButton: Locator;
    readonly changeEmailButton: Locator;
    readonly emailAddressInput: Locator;
    readonly emailAddressConfirmInput: Locator;
    readonly emailConfirmPasswordInput: Locator;
    readonly saveEmailAddressButton: Locator;
    readonly changePasswordButton: Locator;
    readonly newPasswordInput: Locator;
    readonly newPasswordConfirmInput: Locator;
    readonly currentPasswordInput: Locator;
    readonly saveNewPasswordButton: Locator;
    readonly loginDataEmailAddress: Locator;
    readonly emailUpdateMessage: Locator;
    readonly passwordUpdateMessage: Locator;
    readonly emailValidationAlert: Locator;
    readonly emailUpdateFailureAlert: Locator;
    readonly passwordUpdateFailureAlert: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes['InstanceMeta']);
    url(): string;
}

declare class AccountOrder implements PageObject {
    readonly page: Page;
    readonly cartLineItemImages: Locator;
    readonly orderExpandButton: Locator;
    readonly digitalProductDownloadButton: Locator;
    readonly dialogOrderCancel: Locator;
    readonly dialogOrderCancelButton: Locator;
    readonly dialogBackButton: Locator;
    readonly orderDetails: Locator;
    readonly invoiceHTML: Locator;
    readonly creditItem: Locator;
    constructor(page: Page);
    getOrderByOrderNumber(orderNumber: string): Promise<Record<string, Locator>>;
    url(): string;
}

declare class AccountAddresses implements PageObject {
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes['InstanceMeta'];
    readonly addNewAddressButton: Locator;
    readonly editBillingAddressButton: Locator;
    readonly editShippingAddressButton: Locator;
    readonly useDefaultBillingAddressButton: Locator;
    readonly useDefaultShippingAddressButton: Locator;
    readonly deliveryNotPossibleAlert: Locator | undefined;
    readonly availableAddresses: Locator | undefined;
    readonly addressDropdownButton: Locator | undefined;
    readonly addressDropdownButtons: Locator | undefined;
    readonly availableAddressesUseAsBillingAddress: Locator | undefined;
    readonly availableAddressesUseAsShippingAddress: Locator | undefined;
    constructor(page: Page, instanceMeta: HelperFixtureTypes['InstanceMeta']);
    url(): string;
}

declare class AccountPayment implements PageObject {
    readonly page: Page;
    readonly cashOnDeliveryOption: Locator;
    readonly paidInAdvanceOption: Locator;
    readonly invoiceOption: Locator;
    readonly changeDefaultPaymentButton: Locator;
    constructor(page: Page);
    url(): string;
}

declare class Search implements PageObject {
    readonly page: Page;
    readonly headline: Locator;
    readonly productImages: Locator;
    constructor(page: Page);
    url(searchTerm: string): string;
}

declare class SearchSuggest extends Home implements PageObject {
    readonly page: Page;
    readonly searchSuggestLineItemImages: Locator;
    readonly searchInput: Locator;
    readonly searchIcon: Locator;
    readonly searchSuggestNoResult: Locator;
    readonly searchSuggestLineItemName: Locator;
    readonly searchSuggestLineItemPrice: Locator;
    readonly searchSuggestTotalLink: Locator;
    readonly searchResultTotal: Locator;
    readonly searchHeadline: Locator;
    constructor(page: Page);
    getTotalSearchResultCount(): Promise<number>;
    url(searchTerm?: string): string;
}

declare class CustomRegister extends AccountLogin implements PageObject {
    readonly page: Page;
    constructor(page: Page);
    url(customCustomerGroupName?: string): string;
}

declare class CheckoutOrderEdit implements PageObject {
    readonly page: Page;
    readonly completePaymentButton: Locator;
    readonly orderCancelButton: Locator;
    readonly dialogOrderCancel: Locator;
    readonly dialogOrderCancelButton: Locator;
    readonly dialogBackButton: Locator;
    /**
     * Payment options
     */
    readonly paymentCashOnDelivery: Locator;
    readonly paymentPaidInAdvance: Locator;
    readonly paymentInvoice: Locator;
    /**
     * Shipping options
     */
    readonly shippingStandard: Locator;
    readonly shippingExpress: Locator;
    constructor(page: Page);
    url(orderUuid: string): string;
    /**
     * Returns the radio button element for a specified payment method.
     *
     * @param paymentMethodName - Name of the payment method on the page.
     */
    getPaymentMethodButton(paymentMethodName: string): Locator;
}

declare class AccountAddressCreate implements PageObject {
    readonly page: Page;
    readonly salutationDropdown: Locator;
    readonly firstNameInput: Locator;
    readonly lastNameInput: Locator;
    readonly companyInput: Locator;
    readonly departmentInput: Locator;
    readonly streetInput: Locator;
    readonly zipcodeInput: Locator;
    readonly cityInput: Locator;
    readonly countryDropdown: Locator;
    readonly saveAddressButton: Locator;
    readonly stateDropdown: Locator;
    constructor(page: Page);
    url(): string;
}

declare class PageNotFound implements PageObject {
    readonly page: Page;
    readonly pageNotFoundImage: Locator;
    readonly headline: Locator;
    readonly pageNotFoundMessage: Locator;
    readonly backToShopButton: Locator;
    constructor(page: Page);
    url(): string;
}

declare class ContactForm extends Home implements PageObject {
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes['InstanceMeta'];
    /**
     * @deprecated Compatible until shopware v6.6.x, will be removed in 6.8.0.0, use 'contactWrapper' instead
     */
    readonly contactModal: Locator | undefined;
    /**
     * @deprecated Compatible until shopware v6.6.x, will be removed in 6.8.0.0, use 'contactSuccessMessage' instead
     */
    readonly contactSuccessModal: Locator | undefined;
    readonly contactWrapper: Locator;
    readonly salutationSelect: Locator;
    readonly firstNameInput: Locator;
    readonly lastNameInput: Locator;
    readonly emailInput: Locator;
    readonly phoneInput: Locator;
    readonly subjectInput: Locator;
    readonly commentInput: Locator;
    readonly privacyPolicyCheckbox: Locator;
    readonly submitButton: Locator;
    readonly contactSuccessMessage: Locator;
    readonly cardTitle: Locator;
    readonly formFieldFeedback: Locator | undefined;
    readonly formAlert: Locator | undefined;
    /**
     *  Captcha locators
     */
    readonly basicCaptcha: Locator;
    readonly basicCaptchaImage: Locator;
    readonly basicCaptchaRefreshButton: Locator;
    readonly basicCaptchaInput: Locator;
    readonly greCaptchaV2Container: Locator;
    readonly greCaptchaV2Input: Locator;
    readonly greCaptchaProtectionInformation: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes['InstanceMeta']);
    url(): string;
}

declare class Wishlist extends Home implements PageObject {
    readonly page: Page;
    readonly wishListHeader: Locator;
    readonly removeAlert: Locator;
    readonly emptyListing: Locator;
    constructor(page: Page);
    getListingItemByProductName(productListingName: string): Promise<Record<string, Locator>>;
    url(): string;
}

declare class Footer implements PageObject {
    readonly page: Page;
    readonly footerHeadline: Locator;
    readonly footerContent: Locator;
    readonly footerHotline: Locator;
    readonly footerContactForm: Locator;
    readonly footerContactFormLink: Locator;
    constructor(page: Page);
    url(): string;
}

declare class Header implements PageObject {
    readonly page: Page;
    readonly mainNavigationLink: Locator;
    readonly languagesDropdown: Locator;
    readonly languagesMenuOptions: Locator;
    readonly currenciesDropdown: Locator;
    readonly currenciesMenuOptions: Locator;
    readonly wishlistIcon: Locator;
    readonly wishlistBasket: Locator;
    constructor(page: Page);
    url(): string;
}

interface StorefrontPageTypes {
    StorefrontHome: Home;
    StorefrontProductDetail: ProductDetail$1;
    StorefrontCategory: Category;
    StorefrontCheckoutCart: CheckoutCart;
    StorefrontOffCanvasCart: OffCanvasCart;
    StorefrontCheckoutConfirm: CheckoutConfirm;
    StorefrontCheckoutFinish: CheckoutFinish;
    StorefrontCheckoutRegister: CheckoutRegister;
    StorefrontAccount: Account;
    StorefrontAccountLogin: AccountLogin;
    StorefrontAccountRecover: AccountRecover;
    StorefrontAccountProfile: AccountProfile;
    StorefrontAccountOrder: AccountOrder;
    StorefrontAccountAddresses: AccountAddresses;
    StorefrontAccountAddressCreate: AccountAddressCreate;
    StorefrontAccountPayment: AccountPayment;
    StorefrontSearch: Search;
    StorefrontSearchSuggest: SearchSuggest;
    StorefrontCustomRegister: CustomRegister;
    StorefrontCheckoutOrderEdit: CheckoutOrderEdit;
    StorefrontPageNotFound: PageNotFound;
    StorefrontContactForm: ContactForm;
    StorefrontWishlist: Wishlist;
    StorefrontFooter: Footer;
    StorefrontHeader: Header;
}
declare const StorefrontPageObjects: {
    Home: typeof Home;
    ProductDetail: typeof ProductDetail$1;
    Category: typeof Category;
    CheckoutCart: typeof CheckoutCart;
    OffCanvasCart: typeof OffCanvasCart;
    CheckoutConfirm: typeof CheckoutConfirm;
    CheckoutFinish: typeof CheckoutFinish;
    CheckoutRegister: typeof CheckoutRegister;
    Account: typeof Account;
    AccountLogin: typeof AccountLogin;
    AccountRecover: typeof AccountRecover;
    AccountProfile: typeof AccountProfile;
    AccountOrder: typeof AccountOrder;
    AccountAddresses: typeof AccountAddresses;
    AccountAddressCreate: typeof AccountAddressCreate;
    AccountPayment: typeof AccountPayment;
    Search: typeof Search;
    SearchSuggest: typeof SearchSuggest;
    CustomRegister: typeof CustomRegister;
    CheckoutOrderEdit: typeof CheckoutOrderEdit;
    PageNotFound: typeof PageNotFound;
    ContactForm: typeof ContactForm;
    Wishlist: typeof Wishlist;
    Footer: typeof Footer;
    Header: typeof Header;
};

declare class ProductDetail implements PageObject {
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes['InstanceMeta'];
    readonly contentView: Locator;
    readonly productHeadline: Locator;
    /**
     * Save interactions
     */
    readonly savePhysicalProductButton: Locator;
    readonly saveButtonLoadingSpinner: Locator;
    readonly saveButtonCheckMark: Locator;
    /**
     * General Info
     */
    readonly manufacturerDropdownText: Locator;
    /**
     * Prices
     */
    readonly priceGrossInput: Locator;
    /**
     * Deliverability
     */
    readonly stockInput: Locator;
    readonly restockTimeInput: Locator;
    /**
     * Visibility
     */
    readonly activeForAllSalesChannelsToggle: Locator;
    readonly tagsInput: Locator;
    readonly saleChannelsInput: Locator;
    /**
     * Labelling
     */
    readonly releaseDateInput: Locator;
    /**
     * Media Upload interactions
     */
    readonly uploadMediaButton: Locator;
    readonly coverImage: Locator;
    readonly productImage: Locator;
    /**
     * Tabs
     */
    readonly variantsTabLink: Locator;
    readonly specificationsTabLink: Locator;
    readonly advancedPricingTabLink: Locator;
    readonly layoutTabLink: Locator;
    readonly crossSellingTabLink: Locator;
    readonly SEOTabLink: Locator;
    readonly reviewsTabLink: Locator;
    /**
     * Variants Generation
     */
    readonly generateVariantsButton: Locator;
    readonly variantsModal: Locator;
    readonly variantsModalHeadline: Locator;
    readonly variantsNextButton: Locator;
    readonly variantsSaveButton: Locator;
    /**
     * Property Selection
     */
    readonly propertyGroupColor: Locator;
    readonly propertyGroupSize: Locator;
    readonly propertyOptionGrid: Locator;
    readonly propertyOptionColorBlue: Locator;
    readonly propertyOptionColorRed: Locator;
    readonly propertyOptionColorGreen: Locator;
    readonly propertyOptionSizeSmall: Locator;
    readonly propertyOptionSizeMedium: Locator;
    readonly propertyOptionSizeLarge: Locator;
    /**
     * Cards
     */
    readonly customFieldCard: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes['InstanceMeta']);
    getCustomFieldSetCardContentByName(customFieldSetName: string): Promise<Record<string, Locator>>;
    url(productId: string): string;
    getCustomFieldCardLocators(customFieldSetName: string, customFieldTextName: string): Promise<{
        customFieldCard: Locator;
        customFieldSetTab: Locator;
        customFieldLabel: Locator;
        customFieldSelect: Locator;
    }>;
}

declare class OrderDetail implements PageObject {
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes['InstanceMeta'];
    readonly saveButton: Locator;
    readonly dataGridContextButton: Locator;
    readonly orderTag: Locator;
    readonly lineItem: Locator;
    readonly lineItemsTable: Locator;
    readonly documentType: Locator;
    readonly contextMenuButton: Locator;
    readonly contextMenu: Locator;
    readonly contextMenuSendDocument: Locator;
    readonly sendDocumentModal: Locator;
    readonly sendDocumentButton: Locator;
    readonly itemsCardHeader: Locator;
    readonly sentCheckmark: Locator;
    /**
     * Tabs
     */
    readonly generalTabLink: Locator;
    readonly detailsTabLink: Locator;
    readonly documentsTabLink: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes['InstanceMeta']);
    url(orderId: string, tabName?: string): string;
    getCustomFieldCardLocators(customFieldSetName: string, customFieldTextName: string): Promise<{
        customFieldCard: Locator;
        customFieldSetTab: Locator;
        customFieldLabel: Locator;
        customFieldSelect: Locator;
    }>;
}

declare class CustomerListing implements PageObject {
    readonly page: Page;
    readonly headline: Locator;
    readonly addCustomerButton: Locator;
    readonly bulkEditButton: Locator;
    readonly deleteButton: Locator;
    readonly bulkEditModal: Locator;
    readonly startBulkEditButton: Locator;
    readonly cancelButton: Locator;
    readonly modalHeaderCheckbox: Locator;
    constructor(page: Page);
    getCustomerByEmail(customerEmail: string): Promise<Record<string, Locator>>;
    getCustomerBulkEditModalTitle(customerCount: number): Promise<Locator>;
    getBulkEditModalLineItemByCustomerEmail(customerEmail: string): Promise<Record<string, Locator>>;
    url(): string;
}

declare class CustomerDetail implements PageObject {
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes['InstanceMeta'];
    readonly editButton: Locator;
    readonly generalTab: Locator;
    readonly accountCard: Locator;
    readonly customFieldCard: Locator;
    readonly customFieldSetTabs: Locator;
    readonly customFieldSetTabCustomContent: Locator;
    readonly customerGroupRequestMessage: Locator;
    readonly customerGroupAcceptButton: Locator;
    readonly customerGroupDeclineButton: Locator;
    readonly tagList: Locator;
    readonly tagItems: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes['InstanceMeta']);
    getCustomFieldSetCardContentByName(customFieldSetName: string): Promise<Record<string, Locator>>;
    getCustomerGroupAlert(customerGroup: string): Promise<Locator>;
    getCustomerGroup(): Promise<Locator>;
    getAccountStatus(): Promise<Locator>;
    getLanguage(): Promise<Locator>;
    url(customerId: string): string;
}

declare class CustomerGroupListing implements PageObject {
    readonly page: Page;
    readonly headline: Locator;
    readonly addCustomerGroupButton: Locator;
    constructor(page: Page);
    getCustomerGroupByName(customerGroup: string): Promise<Record<string, Locator>>;
    url(): string;
}

declare class CustomerGroupCreate implements PageObject {
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes['InstanceMeta'];
    readonly headline: Locator;
    readonly saveButton: Locator;
    readonly cancelButton: Locator;
    readonly cardTitle: Locator;
    readonly customerGroupNameField: Locator;
    readonly customerGroupGrossTaxDisplay: Locator;
    readonly customerGroupNetTaxDisplay: Locator;
    readonly customSignupFormToggle: Locator;
    readonly signupFormTitle: Locator;
    readonly signupFormIntroduction: Locator;
    readonly signupFormSeoDescription: Locator;
    readonly signupFormCompanySignupToggle: Locator;
    readonly customerGroupSaleschannelSelection: Locator;
    readonly customerGroupSaleschannelResultList: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes['InstanceMeta']);
    url(): string;
}

declare class CustomerGroupDetail extends CustomerGroupCreate implements PageObject {
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes['InstanceMeta'];
    readonly headline: Locator;
    readonly selectedSalesChannel: Locator;
    readonly technicalUrl: Locator;
    readonly saleschannelUrl: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes['InstanceMeta']);
    url(customerGroupId?: string): string;
}

declare class FirstRunWizard implements PageObject {
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes['InstanceMeta'];
    readonly nextButton: Locator;
    readonly configureLaterButton: Locator;
    readonly skipButton: Locator;
    readonly finishButton: Locator;
    readonly backButton: Locator;
    readonly smtpServerButton: Locator;
    readonly dataImportHeader: Locator;
    readonly installLanguagePackButton: Locator;
    readonly installDemoDataButton: Locator;
    readonly installMigrationAssistantButton: Locator;
    readonly defaultValuesHeader: Locator;
    readonly mailerConfigurationHeader: Locator;
    readonly payPalSetupHeader: Locator;
    readonly extensionsHeader: Locator;
    readonly shopwareAccountHeader: Locator;
    readonly shopwareStoreHeader: Locator;
    readonly doneHeader: Locator;
    readonly frwSuccessText: Locator;
    readonly welcomeText: Locator;
    readonly pluginCardInfo: Locator;
    readonly dataImportCard: Locator;
    readonly salesChannelSelectionList: Locator;
    readonly salesChannelSelectionMultiSelect: Locator;
    readonly smtpServerTitle: Locator;
    /**
     * @deprecated - Use `smtpServerFieldInputs` instead.
     */
    readonly smtpServerFields: Locator;
    readonly smtpServerFieldInputs: Locator;
    readonly smtpServerHostInput: Locator;
    readonly smtpServerPortInput: Locator;
    readonly smtpServerUsernameInput: Locator;
    readonly smtpServerPasswordInput: Locator;
    readonly smtpServerEncryptionInput: Locator;
    readonly smtpServerSenderAddressInput: Locator;
    readonly smtpServerDeliveryAddressInput: Locator;
    readonly smtpServerDisableEmailDeliveryCheckbox: Locator;
    readonly payPalPaymethods: Locator;
    readonly payPalInfoCard: Locator;
    readonly emailAddressInputField: Locator;
    readonly passwordInputField: Locator;
    readonly forgotPasswordLink: Locator;
    readonly extensionStoreHeading: Locator;
    readonly documentationLink: Locator;
    readonly forumLink: Locator;
    readonly roadmapLink: Locator;
    readonly germanRegionSelector: Locator;
    readonly toolsSelector: Locator;
    readonly recommendationHeader: Locator;
    readonly toolsRecommendedPlugin: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes['InstanceMeta']);
    url(): string;
}

declare class FlowBuilderCreate implements PageObject {
    readonly page: Page;
    readonly saveButton: Locator;
    readonly header: Locator;
    readonly nameField: Locator;
    readonly flowTab: Locator;
    readonly triggerSelectField: Locator;
    readonly addActionField: Locator;
    readonly smartBarHeader: Locator;
    readonly newFlowHeader: Locator;
    constructor(page: Page);
    url(flowId?: string, tabName?: string): string;
}

declare class FlowBuilderListing implements PageObject {
    readonly page: Page;
    readonly createFlowButton: Locator;
    readonly firstFlowName: Locator;
    readonly firstFlowContextButton: Locator;
    readonly flowContextMenu: Locator;
    readonly contextMenuDownload: Locator;
    readonly contextMenuDuplicate: Locator;
    readonly contextMenuEdit: Locator;
    readonly contextMenuDelete: Locator;
    readonly flowDownloadModal: Locator;
    readonly downloadFlowButton: Locator;
    readonly flowDeleteButton: Locator;
    readonly successAlert: Locator;
    readonly successAlertMessage: Locator;
    readonly searchBar: Locator;
    constructor(page: Page);
    url(): string;
    getLineItemByFlowName(flowName: string): Promise<Record<string, Locator>>;
}

declare class FlowBuilderTemplates extends FlowBuilderListing implements PageObject {
    readonly page: Page;
    constructor(page: Page);
    url(): string;
    getLineItemByFlowName(flowName: string): Promise<{
        createFlowLink: _playwright_test.Locator;
        lineItem: _playwright_test.Locator;
        templateDetailLink: _playwright_test.Locator;
    }>;
}

declare class FlowBuilderDetail extends FlowBuilderCreate implements PageObject {
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes['InstanceMeta'];
    readonly saveButtonLoader: Locator;
    readonly saveButton: Locator;
    readonly generalTab: Locator;
    readonly flowTab: Locator;
    readonly alertWarning: Locator;
    readonly templateName: Locator;
    readonly alertMessage: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes['InstanceMeta']);
    url(flowId: string, tabName?: string): string;
}

declare class DataSharing implements PageObject {
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes['InstanceMeta'];
    readonly dataConsentHeadline: Locator;
    readonly dataSharingSuccessMessageLabel: Locator;
    readonly dataSharingAgreeButton: Locator;
    readonly dataSharingDisableButton: Locator;
    readonly dataSharingTermsAgreementLabel: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes['InstanceMeta']);
    url(): "#/sw/settings/usage/data/index" | "#/sw/settings/usage/data/index/general";
}

declare class Dashboard implements PageObject {
    readonly page: Page;
    readonly contentView: Locator;
    readonly adminMenuView: Locator;
    readonly adminMenuCatalog: Locator;
    readonly adminMenuOrder: Locator;
    readonly adminMenuCustomer: Locator;
    readonly adminMenuContent: Locator;
    readonly adminMenuMarketing: Locator;
    readonly adminMenuExtension: Locator;
    readonly adminMenuUserChevron: Locator;
    readonly adminMenuUserIcon: Locator;
    readonly adminMenuUserName: Locator;
    readonly welcomeHeadline: Locator;
    readonly welcomeMessage: Locator;
    readonly dataSharingConsentBanner: Locator;
    readonly dataSharingAgreeButton: Locator;
    readonly dataSharingNotAtTheMomentButton: Locator;
    readonly dataSharingTermsAgreementLabel: Locator;
    readonly dataSharingSettingsLink: Locator;
    readonly dataSharingAcceptMessageText: Locator;
    readonly dataSharingNotAtTheMomentMessageText: Locator;
    readonly statisticsDateRange: Locator;
    readonly statisticsChart: Locator;
    constructor(page: Page);
    url(): string;
}

declare class ShippingListing implements PageObject {
    readonly page: Page;
    readonly header: Locator;
    readonly addShippingMethod: Locator;
    readonly contextMenu: Locator;
    readonly editButton: Locator;
    readonly deleteButton: Locator;
    readonly modal: Locator;
    readonly modalHeader: Locator;
    readonly modalCancelButton: Locator;
    readonly modalDeleteButton: Locator;
    constructor(page: Page);
    url(): string;
}

declare class ShippingDetail implements PageObject {
    readonly page: Page;
    readonly header: Locator;
    readonly nameField: Locator;
    readonly availabilityRuleField: Locator;
    readonly availabilityRuleListItem: Locator;
    constructor(page: Page);
    url(shippingId: string): string;
    getRuleSelectionCheckmark(ruleName: string): Locator;
}

declare class PaymentDetail implements PageObject {
    readonly page: Page;
    readonly header: Locator;
    readonly nameField: Locator;
    readonly availabilityRuleField: Locator;
    readonly availabilityRuleListItem: Locator;
    constructor(page: Page);
    url(paymentId: string): string;
    getRuleSelectionCheckmark(ruleName: string): Locator;
}

declare class LandingPageCreate implements PageObject {
    readonly page: Page;
    /**
     * General
     */
    readonly nameInput: Locator;
    readonly landingPageStatus: Locator;
    readonly salesChannelSelectionList: Locator;
    readonly filtersResultPopoverItemList: Locator;
    readonly saveLandingPageButton: Locator;
    readonly loadingSpinner: Locator;
    readonly seoUrlInput: Locator;
    /**
     * Layout
     */
    readonly layoutTab: Locator;
    readonly assignLayoutButton: Locator;
    readonly searchLayoutInput: Locator;
    readonly layoutItems: Locator;
    readonly layoutSaveButton: Locator;
    readonly layoutEmptyState: Locator;
    readonly createNewLayoutButton: Locator;
    readonly layoutCheckboxes: Locator;
    constructor(page: Page);
    url(): string;
}

declare class LandingPageDetail implements PageObject {
    readonly page: Page;
    /**
     * General
     */
    readonly nameInput: Locator;
    readonly landingPageStatus: Locator;
    readonly salesChannelSelectionList: Locator;
    readonly filtersResultPopoverItemList: Locator;
    readonly saveLandingPageButton: Locator;
    readonly loadingSpinner: Locator;
    readonly seoUrlInput: Locator;
    /**
     * Layout
     */
    readonly layoutTab: Locator;
    readonly layoutAssignmentCardTitle: Locator;
    readonly layoutAssignmentCardHeadline: Locator;
    readonly changeLayoutButton: Locator;
    readonly editInDesignerButton: Locator;
    readonly layoutResetButton: Locator;
    readonly layoutAssignmentStatus: Locator;
    readonly layoutAssignmentContentSection: Locator;
    constructor(page: Page);
    url(landingPageUuid: string): string;
}

declare class Categories implements PageObject {
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes['InstanceMeta'];
    /**
     * Visual tests
     */
    readonly contentView: Locator;
    /**
     * Landing pages
     */
    readonly landingPageArea: Locator;
    readonly landingPageHeadline: Locator;
    readonly addLandingPageButton: Locator;
    readonly landingPageItems: Locator;
    /**
     * Category tree
     */
    readonly categoryTree: Locator;
    readonly categoryMenuItemList: Locator;
    readonly createCategoryInput: Locator;
    readonly confirmCategoryCreationButton: Locator;
    readonly confirmCategoryCancelButton: Locator;
    readonly categoryItems: Locator;
    /**
     * Tabs
     */
    readonly generalTab: Locator;
    readonly productsTab: Locator;
    readonly layoutTab: Locator;
    readonly seoTab: Locator;
    /**
     * General
     */
    readonly nameInput: Locator;
    readonly activeCheckbox: Locator;
    readonly categoryTypeSelectionList: Locator;
    readonly filtersResultPopoverItemList: Locator;
    readonly saveButton: Locator;
    readonly loadingSpinner: Locator;
    readonly fadingBar: Locator;
    readonly configureHomePageButton: Locator;
    readonly configureModalCancelButton: Locator;
    /**
     * Customisable link
     */
    readonly entitySelectionList: Locator;
    readonly linkTypeSelectionList: Locator;
    readonly categorySelectionList: Locator;
    readonly productSelectionList: Locator;
    readonly landingPageSelectionList: Locator;
    readonly filterResultPopoverTreeCheckboxItemList: Locator;
    readonly openInNewTabCheckbox: Locator;
    readonly popoverCategoryTree: Locator;
    readonly categorySelectionListWrapper: Locator;
    readonly productSelectionInput: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes['InstanceMeta']);
    getLandingPageByName(landingPageName: string): Promise<Locator>;
    getPopOverCategoryByName(categoryName: string): Promise<Locator>;
    getTreeItemContextButton(name: string): Locator;
    url(): string;
}

declare class CustomFieldListing implements PageObject {
    readonly page: Page;
    readonly addNewSetButton: Locator;
    readonly customFieldRows: Locator;
    constructor(page: Page);
    getLineItemByCustomFieldSetName(customFieldSetName: string): Promise<Record<string, Locator>>;
    url(): string;
}

declare class CustomFieldCreate implements PageObject {
    readonly page: Page;
    readonly saveButton: Locator;
    readonly cancelButton: Locator;
    readonly technicalNameInput: Locator;
    readonly positionInput: Locator;
    readonly labelEnglishGBInput: Locator;
    readonly assignToSelectionList: Locator;
    readonly resultAssignToPopoverItemList: Locator;
    constructor(page: Page);
    url(): string;
}

declare class CustomFieldDetail extends CustomFieldCreate {
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes['InstanceMeta'];
    readonly newCustomFieldButton: Locator;
    readonly customFieldEditDialog: Locator;
    readonly newCustomFieldDialog: Locator;
    readonly customFieldTechnicalNameInput: Locator;
    readonly customFieldPositionInput: Locator;
    readonly customFieldTypeSelectionList: Locator;
    readonly customFieldModifyByStoreApiCheckbox: Locator;
    readonly customFieldCancelButton: Locator;
    readonly customFieldAddButton: Locator;
    readonly customFieldEditApplyButton: Locator;
    readonly customFieldLabelEnglishGBInput: Locator;
    readonly customFieldPlaceholderEnglishGBInput: Locator;
    readonly customFieldHelpTextEnglishGBInput: Locator;
    readonly customFieldDeleteListButton: Locator;
    readonly customFieldDeleteDialog: Locator;
    readonly customFieldDeleteCancelButton: Locator;
    readonly customFieldDeleteButton: Locator;
    readonly customFieldEditAvailableInShoppingCartCheckbox: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes['InstanceMeta']);
    getLineItemByCustomFieldName(customFieldName: string): Promise<Record<string, Locator>>;
    url(customFieldUuid?: string): string;
    getSelectFieldListitem(selectField: Locator, listItem: string): Promise<Locator>;
}

declare class CategoryDetail implements PageObject {
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes['InstanceMeta'];
    readonly saveButton: Locator;
    readonly cancelButton: Locator;
    readonly customFieldCard: Locator;
    readonly customFieldSetTabs: Locator;
    readonly customFieldSetTabCustomContent: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes['InstanceMeta']);
    getCustomFieldSetCardContentByName(customFieldSetName: string): Promise<Record<string, Locator>>;
    url(categoryUuid: string): string;
    getCustomFieldCardLocators(customFieldSetName: string, customFieldTextName: string): Promise<{
        customFieldCard: Locator;
        customFieldSetTab: Locator;
        customFieldLabel: Locator;
        customFieldSelect: Locator;
    }>;
}

declare class RuleCreate implements PageObject {
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes['InstanceMeta'];
    readonly nameInput: Locator;
    readonly priorityInput: Locator;
    readonly conditionTypeSelectionInput: Locator;
    readonly conditionValueSelectionInput: Locator;
    readonly filtersResultPopoverSelectionList: Locator;
    readonly saveButton: Locator;
    readonly cancelButton: Locator;
    readonly valueNotAvailableTooltip: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes['InstanceMeta']);
    url(): string;
    getSelectFieldListitem(selectField: Locator, listItem: string): Promise<Locator>;
}

declare class RuleDetail extends RuleCreate implements PageObject {
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes['InstanceMeta'];
    readonly shippingMethodAvailabilityRulesCard: Locator;
    readonly shippingMethodAvailabilityRulesCardLink: Locator;
    readonly shippingMethodAvailabilityRulesCardTable: Locator;
    readonly shippingMethodAvailabilityRulesCardEmptyState: Locator;
    readonly shippingMethodAvailabilityRulesCardSearchField: Locator;
    readonly taxProviderRulesCard: Locator;
    readonly taxProviderRulesCardEmptyState: Locator;
    readonly paymentMethodsAvailabilityRulesCard: Locator;
    readonly paymentMethodsAvailabilityRulesCardEmptyState: Locator;
    readonly paymentMethodsAvailabilityRulesCardLink: Locator;
    readonly promotionOrderRulesCard: Locator;
    readonly promotionOrderRulesCardEmptyState: Locator;
    readonly promotionCustomerRulesCard: Locator;
    readonly promotionCustomerRulesCardEmptyState: Locator;
    readonly promotionCartRulesCard: Locator;
    readonly promotionCartRulesCardEmptyState: Locator;
    readonly assignmentModalAddButton: Locator;
    readonly assignmentModalSearchField: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes['InstanceMeta']);
    getEntityCard(cardLocator: Locator): Promise<Record<string, Locator>>;
    url(ruleId?: string, tabName?: string): string;
}

declare class RuleListing implements PageObject {
    readonly page: Page;
    readonly createRuleButton: Locator;
    constructor(page: Page);
    url(): string;
}

declare class ManufacturerCreate implements PageObject {
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes['InstanceMeta'];
    readonly saveButton: Locator;
    readonly cancelButton: Locator;
    readonly nameInput: Locator;
    readonly websiteInput: Locator;
    readonly descriptionInput: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes['InstanceMeta']);
    url(): string;
}

declare class ManufacturerListing implements PageObject {
    readonly page: Page;
    readonly addManufacturerButton: Locator;
    readonly manufacturerRows: Locator;
    constructor(page: Page);
    getLineItemByManufacturerName(manufacturerName: string): Promise<Record<string, Locator>>;
    url(): string;
}

declare class ManufacturerDetail extends ManufacturerCreate {
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes['InstanceMeta'];
    readonly customFieldCard: Locator;
    readonly customFieldSetTabs: Locator;
    readonly customFieldSetTabCustomContent: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes['InstanceMeta']);
    getCustomFieldSetCardContentByName(customFieldSetName: string): Promise<Record<string, Locator>>;
    url(manufacturerUuid?: string): string;
}

declare class ProductListing implements PageObject {
    readonly page: Page;
    /**
     * Multi selection
     */
    readonly productsTable: Locator;
    readonly bulkEditButton: Locator;
    /**
     * Bulk edit modal
     */
    readonly bulkEditModal: Locator;
    readonly startBulkEditButton: Locator;
    constructor(page: Page);
    /**
     * Returns the url to the listing page.
     *
     * @param searchTerms - Includes search terms for filtering of the product list.
     */
    url(searchTerms?: string[]): string;
    /**
     * Returns the table row containing the product with the given product number.
     *
     * @param productNumber - Product number you are looking for.
     */
    getProductRow(productNumber: string): Promise<Record<string, Locator>>;
}

declare class ProductBulkEdit implements PageObject {
    readonly page: Page;
    /**
     * Bulk edit values
     */
    readonly changeManufacturerRow: Locator;
    readonly changeManufacturerCheckbox: Locator;
    readonly manufacturerDropdown: Locator;
    readonly manufacturerDropdownInput: Locator;
    readonly manufacturerListResult: Locator;
    readonly changeActiveRow: Locator;
    readonly changeActiveCheckbox: Locator;
    readonly activeToggle: Locator;
    readonly changePriceRow: Locator;
    readonly changePriceCheckbox: Locator;
    readonly grossPriceInput: Locator;
    readonly changeReleaseDateRow: Locator;
    readonly changeReleaseDateCheckbox: Locator;
    readonly releaseDateInput: Locator;
    readonly changeStockRow: Locator;
    readonly changeStockCheckbox: Locator;
    readonly stockChangeMethodDropdown: Locator;
    readonly stockChangeMethodInput: Locator;
    readonly stockInput: Locator;
    readonly changeRestockTimeRow: Locator;
    readonly changeRestockTimeCheckbox: Locator;
    readonly restockTimeChangeMethodDropdown: Locator;
    readonly restockTimeChangeMethodInput: Locator;
    readonly restockTimeInput: Locator;
    readonly changeTagsRow: Locator;
    readonly changeTagsCheckbox: Locator;
    readonly tagsChangeMethodDropdown: Locator;
    readonly tagsChangeMethodInput: Locator;
    readonly tagsInput: Locator;
    readonly changeSalesChannelRow: Locator;
    readonly changeSalesChannelCheckbox: Locator;
    readonly salesChannelChangeMethodDropdown: Locator;
    readonly salesChannelChangeMethodInput: Locator;
    readonly salesChannelInput: Locator;
    readonly applyChangesButton: Locator;
    /**
     * Confirmation modal
     */
    readonly confirmModal: Locator;
    readonly confirmModalApplyChangesButton: Locator;
    readonly confirmModalLoadingSpinner: Locator;
    readonly confirmModalSuccessHeader: Locator;
    readonly confirmModalSuccessCloseButton: Locator;
    constructor(page: Page);
    url(): string;
    getDropdownEntry(entry: string): Promise<Locator>;
}

declare class CustomerBulkEdit implements PageObject {
    readonly page: Page;
    readonly applyChangesButton: Locator;
    readonly filtersResultPopoverItemList: Locator;
    readonly changeCustomerGroupCheckbox: Locator;
    readonly customerGroupInput: Locator;
    readonly changeAccountStatusCheckbox: Locator;
    readonly accountStatusInput: Locator;
    readonly changeLanguageCheckbox: Locator;
    readonly changeLanguageInput: Locator;
    readonly replyToCustomerGroupRequest: Locator;
    readonly replyToCustomerGroupRequestInput: Locator;
    readonly changeTagsCheckbox: Locator;
    readonly changeTypeSelect: Locator;
    readonly enterTagsSelect: Locator;
    readonly customFieldCheckbox: Locator;
    readonly customFieldInput: Locator;
    readonly customFieldArrowRightButton: Locator;
    /**
     * Confirmation modal
     */
    readonly confirmModal: Locator;
    readonly confirmModalApplyChangesButton: Locator;
    readonly confirmModalSuccessHeader: Locator;
    readonly confirmModalSuccessCloseButton: Locator;
    constructor(page: Page);
    getPageHeadline(customerCount: number): Promise<Locator>;
    getCustomFieldInputByName(customFieldName: string): Promise<Locator>;
    getCustomFieldLinkByName(customFieldSetName: string): Promise<Locator>;
    url(): string;
}

declare class SettingsListing implements PageObject {
    readonly page: Page;
    readonly contentView: Locator;
    readonly header: Locator;
    constructor(page: Page);
    url(): string;
}

declare class DocumentListing implements PageObject {
    readonly page: Page;
    readonly addDocumentButton: Locator;
    readonly invoiceLink: Locator;
    constructor(page: Page);
    url(): string;
}

declare class DocumentDetail implements PageObject {
    readonly page: Page;
    readonly showInAccountSwitch: Locator;
    readonly saveButton: Locator;
    readonly documentTypeSelect: Locator;
    constructor(page: Page);
    url(documentId: string): string;
}

interface AdministrationPageTypes {
    AdminProductDetail: ProductDetail;
    AdminOrderDetail: OrderDetail;
    AdminCustomerListing: CustomerListing;
    AdminCustomerDetail: CustomerDetail;
    AdminCustomerGroupListing: CustomerGroupListing;
    AdminCustomerGroupCreate: CustomerGroupCreate;
    AdminCustomerGroupDetail: CustomerGroupDetail;
    AdminFirstRunWizard: FirstRunWizard;
    AdminFlowBuilderCreate: FlowBuilderCreate;
    AdminFlowBuilderListing: FlowBuilderListing;
    AdminFlowBuilderTemplates: FlowBuilderTemplates;
    AdminFlowBuilderDetail: FlowBuilderDetail;
    AdminDataSharing: DataSharing;
    AdminDashboard: Dashboard;
    AdminShippingListing: ShippingListing;
    AdminShippingDetail: ShippingDetail;
    AdminPaymentDetail: PaymentDetail;
    AdminCategories: Categories;
    AdminCategoryDetail: CategoryDetail;
    AdminLandingPageCreate: LandingPageCreate;
    AdminLandingPageDetail: LandingPageDetail;
    AdminCustomFieldListing: CustomFieldListing;
    AdminCustomFieldCreate: CustomFieldCreate;
    AdminCustomFieldDetail: CustomFieldDetail;
    AdminRuleDetail: RuleDetail;
    AdminRuleCreate: RuleCreate;
    AdminRuleListing: RuleListing;
    AdminManufacturerCreate: ManufacturerCreate;
    AdminManufacturerListing: ManufacturerListing;
    AdminManufacturerDetail: ManufacturerDetail;
    AdminProductListing: ProductListing;
    AdminProductBulkEdit: ProductBulkEdit;
    AdminCustomerBulkEdit: CustomerBulkEdit;
    AdminSettingsListing: SettingsListing;
    AdminDocumentListing: DocumentListing;
    AdminDocumentDetail: DocumentDetail;
}
declare const AdminPageObjects: {
    ProductDetail: typeof ProductDetail;
    OrderDetail: typeof OrderDetail;
    CustomerListing: typeof CustomerListing;
    CustomerDetail: typeof CustomerDetail;
    CustomerGroupListing: typeof CustomerGroupListing;
    CustomerGroupCreate: typeof CustomerGroupCreate;
    CustomerGroupDetail: typeof CustomerGroupDetail;
    FirstRunWizard: typeof FirstRunWizard;
    FlowBuilderCreate: typeof FlowBuilderCreate;
    FlowBuilderListing: typeof FlowBuilderListing;
    FlowBuilderTemplates: typeof FlowBuilderTemplates;
    FlowBuilderDetail: typeof FlowBuilderDetail;
    Dashboard: typeof Dashboard;
    DataSharing: typeof DataSharing;
    ShippingListing: typeof ShippingListing;
    ShippingDetail: typeof ShippingDetail;
    PaymentDetail: typeof PaymentDetail;
    Categories: typeof Categories;
    CategoryDetail: typeof CategoryDetail;
    LandingPageCreate: typeof LandingPageCreate;
    LandingPageDetail: typeof LandingPageDetail;
    CustomFieldListing: typeof CustomFieldListing;
    CustomFieldCreate: typeof CustomFieldCreate;
    CustomFieldDetail: typeof CustomFieldDetail;
    RuleCreate: typeof RuleCreate;
    RuleDetail: typeof RuleDetail;
    RuleListing: typeof RuleListing;
    ManufacturerCreate: typeof ManufacturerCreate;
    ManufacturerDetail: typeof ManufacturerDetail;
    ManufacturerListing: typeof ManufacturerListing;
    ProductListing: typeof ProductListing;
    ProductBulkEdit: typeof ProductBulkEdit;
    CustomerBulkEdit: typeof CustomerBulkEdit;
    SettingsListing: typeof SettingsListing;
    DocumentListing: typeof DocumentListing;
    DocumentDetail: typeof DocumentDetail;
};

interface DataFixtureTypes {
    ProductData: Product;
    CategoryData: Category$1;
    DigitalProductData: {
        product: Product;
        fileContent: string;
    };
    PromotionWithCodeData: components['schemas']['Promotion'];
    CartWithProductData: Record<string, unknown>;
    PropertiesData: {
        propertyGroupColor: components['schemas']['PropertyGroup'];
        propertyGroupSize: components['schemas']['PropertyGroup'];
    };
    MediaData: components['schemas']['Media'];
    OrderData: Order;
    TagData: components['schemas']['Tag'];
}

/**
 * Service to interact with feature flags
 */
declare class FeatureService {
    private readonly apiContext;
    private features;
    private resetFeatures;
    constructor(apiContext: AdminApiContext);
    enable(name: string | string[]): Promise<void>;
    disable(name: string | string[]): Promise<void>;
    isEnabled(name: string): Promise<boolean>;
    private loadFeatures;
    cleanup(): Promise<void>;
}

interface FeatureFixtureTypes {
    FeatureService: FeatureService;
}

interface FixtureTypes extends ApiContextTypes, PageContextTypes, ActorFixtureTypes, TestDataFixtureTypes, HelperFixtureTypes, FeatureFixtureTypes, DefaultSalesChannelTypes, ShopwareDataFixtureTypes, StorefrontPageTypes, AdministrationPageTypes, DataFixtureTypes {
}

type Language = components['schemas']['Language'] & {
    id: string;
    translationCode: components['schemas']['Locale'] & {
        id: string;
    };
};
declare const getLanguageData: (languageCode: string, adminApiContext: AdminApiContext) => Promise<Language>;
declare const getSnippetSetId: (languageCode: string, adminApiContext: AdminApiContext) => Promise<string>;
type Currency = components['schemas']['Currency'] & {
    id: string;
};
declare const getCurrency: (isoCode: string, adminApiContext: AdminApiContext) => Promise<Currency>;
declare const getTaxId: (adminApiContext: AdminApiContext) => Promise<string>;
declare const getPaymentMethodId: (adminApiContext: AdminApiContext, handlerId?: string) => Promise<string>;
/**
 * Gives the default shipping method back called Standard
 * @param adminApiContext - An AdminApiContext entity
 *
 * @deprecated - Use getShippingMethodId instead
 */
declare const getDefaultShippingMethodId: (adminApiContext: AdminApiContext) => Promise<string>;
declare const getShippingMethodId: (name: string, adminApiContext: AdminApiContext) => Promise<string>;
declare const getCountryId: (iso2: string, adminApiContext: AdminApiContext) => Promise<string>;
declare const getThemeId: (technicalName: string, adminApiContext: AdminApiContext) => Promise<string>;
declare const getSalutationId: (salutationKey: string, adminApiContext: AdminApiContext) => Promise<string>;
declare const getStateMachineId: (technicalName: string, adminApiContext: AdminApiContext) => Promise<string>;
declare const getStateMachineStateId: (stateMachineId: string, adminApiContext: AdminApiContext) => Promise<string>;
declare const getFlowId: (flowName: string, adminApiContext: AdminApiContext) => Promise<string>;
declare const getOrderTransactionId: (orderId: string, adminApiContext: AdminApiContext) => Promise<{
    id: string;
}>;
declare const getMediaId: (fileName: string, adminApiContext: AdminApiContext) => Promise<string>;
declare const getFlowTemplate: (flowTemplateId: string, adminApiContext: AdminApiContext) => Promise<FlowTemplate>;
declare const getFlow: (flowId: string, adminApiContext: AdminApiContext) => Promise<Flow>;
declare const compareFlowTemplateWithFlow: (flowId: string, flowTemplateId: string, adminApiContext: AdminApiContext) => Promise<boolean>;
declare function extractIdFromUrl(url: string): string | null;
type OrderStatus = 'cancel' | 'complete' | 'reopen' | 'process';
declare const setOrderStatus: (orderId: string, orderStatus: OrderStatus, adminApiContext: AdminApiContext) => Promise<APIResponse>;
/**
 * Return a single promotion entity with a fetched single discount entity
 */
declare const getPromotionWithDiscount: (promotionId: string, adminApiContext: AdminApiContext) => Promise<Promotion>;

declare const isSaaSInstance: (adminApiContext: AdminApiContext) => Promise<boolean>;
declare const isThemeCompiled: (context: AdminApiContext, storefrontUrl: string) => Promise<boolean>;

declare function createRandomImage(width?: number, height?: number): Image;

/**
 * Hides the given page elements using `visibility: hidden`, so they become invisible
 * without affecting the layout (no realignment occurs).
 *
 * @param page - Playwright page object
 * @param selectors - CSS selectors for elements to hide
 */
declare function hideElements(page: Page, selectors: (string | Locator)[]): Promise<void>;
/**
 * Replaces the text content of selected elements with `***`.
 *
 * @param page - Playwright page object
 * @param selectors - CSS selectors for elements whose content to replace
 */
declare function replaceElements(page: Page, selectors: (string | Locator)[]): Promise<void>;
/**
 * Calculates the ideal viewport dimensions for a Playwright test based on scrollable content,
 * header visibility, and optional configuration. Useful for dynamic screenshot sizing or
 * testing long-scrolling pages.
 *
 * This function:
 * - Optionally waits for a network request (`requestURL`) before continuing.
 * - Optionally waits for a specific locator (`waitForLocator`) to become visible.
 * - Measures scrollable content height (`scrollableElementVertical`) and header height.
 * - Measures scrollable content width (`scrollableElementHorizontal`).
 * - Falls back to defaults if elements are not found or inaccessible.
 *
 * @param {Page} page - The Playwright `Page` object representing the current browser tab.
 * @param {Options} [options] - Optional configuration to override default behavior.
 * @param {string} [options.requestURL] - A URL substring to wait for via `waitForResponse`.
 * @param {number} [options.width] - Base viewport width to use (default: 1440).
 * @param {string | Locator} [options.scrollableElementVertical] - Selector or Locator for vertical scroll container.
 * @param {string | Locator} [options.scrollableElementHorizontal] - Selector or Locator for horizontal scroll container.
 * @param {number} [options.additionalHeight] - Extra height to add (e.g., to avoid cut-off).
 * @param {string | Locator} [options.waitForSelector] - A selector or Locator to wait for visibility before measuring.
 * @param {number} [options.contentHeight] - Default vertical height fallback if measurement fails.
 * @param {number} [options.headerHeight] - Default header height fallback.
 * @param {string} [options.headerElement] - Selector for a header element whose height should be added if outside scrollable container.
 *
 * @returns {Promise<{ contentWidth: number; totalHeight: number }>} - A Promise resolving to the measured dimensions:
 *   - `contentWidth`: the horizontal scroll width or fallback.
 *   - `totalHeight`: sum of content height, header height, and any additional height.
 */
interface Options {
    requestURL?: string;
    width?: number;
    scrollableElementVertical?: string | Locator;
    scrollableElementHorizontal?: string | Locator;
    additionalHeight?: number;
    waitForSelector?: string | Locator;
    contentHeight?: number;
    headerHeight?: number;
    headerElement?: string;
}
declare function setViewport(page: Page, options?: Options): Promise<void>;

declare const test: _playwright_test.TestType<_playwright_test.PlaywrightTestArgs & _playwright_test.PlaywrightTestOptions & FixtureTypes & {
    SaveProduct: Task;
} & {
    ExpectNotification: Task;
} & {
    CreateLinkTypeCategory: Task;
} & {
    BulkEditProducts: Task;
} & {
    BulkEditCustomers: Task;
} & {
    AssignEntitiesToRule: Task;
} & {
    LoginViaReviewsTab: Task;
} & {
    Login: Task;
} & {
    Logout: Task;
} & {
    Register: Task;
} & {
    RegisterGuest: Task;
} & {
    ChangeStorefrontCurrency: Task;
} & {
    AddNewAddress: Task;
} & {
    AddProductToCart: Task;
} & {
    ChangeProductQuantity: Task;
} & {
    ProceedFromProductToCheckout: Task;
} & {
    ProceedFromCartToCheckout: Task;
} & {
    ConfirmTermsAndConditions: Task;
} & {
    SelectInvoicePaymentOption: Task;
} & {
    SelectCashOnDeliveryPaymentOption: Task;
} & {
    SelectPaidInAdvancePaymentOption: Task;
} & {
    SelectStandardShippingOption: Task;
} & {
    SelectExpressShippingOption: Task;
} & {
    SubmitOrder: Task;
} & {
    OpenSearchResultPage: Task;
} & {
    OpenSearchSuggestPage: Task;
} & {
    SearchForTerm: Task;
} & {
    ValidateAccessibility: (pageName: string, assertViolations?: number | boolean | undefined, createReport?: boolean | undefined, ruleTags?: string[] | undefined, outputDir?: string | undefined) => () => Promise<axe_core.Result[]>;
} & {
    RemoveProductFromWishlist: Task;
} & {
    AddProductToCartFromWishlist: Task;
} & {
    AddProductToWishlist: Task;
} & {
    SelectProductFilterOption: Task;
}, _playwright_test.PlaywrightWorkerArgs & _playwright_test.PlaywrightWorkerOptions & FixtureTypes>;

export { type AccountData, type Address, AdminPageObjects, type CalculatedTaxes, type Category$1 as Category, type CategoryCustomizableLinkData, type CategoryData, type CmsPage, type Country$1 as Country, type CreatedRecord, type Currency$2 as Currency, type CustomField, type CustomFieldData, type CustomFieldSet, type Customer, type CustomerAddress, type CustomerGroup, type DataServiceOptions, type DeliveryTime, type FixtureTypes, type Flow, type FlowTemplate, type Language$2 as Language, type Manufacturer, type Media, type Options, type Order, type OrderDelivery, type OrderLineItem, type OrderStatus, type PageObject, type PaymentMethod$1 as PaymentMethod, type Price, type Product, type ProductCrossSelling, type ProductPrice, type ProductReview, type Promotion, type PromotionDiscount, type PropertyGroup, type PropertyGroupOption, type RegistrationData, type Rule, type RuleAssignmentEntity, RuleType, type SalesChannel, type SalesChannelAnalytics, type SalesChannelDomain, type SalesChannelRecord, type Salutation, type ShippingMethod$1 as ShippingMethod, type SimpleLineItem, type StateMachine, type StateMachineState, StorefrontPageObjects, type SyncApiOperation, type SystemConfig, type Tag, type TagData, type Task, type Tax$1 as Tax, type TaxRules, TestDataService, type VariantListingConfig, compareFlowTemplateWithFlow, createRandomImage, extractIdFromUrl, getCountryId, getCurrency, getDefaultShippingMethodId, getFlow, getFlowId, getFlowTemplate, getLanguageData, getMediaId, getOrderTransactionId, getPaymentMethodId, getPromotionWithDiscount, getSalutationId, getShippingMethodId, getSnippetSetId, getStateMachineId, getStateMachineStateId, getTaxId, getThemeId, hideElements, isSaaSInstance, isThemeCompiled, replaceElements, setOrderStatus, setViewport, test };