import * as axe_core from 'axe-core';
import * as playwright_test from '@playwright/test';
import { Page as Page$1, Locator as Locator$1, Browser } from '@playwright/test';
export { expect, mergeTests } from '@playwright/test';
import * as playwright_core from 'playwright-core';
import { APIRequestContext, APIResponse, Page, Locator, BrowserContext } from 'playwright-core';
export { APIRequestContext, APIResponse, BrowserContext, Locator, Page, Request } from 'playwright-core';
import { components } from '@shopware/api-client/admin-api-types';
import { Image } from 'image-js';

declare global {
    namespace PlaywrightTest {
        interface Matchers<R> {
            toHaveVisibleFocus(): Promise<R>;
        }
    }
}

interface RequestOptions$1<PAYLOAD> {
    [key: string]: unknown;
    data?: PAYLOAD;
    headers?: Record<string, string>;
}
interface AdminApiContextOptions {
    app_url?: string;
    client_id?: string;
    client_secret?: string;
    access_token?: string;
    admin_username?: string;
    admin_password?: string;
    ignoreHTTPSErrors?: boolean;
    authMaxRetries?: number;
    authBaseDelayMs?: number;
}
declare class AdminApiContext {
    context: APIRequestContext;
    readonly options: Required<AdminApiContextOptions>;
    private static readonly defaultOptions;
    constructor(context: APIRequestContext, options: Required<AdminApiContextOptions>);
    static create(options?: Required<AdminApiContextOptions>): Promise<AdminApiContext>;
    private static createApiRequestContext;
    private static authenticateWithRetry;
    static authenticateWithClientCredentials(context: APIRequestContext, options: Required<AdminApiContextOptions>): Promise<string>;
    static authenticateWithUserPassword(context: APIRequestContext, options: Required<AdminApiContextOptions>): Promise<string>;
    private reauthenticate;
    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;
}

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 User = components["schemas"]["User"] & {
    id: string;
    password: string;
};
type AclRole = components["schemas"]["AclRole"] & {
    id: string;
    privileges: string[];
};
type CustomerAddress = components["schemas"]["CustomerAddress"] & {
    id: string;
};
interface Address {
    id: string;
    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$1 = 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;
    orderNumber: 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;
        }
    ];
    active: boolean;
    code: string;
};
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 const RuleType: {
    readonly shippingAvailability: "shippingMethodAvailabilityRule";
    readonly taxAvailability: "taxProviderAvailabilityRule";
    readonly paymentAvailability: "paymentMethodAvailabilityRule";
    readonly promotionOrder: "promotionOrderRule";
    readonly promotionCustomer: "promotionCustomerRule";
    readonly promotionCart: "promotionCartRule";
};
type RuleType = (typeof RuleType)[keyof typeof RuleType];
interface RuleAssignmentEntity {
    entity: {
        id: string;
        name: string;
    };
    ruleType: RuleType;
}
interface FlowConfig {
    name: string;
    description: string;
    priority: string;
    active: boolean;
    triggerSearchTerm: string;
    triggerLabel: string;
    condition: string;
    trueAction: string;
    trueActionIdentifier: string;
    falseAction: string;
    falseActionIdentifier: string;
}
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;
        }
    ];
}

declare const COUNTRY_ADDRESS_DATA: {
    DE: {
        street: string;
        city: string;
        country: string;
        postalCode: string;
        vatRegNo: string;
    };
    US: {
        street: string;
        city: string;
        country: string;
        postalCode: string;
        vatRegNo: string;
    };
    GB: {
        street: string;
        city: string;
        country: string;
        postalCode: string;
        vatRegNo: string;
    };
};
declare const getCountryAddressData: (countryCode?: string) => {
    street: string;
    city: string;
    country: string;
    postalCode: string;
    vatRegNo: string;
};
declare const getLocale: () => string;
declare const getLanguageCode: (locale?: string) => string;
declare const getCountryCodeFromLocale: (locale?: string) => string;
declare const getCurrencyCodeFromLocale: (locale?: string) => string;
declare const getCurrencySymbolFromLocale: (locale?: string) => string;
declare const formatPrice: (price: number, locale?: string, currencyCode?: string) => string;
type Language$1 = components["schemas"]["Language"] & {
    id: string;
    translationCode: components["schemas"]["Locale"] & {
        id: string;
    };
};
declare const getLanguageData: (adminApiContext: AdminApiContext, languageCode?: string) => Promise<Language$1>;
declare const getSnippetSetId: (adminApiContext: AdminApiContext, languageCode?: string) => Promise<string>;
type Currency$1 = components["schemas"]["Currency"] & {
    id: string;
};
declare const getCurrency: (adminApiContext: AdminApiContext, isoCode?: string) => Promise<Currency$1>;
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 updateAdminUser: (adminUserId: string, adminApiContext: AdminApiContext, data: Record<string, string | boolean>) => Promise<void>;

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>;
}

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

declare function createRandomImage(width?: number, height?: number): Image;
declare function createSolidColorImage(width?: number, height?: number, color?: [number, number, number]): Image;
declare function encodeImage(image: Image): Buffer<ArrayBuffer>;

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;
}

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;
    get shouldCleanUp(): boolean;
    /**
     * 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$1>;
    /**
     * Creates a new media resource containing a solid color PNG image.
     * Unlike `createMediaPNG`, the result is deterministic and suitable for visual regression tests.
     *
     * @param width - The width of the image in pixel. Default is 800.
     * @param height - The height of the image in pixel. Default is 600.
     * @param color - RGB color as `[r, g, b]` with values 0..255. Default is red `[255, 0, 0]`.
     */
    createMediaPNGSolid(width?: number, height?: number, color?: [number, number, number]): Promise<Media$1>;
    /**
     * Creates a new media resource containing a text file.
     *
     * @param content - The content of the text file.
     */
    createMediaTXT(content?: string): Promise<Media$1>;
    /**
     * Creates a new empty media resource.
     * This method is mostly used to combine it with a certain file upload.
     */
    createMediaResource(): Promise<Media$1>;
    /**
     * 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 user for the admin with full admin permissions.
     *
     * @param overrides - Specific data overrides that will be applied to the customer data struct.
     * @param salesChannel - The sales channel for which the customer should be registered.
     */
    createUser(overrides?: Partial<User>, salesChannel?: SalesChannel): Promise<User>;
    /**
     * Creates a new AclRole for the administration with basic shop configuration privileges.
     *
     * @param overrides - Specific data overrides that will be applied to the aclRole data struct.
     */
    createAclRole(overrides?: Partial<AclRole>): Promise<AclRole>;
    /**
     * 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 basic rule 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>;
    /**
     * Creates a customer address
     *
     * @param overrides - Specific data overrides that will be applied to the customer address data struct.
     */
    createCustomerAddress(customer: Customer, overrides?: Partial<Address>): Promise<Address>;
    /**
     * 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<any>;
    /**
     * 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<any>;
    /**
     * 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<any>;
    /**
     * 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>;
    /**
     * Assigns an ACL Role to a user (user in administration).
     *
     * @param aclRoleId - The uuid of the ACL role.
     * @param adminUserId - The uuid of the admin user.

     */
    assignAclRoleUser(aclRoleId: string, adminUserId: 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 a payment method by its distinguishable name.
     *
     * @param name - The name of the payment method.
     * @param exact - exact name or part of it
     */
    getPaymentMethodByDistinguishableName(name: string, exact?: boolean): 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>;
    /**
     * Retrieves a user by its id.
     *
     * @param userId - The id of the user.
     */
    getUserById(userId: string | undefined): Promise<User>;
    /**
     * Retrieves a AclRole by its id.
     *
     * @param aclRoleId - The id of the ACL role.
     */
    getAclRoleById(aclRoleId: string | undefined): Promise<AclRole>;
    /**
     * 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_core.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>[][];
    /**
     * Generates a random alphanumeric string of a specified length.
     * Ensures at least one numeric character is included.
     *
     * @param length - The desired length of the random string (default: 3)
     * @returns A random alphanumeric string containing at least one digit
     */
    generateRandomId(length?: number): 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>;
    getBasicUserStruct(localId: string, overrides?: Partial<User>): Partial<User>;
    getBasicAclRoleStruct(overrides?: Partial<AclRole>): Partial<AclRole>;
    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;
        payload: {
            code: string;
        };
        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>;
    getBasicCustomerAddressStruct(customerId: string, overrides?: Partial<Address>): Partial<Address>;
    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>;
}

/**
 * Hides elements (via `visibility: hidden`).
 */
declare function hideElements(page: Page, selectors: (string | Locator)[]): Promise<void>;
/**
 * Replaces text content or input values of elements with a given replacement string (default: "***").
 * - Works for inputs, textareas, contenteditables and generic elements.
 * - Ensures frameworks see the change (dispatches input/change).
 * - Also masks placeholder so empty fields show replacement text in screenshots.
 */
declare function replaceElements(page: Page, selectors: (string | Locator)[], replaceWith?: string): Promise<void>;
interface ReplaceTarget {
    selector: string | Locator;
    replaceWith?: string;
}
/**
 * Replaces elements individually based on an array of targets.
 *
 *@param page - Playwright page
 *@param targets - Array of objects containing selectors and optional replacement strings.
 */
declare function replaceElementsIndividually(page: Page, targets: ReplaceTarget[]): 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>;
/**
 * Takes a screenshot of the desktop content of the page or the provided locator and compares it to existing ones.
 *
 * @param page - Playwright page object
 * @param filename - Filename of the screenshot
 * @param locator - Optional Playwright locator to take a screenshot of instead of the desktop content
 */
declare function assertScreenshot(page: Page, filename: string, locator?: Locator): Promise<void>;

declare const BUNDLED_RESOURCES: {
    readonly en: {
        readonly "administration/category": {
            general: {
                name: string;
                active: string;
                save: string;
                cancel: string;
                delete: string;
                customFields: string;
            };
            actions: {
                createCategory: string;
                addLandingPage: string;
                configureHomePage: string;
                newCategoryAfter: string;
            };
            tabs: {
                general: string;
                products: string;
                layout: string;
                seo: string;
            };
            fields: {
                categoryType: string;
                linkType: string;
                entity: string;
                openInNewTab: string;
            };
            headings: {
                landingPages: string;
            };
            errors: {
                entityTypeNotFound: string;
            };
            entities: {
                category: string;
                product: string;
                landingPage: string;
            };
        };
        readonly "administration/customer": {
            listing: {
                customers: string;
                bulkEdit: string;
                delete: string;
                cancel: string;
                startBulkEdit: string;
                bulkEditItemsSelected: string;
            };
            detail: {
                general: string;
                addresses: string;
                orders: string;
                accept: string;
                decline: string;
                edit: string;
                customerGroupRequestMessage: string;
                customerGroup: string;
                accountStatus: string;
                language: string;
            };
            bulkEdit: {
                headline: string;
                applyChanges: string;
                success: string;
                close: string;
                changes: {
                    customerGroup: string;
                    accountStatus: string;
                    language: string;
                    tags: string;
                    replyToRequest: string;
                };
                placeholders: {
                    selectCustomerGroup: string;
                    selectLanguage: string;
                    selectCustomerGroupRequestReply: string;
                };
            };
        };
        readonly "administration/customField": {
            common: {
                technicalName: string;
                position: string;
                labelEnglishGB: string;
            };
            listing: {
                addNewSet: string;
            };
            create: {
                assignTo: string;
                save: string;
                cancel: string;
            };
            detail: {
                type: string;
                modifiableViaStoreApi: string;
                placeholderEnglishGB: string;
                helpTextEnglishGB: string;
                availableInShoppingCart: string;
                select: string;
                newCustomField: string;
                editCustomField: string;
                add: string;
            };
            general: {
                customFields: string;
            };
            actions: {
                edit: string;
                delete: string;
                cancel: string;
                applyChanges: string;
            };
            dialogs: {
                warning: string;
                deleteCustomField: string;
            };
        };
        readonly "administration/dataSharing": {
            buttons: {
                agree: string;
                disableDataSharing: string;
                allowAll: string;
                rejectAll: string;
                savePreferences: string;
                declineUsageData: string;
                giveConsentUsageData: string;
            };
            checkboxes: {
                shareStoreData: string;
                shareUsageData: string;
            };
            headlines: {
                consentModal: string;
                storeData: string;
                usageData: string;
                dataConsent: string;
            };
            links: {
                storeDataCollectionDetails: string;
                privacyPolicy: string;
            };
            messages: {
                storeData: string;
                usageData: string;
                sharingData: string;
                termsAgreement: string;
            };
        };
        readonly "administration/document": {
            listing: {
                addDocument: string;
            };
            types: {
                invoice: string;
            };
            detail: {
                displayDocumentInMyAccount: string;
                displayDocumentInMyAccountSwitch: string;
                save: string;
            };
        };
        readonly "administration/landingPage": {
            create: {
                searchLayoutsPlaceholder: string;
                assignLayout: string;
                createNewLayout: string;
                selectLayout: string;
            };
            general: {
                name: string;
                save: string;
                active: string;
                salesChannels: string;
                seoUrl: string;
            };
            layout: {
                layout: string;
                changeLayout: string;
                editInDesigner: string;
            };
        };
        readonly "administration/layout": {
            listing: {
                createNewLayout: string;
            };
            create: {
                shopPage: string;
                landingPage: string;
                listingPage: string;
                productPage: string;
                cancel: string;
                save: string;
                fullWidth: string;
                sidebar: string;
                back: string;
                layoutName: string;
                createLayout: string;
            };
            detail: {
                save: string;
                settings: string;
                blocks: string;
                navigator: string;
                layoutAssignment: string;
            };
        };
        readonly "administration/login": {
            username: string;
            emailAddress: string;
            password: string;
            loginButton: string;
        };
        readonly "administration/flowBuilder": {
            listing: {
                delete: string;
                downloadFlow: string;
                testFlow: string;
                flowTemplates: string;
            };
            create: {
                addAction: string;
                addConditionIf: string;
                addActionThen: string;
                newFlow: string;
                name: string;
                description: string;
                priority: string;
                active: string;
                tags: string;
            };
            detail: {
                name: string;
            };
            templates: {
                createFromTemplate: string;
                createNewFlowFromTemplate: string;
            };
            messages: {
                deleteConfirmation: string;
            };
        };
        readonly "administration/dashboard": {
            dataSharing: {
                agree: string;
                notAtTheMoment: string;
                acceptMessage: string;
                notAtTheMomentMessage: string;
                agreementText: string;
            };
            shopwareServices: {
                close: string;
                exploreNow: string;
            };
            userMenu: {
                logout: string;
            };
            order: {
                orderTitle: string;
                orderOverview: string;
            };
        };
        readonly "administration/manufacturer": {
            listing: {
                addManufacturer: string;
            };
            create: {
                name: string;
                website: string;
                save: string;
                cancel: string;
            };
            detail: {
                customFields: string;
            };
            actions: {
                edit: string;
                delete: string;
                cancel: string;
            };
            dialogs: {
                warning: string;
            };
        };
        readonly "administration/media": {
            buttons: {
                uploadFile: string;
                addNewFolder: string;
            };
            search: {
                placeholder: string;
            };
            actions: {
                rename: string;
                delete: string;
            };
        };
        readonly "administration/order": {
            detail: {
                items: string;
                sendDocument: string;
                openActionsMenu: string;
            };
            contextMenu: {
                sendDocument: string;
                openDocument: string;
                markAsSent: string;
            };
            tabs: {
                general: string;
                details: string;
                documents: string;
            };
            listing: {
                addOrder: string;
            };
            actions: {
                view: string;
                delete: string;
                cancel: string;
            };
            dialogs: {
                warning: string;
            };
        };
        readonly "administration/payment": {
            common: {
                name: string;
                availabilityRule: string;
                cashOnDelivery: string;
                paidInAdvance: string;
                invoice: string;
            };
            detail: {};
            methods: {
                customPaymentMethod: string;
            };
        };
        readonly "administration/promotion": {
            tabs: {
                general: string;
                conditions: string;
                discounts: string;
            };
            cards: {
                preConditions: string;
            };
            headings: {
                promotionCodes: string;
            };
            actions: {
                addPromotion: string;
                addDiscount: string;
                duplicate: string;
                delete: string;
                edit: string;
                save: string;
                cancel: string;
            };
            fields: {
                priority: string;
            };
            sidebar: {
                refresh: string;
            };
        };
        readonly "administration/rule": {
            buttons: {
                createRule: string;
                add: string;
                addAssignment: string;
                save: string;
                cancel: string;
            };
            fields: {
                name: string;
                priority: string;
                description: string;
            };
            errors: {
                unknownRuleType: string;
            };
            testData: {
                ruleDescription: string;
            };
            text: {
                ruleNotInUse: string;
                filter: string;
            };
        };
        readonly "administration/settings": {
            header: {
                settings: string;
            };
            links: {
                basicInformation: string;
                cartSettings: string;
                languages: string;
                measurementSystem: string;
                numberRanges: string;
                productUnits: string;
                search: string;
                statusManagement: string;
                customerGroups: string;
                loginAndSignUp: string;
                salutations: string;
                flowBuilder: string;
                importExport: string;
                ruleBuilder: string;
                countries: string;
                currencies: string;
                snippets: string;
                tax: string;
                customFields: string;
                emailTemplates: string;
                media: string;
                newsletter: string;
                seo: string;
                sitemap: string;
                tags: string;
                deliveryTimes: string;
                documents: string;
                essentialCharacteristics: string;
                paymentMethods: string;
                products: string;
                shipping: string;
                cachesAndIndexes: string;
                eventLogs: string;
                firstRunWizard: string;
                integrations: string;
                mailer: string;
                messageQueueStatistics: string;
                privacy: string;
                shopwareAccount: string;
                shopwareServices: string;
                shopwareUpdates: string;
                storefront: string;
                usersAndPermissions: string;
            };
        };
        readonly "administration/shipping": {
            common: {
                name: string;
                availabilityRule: string;
            };
            listing: {
                addShippingMethod: string;
            };
            detail: {};
            methods: {
                standard: string;
                express: string;
                customShippingMethod: string;
            };
            dialogs: {
                warning: string;
                cancel: string;
                delete: string;
            };
        };
        readonly "administration/yourProfile": {
            tabs: {
                searchPreferences: string;
                privacyPreferences: string;
            };
            fields: {
                firstName: string;
                lastName: string;
                username: string;
                email: string;
            };
            buttons: {
                deselectAll: string;
            };
            links: {
                privacy: string;
            };
            checkboxes: {
                usageDataCheckbox: string;
            };
            headlines: {
                usageDataHeadline: string;
                cardTitle: string;
            };
        };
        readonly "administration/customerGroup": {
            listing: {
                customerGroups: string;
            };
            detail: {
                technicalUrl: string;
            };
            create: {
                title: string;
                cardTitle: string;
                save: string;
                cancel: string;
                customSignupForm: string;
                companySignupForm: string;
                seoMetaDescription: string;
            };
        };
        readonly "administration/firstRunWizard": {
            welcome: {
                text: string;
            };
            buttons: {
                install: string;
                installMigrationAssistant: string;
                installDemoData: string;
                next: string;
                skip: string;
                finish: string;
                back: string;
                configureLater: string;
                configureOwnSmtpServer: string;
            };
            headers: {
                dataImport: string;
                defaultValues: string;
                mailerConfiguration: string;
                payPalSetup: string;
                extensions: string;
                shopwareAccount: string;
                shopwareStore: string;
                done: string;
            };
            fields: {
                host: string;
                port: string;
                username: string;
                password: string;
                senderAddress: string;
                deliveryAddress: string;
                disableEmailDelivery: string;
            };
            placeholders: {
                selectSalesChannels: string;
                enterEmailAddress: string;
                enterPassword: string;
            };
            regions: {
                germanRegion: string;
                tools: string;
            };
            text: {
                smtpServer: string;
                globalRecommendations: string;
                allDone: string;
                forgotPassword: string;
            };
        };
        readonly "administration/shopwareServices": {
            headings: {
                futureProofStore: string;
            };
            buttons: {
                activateServices: string;
                grantPermissions: string;
                deactivate: string;
                exploreNow: string;
            };
            modals: {
                deactivateServices: string;
            };
            messages: {
                accessDenied: string;
            };
            links: {
                shopwareServices: string;
            };
            dashboard: {
                shopwareServicesIntroduction: string;
            };
        };
        readonly "administration/product": {
            detail: {
                customFields: string;
                colorProperty: string;
                sizeProperty: string;
                stockPlaceholder: string;
                restockTimePlaceholder: string;
            };
            variants: {
                properties: string;
            };
            flows: {
                tag: string;
            };
            errors: {
                followingErrorOccurred: string;
            };
            bulkEdit: {
                applyChanges: string;
                success: string;
                close: string;
            };
            listing: {
                bulkEdit: string;
                startBulkEdit: string;
            };
            tabs: {
                specifications: string;
                advancedPricing: string;
                variants: string;
                layout: string;
                crossSelling: string;
                seo: string;
                reviews: string;
            };
            buttons: {
                save: string;
                uploadFile: string;
                generateVariants: string;
                next: string;
                saveVariants: string;
            };
            modals: {
                generateVariants: string;
            };
            propertyValues: {
                blue: string;
                red: string;
                green: string;
                small: string;
                medium: string;
                large: string;
            };
        };
        readonly "administration/salesChannel": {
            tabs: {
                general: string;
                products: string;
                theme: string;
                analytics: string;
            };
            buttons: {
                addDomain: string;
            };
        };
        readonly "storefront/account": {
            common: {
                salutation: string;
                firstName: string;
                lastName: string;
                company: string;
                department: string;
                back: string;
                changePassword: string;
                passwordUpdated: string;
                cashOnDelivery: string;
                paidInAdvance: string;
                invoice: string;
            };
            login: {
                email: string;
                password: string;
                logIn: string;
                logOut: string;
                forgotPassword: string;
                invalidCredentials: string;
                successfulLogout: string;
            };
            profile: {
                saveChanges: string;
                changeEmail: string;
                emailConfirmation: string;
                emailUpdated: string;
                invalidEmail: string;
                emailUpdateFailure: string;
                passwordTooShort: string;
                passwordUpdateFailure: string;
            };
            orders: {
                download: string;
                cancelOrder: string;
                repeatOrder: string;
                changePaymentMethod: string;
                actions: string;
                expand: string;
                showDetails: string;
                creditItem: string;
                orderNumber: string;
                plusVat: string;
                includeVat: string;
                vatSuffix: string;
                shippingCosts: string;
                totalGross: string;
                headlineCompletePayment: string;
                buttonCompletePayment: string;
                editCompleted: string;
            };
            addresses: {
                street: string;
                streetAddress: string;
                city: string;
                country: string;
                postalCode: string;
                state: string;
                editAddress: string;
                addNewAddress: string;
                useAsDefaultBilling: string;
                useAsDefaultShipping: string;
                deliveryNotPossible: string;
            };
            registration: {
                continue: string;
                differentShippingAddress: string;
            };
            general: {
                overview: string;
                personalData: string;
                defaultPaymentMethod: string;
                defaultBillingAddress: string;
                defaultShippingAddress: string;
                yourAccount: string;
                newsletter: string;
                newsletterRegistrationSuccess: string;
                cannotDeliverToCountry: string;
                shippingNotPossible: string;
                customerGroupAccessRequested: string;
            };
            navigation: {
                overview: string;
                yourProfile: string;
                addresses: string;
                orders: string;
                logout: string;
            };
            recovery: {
                title: string;
                subtitle: string;
                requestEmail: string;
                emailSent: string;
                invalidLink: string;
                newPassword: string;
                passwordConfirmation: string;
            };
            payment: {
                change: string;
            };
        };
        readonly "storefront/address": {
            common: {
                salutation: string;
                firstName: string;
                lastName: string;
                company: string;
                department: string;
                street: string;
                postalCode: string;
            };
            actions: {
                editAddress: string;
                useAsDefaultBilling: string;
                useAsDefaultShipping: string;
                addressOptions: string;
                deleteAddress: string;
            };
            badges: {
                defaultBilling: string;
                defaultShipping: string;
            };
            messages: {
                deliveryNotPossible: string;
            };
        };
        readonly "storefront/checkout": {
            common: {
                back: string;
                paymentMethod: string;
                cashOnDelivery: string;
                paidInAdvance: string;
                invoice: string;
                shippingMethod: string;
                standard: string;
                express: string;
                grandTotal: string;
                plusVat: string;
                vatSuffix: string;
            };
            cart: {
                shoppingCart: string;
                goToCheckout: string;
                displayShoppingCart: string;
                continueShopping: string;
                promoCode: string;
                emptyCart: string;
                quantity: string;
                stockReached: string;
            };
            confirm: {
                completeOrder: string;
                submitOrder: string;
                termsAndConditions: string;
                immediateAccessToDigitalProduct: string;
            };
            finish: {
                thankYouForOrder: string;
            };
            orderEdit: {
                cancelOrder: string;
            };
        };
        readonly "storefront/product": {
            addToCart: string;
            quantity: string;
            addToWishlist: string;
            removeFromWishlist: string;
            deliveryTime: string;
            review: {
                tabTitle: string;
                title: string;
                text: string;
                emptyText: string;
                submitMessage: string;
            };
            listing: {
                sorting: string;
                noProductsFound: string;
            };
        };
        readonly "storefront/navigation": {
            pageNotFound: {
                title: string;
                backToShop: string;
            };
            home: {
                yourAccount: string;
                manufacturerFilter: string;
                priceFilter: string;
                resetAll: string;
                freeShipping: string;
            };
            footer: {
                contactForm: string;
            };
            category: {
                sorting: string;
                addToCart: string;
                noProductsFound: string;
            };
        };
        readonly "storefront/contact": {
            title: string;
            link: {
                contactForm: string;
            };
            form: {
                contact: string;
                salutation: string;
                firstName: string;
                lastName: string;
                emailAddress: string;
                phone: string;
                subject: string;
                comment: string;
                submit: string;
                privacyPolicy: string;
            };
            email: {
                from: string;
                subject: string;
            };
        };
        readonly "storefront/consent": {
            cookie: {
                onlyTechnicallyRequired: string;
                configure: string;
                acceptAllCookies: string;
                preferences: string;
                marketing: string;
            };
        };
        readonly "storefront/header": {
            topBarNav: string;
            currencyDropdown: string;
            languageDropdown: string;
            skipToContentLink: string;
            searchInputAriaLabel: string;
            wishlistIcon: string;
            shoppingCart: string;
        };
        readonly "storefront/home": {
            account: {
                yourAccount: string;
            };
            consent: {
                close: string;
                onlyTechnicallyRequired: string;
                technicallyRequired: string;
                configure: string;
                acceptAllCookies: string;
                cookiePreferences: string;
                marketing: string;
                statistics: string;
                save: string;
            };
            filters: {
                filterPanel: string;
                labelPrefix: string;
                manufacturer: string;
                price: string;
                resetAll: string;
                freeShipping: string;
                rating: string;
                minRating: string;
            };
            listing: {
                addToShoppingCart: string;
            };
        };
        readonly "storefront/login": {
            emailAddress: string;
            password: string;
            loginButton: string;
            forgotPassword: string;
            logout: string;
            invalidCredentials: string;
            successfulLogout: string;
            passwordUpdated: string;
            register: {
                salutation: string;
                firstName: string;
                lastName: string;
                company: string;
                department: string;
                emailAddress: string;
                password: string;
                streetAddress: string;
                city: string;
                country: string;
                postalCode: string;
                state: string;
                differentShippingAddress: string;
                continue: string;
            };
        };
        readonly "storefront/order": {
            actions: {
                cancelOrder: string;
                back: string;
            };
            shipping: {
                standard: string;
                express: string;
            };
        };
        readonly "storefront/pageNotFound": {
            title: string;
            message: string;
            backToShop: string;
        };
        readonly "storefront/payment": {
            methods: {
                cashOnDelivery: string;
                paidInAdvance: string;
                invoice: string;
            };
            actions: {
                change: string;
                completePayment: string;
            };
        };
        readonly "storefront/recover": {
            passwordRecovery: string;
            subtitle: string;
            requestEmail: string;
            back: string;
            emailSent: string;
            newPassword: string;
            passwordConfirmation: string;
            changePassword: string;
            invalidLink: string;
        };
        readonly "storefront/offCanvasCart": {
            general: {
                title: string;
            };
            buttons: {
                goToCheckout: string;
                goToCart: string;
                continueShopping: string;
            };
        };
        readonly "storefront/wishlist": {
            removeProduct: string;
        };
    };
    readonly de: {
        readonly "administration/category": {
            general: {
                name: string;
                active: string;
                save: string;
                cancel: string;
                delete: string;
                customFields: string;
            };
            actions: {
                createCategory: string;
                addLandingPage: string;
                configureHomePage: string;
                newCategoryAfter: string;
            };
            tabs: {
                general: string;
                products: string;
                layout: string;
                seo: string;
            };
            fields: {
                categoryType: string;
                linkType: string;
                entity: string;
                openInNewTab: string;
            };
            headings: {
                landingPages: string;
            };
            errors: {
                entityTypeNotFound: string;
            };
            entities: {
                category: string;
                product: string;
                landingPage: string;
            };
        };
        readonly "administration/customer": {
            listing: {
                customers: string;
                bulkEdit: string;
                startBulkEdit: string;
                cancel: string;
                delete: string;
                bulkEditItemsSelected: string;
            };
            detail: {
                edit: string;
                general: string;
                addresses: string;
                orders: string;
                accept: string;
                decline: string;
                accountStatus: string;
                customerGroup: string;
                language: string;
                customerGroupRequestMessage: string;
            };
            bulkEdit: {
                headline: string;
                applyChanges: string;
                success: string;
                close: string;
                changes: {
                    customerGroup: string;
                    accountStatus: string;
                    language: string;
                    replyToRequest: string;
                    tags: string;
                };
                placeholders: {
                    selectCustomerGroup: string;
                    selectLanguage: string;
                    selectCustomerGroupRequestReply: string;
                };
            };
        };
        readonly "administration/customerGroup": {
            listing: {
                addCustomerGroup: string;
                customerGroups: string;
            };
            create: {
                title: string;
                saveSuccess: string;
                save: string;
                cancel: string;
                cardTitle: string;
                customSignupForm: string;
                seoMetaDescription: string;
                companySignupForm: string;
            };
            detail: {
                registration: {
                    accepted: string;
                    denied: string;
                };
                technicalUrl: string;
            };
        };
        readonly "administration/customField": {
            common: {
                technicalName: string;
                type: string;
                required: string;
                position: string;
                customFieldSet: string;
                labelEnglishGB: string;
            };
            listing: {
                addCustomField: string;
                addNewSet: string;
            };
            create: {
                title: string;
                saveSuccess: string;
                assignTo: string;
                save: string;
                cancel: string;
            };
            detail: {
                label: string;
                helpText: string;
                placeholder: string;
                type: string;
                modifiableViaStoreApi: string;
                placeholderEnglishGB: string;
                helpTextEnglishGB: string;
                availableInShoppingCart: string;
                select: string;
                newCustomField: string;
                editCustomField: string;
                add: string;
            };
            general: {
                customFields: string;
            };
            actions: {
                edit: string;
                delete: string;
                cancel: string;
                applyChanges: string;
            };
            dialogs: {
                warning: string;
                deleteCustomField: string;
            };
        };
        readonly "administration/dashboard": {
            dataSharing: {
                agree: string;
                notAtTheMoment: string;
                acceptMessage: string;
                notAtTheMomentMessage: string;
                agreementText: string;
            };
            shopwareServices: {
                close: string;
                exploreNow: string;
            };
            userMenu: {
                logout: string;
            };
            order: {
                orderTitle: string;
                orderOverview: string;
            };
        };
        readonly "administration/dataSharing": {
            buttons: {
                agree: string;
                disableDataSharing: string;
                allowAll: string;
                rejectAll: string;
                savePreferences: string;
                declineUsageData: string;
                giveConsentUsageData: string;
            };
            checkboxes: {
                shareStoreData: string;
                shareUsageData: string;
            };
            headlines: {
                consentModal: string;
                storeData: string;
                usageData: string;
                dataConsent: string;
            };
            links: {
                storeDataCollectionDetails: string;
                privacyPolicy: string;
            };
            messages: {
                storeData: string;
                usageData: string;
                sharingData: string;
                termsAgreement: string;
            };
        };
        readonly "administration/document": {
            listing: {
                addDocument: string;
            };
            types: {
                invoice: string;
            };
            detail: {
                displayDocumentInMyAccount: string;
                displayDocumentInMyAccountSwitch: string;
                save: string;
            };
        };
        readonly "administration/firstRunWizard": {
            welcome: {
                text: string;
            };
            buttons: {
                install: string;
                installMigrationAssistant: string;
                installDemoData: string;
                next: string;
                skip: string;
                finish: string;
                back: string;
                configureLater: string;
                configureOwnSmtpServer: string;
            };
            headers: {
                dataImport: string;
                defaultValues: string;
                mailerConfiguration: string;
                payPalSetup: string;
                extensions: string;
                shopwareAccount: string;
                shopwareStore: string;
                done: string;
            };
            fields: {
                host: string;
                port: string;
                username: string;
                password: string;
                senderAddress: string;
                deliveryAddress: string;
                disableEmailDelivery: string;
            };
            placeholders: {
                selectSalesChannels: string;
                enterEmailAddress: string;
                enterPassword: string;
            };
            regions: {
                germanRegion: string;
                tools: string;
            };
            text: {
                smtpServer: string;
                globalRecommendations: string;
                allDone: string;
                forgotPassword: string;
            };
        };
        readonly "administration/flowBuilder": {
            listing: {
                addFlow: string;
                delete: string;
                downloadFlow: string;
                testFlow: string;
                flowTemplates: string;
            };
            create: {
                title: string;
                saveSuccess: string;
                addAction: string;
                addConditionIf: string;
                addActionThen: string;
                newFlow: string;
                name: string;
                description: string;
                priority: string;
                active: string;
                tags: string;
            };
            detail: {
                priority: string;
                trigger: string;
                actions: string;
                name: string;
            };
            templates: {
                title: string;
                useTemplate: string;
                createFromTemplate: string;
                createNewFlowFromTemplate: string;
            };
            messages: {
                deleteConfirmation: string;
            };
        };
        readonly "administration/landingPage": {
            create: {
                title: string;
                saveSuccess: string;
                searchLayoutsPlaceholder: string;
                assignLayout: string;
                createNewLayout: string;
                selectLayout: string;
            };
            detail: {
                name: string;
                active: string;
                salesChannel: string;
                url: string;
            };
            general: {
                name: string;
                save: string;
                active: string;
                salesChannels: string;
                seoUrl: string;
            };
            layout: {
                layout: string;
                changeLayout: string;
                editInDesigner: string;
            };
        };
        readonly "administration/layout": {
            listing: {
                createNewLayout: string;
            };
            create: {
                shopPage: string;
                landingPage: string;
                listingPage: string;
                productPage: string;
                cancel: string;
                save: string;
                fullWidth: string;
                sidebar: string;
                back: string;
                layoutName: string;
                createLayout: string;
            };
            detail: {
                save: string;
                settings: string;
                blocks: string;
                navigator: string;
                layoutAssignment: string;
            };
        };
        readonly "administration/login": {
            username: string;
            emailAddress: string;
            password: string;
            loginButton: string;
        };
        readonly "administration/manufacturer": {
            listing: {
                addManufacturer: string;
            };
            create: {
                name: string;
                website: string;
                save: string;
                cancel: string;
            };
            detail: {
                customFields: string;
            };
            actions: {
                edit: string;
                delete: string;
                cancel: string;
            };
            dialogs: {
                warning: string;
            };
        };
        readonly "administration/media": {
            buttons: {
                uploadFile: string;
                addNewFolder: string;
            };
            search: {
                placeholder: string;
            };
            actions: {
                rename: string;
                delete: string;
            };
        };
        readonly "administration/order": {
            detail: {
                items: string;
                sendDocument: string;
                openActionsMenu: string;
            };
            contextMenu: {
                sendDocument: string;
                openDocument: string;
                markAsSent: string;
            };
            tabs: {
                general: string;
                details: string;
                documents: string;
            };
            listing: {
                addOrder: string;
            };
            actions: {
                view: string;
                delete: string;
                cancel: string;
            };
            dialogs: {
                warning: string;
            };
        };
        readonly "administration/payment": {
            common: {
                name: string;
                availabilityRule: string;
                cashOnDelivery: string;
                paidInAdvance: string;
                invoice: string;
            };
            detail: {};
            methods: {
                customPaymentMethod: string;
            };
        };
        readonly "administration/product": {
            listing: {
                addProduct: string;
                bulkEdit: string;
                startBulkEdit: string;
            };
            create: {
                title: string;
                saveSuccess: string;
            };
            detail: {
                name: string;
                description: string;
                price: string;
                stock: string;
                productNumber: string;
                manufacturer: string;
                tax: string;
                properties: string;
                customFields: string;
                colorProperty: string;
                sizeProperty: string;
                stockPlaceholder: string;
                restockTimePlaceholder: string;
            };
            errors: {
                flows: {
                    productWritten: string;
                };
                followingErrorOccurred: string;
            };
            variants: {
                properties: string;
            };
            flows: {
                tag: string;
            };
            bulkEdit: {
                applyChanges: string;
                success: string;
                close: string;
            };
            tabs: {
                specifications: string;
                advancedPricing: string;
                variants: string;
                layout: string;
                crossSelling: string;
                seo: string;
                reviews: string;
            };
            buttons: {
                save: string;
                uploadFile: string;
                generateVariants: string;
                next: string;
                saveVariants: string;
            };
            modals: {
                generateVariants: string;
            };
            propertyValues: {
                blue: string;
                red: string;
                green: string;
                small: string;
                medium: string;
                large: string;
            };
        };
        readonly "administration/promotion": {
            listing: {
                addPromotion: string;
            };
            create: {
                title: string;
                saveSuccess: string;
            };
            detail: {
                name: string;
                active: string;
                code: string;
                discountType: string;
                value: string;
                validFrom: string;
                validUntil: string;
            };
            actions: {
                save: string;
                cancel: string;
                addPromotion: string;
                edit: string;
                delete: string;
                duplicate: string;
                addDiscount: string;
            };
            fields: {
                priority: string;
            };
            tabs: {
                general: string;
                conditions: string;
                discounts: string;
            };
            headings: {
                promotionCodes: string;
            };
            cards: {
                preConditions: string;
            };
            sidebar: {
                refresh: string;
            };
        };
        readonly "administration/rule": {
            fields: {
                priority: string;
                name: string;
                description: string;
            };
            buttons: {
                save: string;
                cancel: string;
                add: string;
                addAssignment: string;
                createRule: string;
            };
            errors: {
                unknownRuleType: string;
            };
            testData: {
                ruleDescription: string;
            };
            text: {
                ruleNotInUse: string;
                filter: string;
            };
        };
        readonly "administration/settings": {
            header: {
                settings: string;
            };
            links: {
                basicInformation: string;
                cartSettings: string;
                languages: string;
                measurementSystem: string;
                numberRanges: string;
                productUnits: string;
                search: string;
                statusManagement: string;
                customerGroups: string;
                loginAndSignUp: string;
                salutations: string;
                flowBuilder: string;
                importExport: string;
                ruleBuilder: string;
                countries: string;
                currencies: string;
                snippets: string;
                tax: string;
                customFields: string;
                emailTemplates: string;
                media: string;
                newsletter: string;
                seo: string;
                sitemap: string;
                tags: string;
                deliveryTimes: string;
                documents: string;
                essentialCharacteristics: string;
                paymentMethods: string;
                products: string;
                shipping: string;
                cachesAndIndexes: string;
                eventLogs: string;
                firstRunWizard: string;
                integrations: string;
                mailer: string;
                messageQueueStatistics: string;
                privacy: string;
                shopwareAccount: string;
                shopwareServices: string;
                shopwareUpdates: string;
                storefront: string;
                usersAndPermissions: string;
            };
        };
        readonly "administration/shipping": {
            common: {
                name: string;
                availabilityRule: string;
            };
            listing: {
                addShippingMethod: string;
            };
            detail: {};
            methods: {
                standard: string;
                express: string;
                customShippingMethod: string;
            };
            dialogs: {
                warning: string;
                cancel: string;
                delete: string;
            };
        };
        readonly "administration/shopwareServices": {
            headings: {
                futureProofStore: string;
            };
            buttons: {
                activateServices: string;
                grantPermissions: string;
                deactivate: string;
                exploreNow: string;
            };
            modals: {
                deactivateServices: string;
            };
            messages: {
                accessDenied: string;
            };
            links: {
                shopwareServices: string;
            };
            dashboard: {
                shopwareServicesIntroduction: string;
            };
        };
        readonly "administration/yourProfile": {
            general: {
                title: string;
                firstName: string;
                lastName: string;
                email: string;
                username: string;
                currentPassword: string;
                newPassword: string;
                newPasswordConfirm: string;
                language: string;
                timeZone: string;
                save: string;
                saveSuccess: string;
            };
            tabs: {
                searchPreferences: string;
                privacyPreferences: string;
            };
            fields: {
                firstName: string;
                lastName: string;
                username: string;
                email: string;
            };
            buttons: {
                deselectAll: string;
            };
            links: {
                privacy: string;
            };
            checkboxes: {
                usageDataCheckbox: string;
            };
            headlines: {
                usageDataHeadline: string;
                cardTitle: string;
            };
        };
        readonly "administration/salesChannel": {
            tabs: {
                general: string;
                products: string;
                theme: string;
                analytics: string;
            };
            buttons: {
                addDomain: string;
            };
        };
        readonly "storefront/account": {
            common: {
                salutation: string;
                firstName: string;
                lastName: string;
                company: string;
                department: string;
                back: string;
                changePassword: string;
                passwordUpdated: string;
                cashOnDelivery: string;
                paidInAdvance: string;
                invoice: string;
            };
            login: {
                email: string;
                password: string;
                logIn: string;
                logOut: string;
                forgotPassword: string;
                invalidCredentials: string;
                successfulLogout: string;
            };
            profile: {
                saveChanges: string;
                changeEmail: string;
                emailConfirmation: string;
                emailUpdated: string;
                invalidEmail: string;
                emailUpdateFailure: string;
                passwordTooShort: string;
                passwordUpdateFailure: string;
            };
            orders: {
                download: string;
                cancelOrder: string;
                repeatOrder: string;
                changePaymentMethod: string;
                actions: string;
                expand: string;
                showDetails: string;
                creditItem: string;
                orderNumber: string;
                plusVat: string;
                includeVat: string;
                vatSuffix: string;
                shippingCosts: string;
                totalGross: string;
                headlineCompletePayment: string;
                buttonCompletePayment: string;
                editCompleted: string;
            };
            addresses: {
                street: string;
                streetAddress: string;
                city: string;
                country: string;
                postalCode: string;
                state: string;
                editAddress: string;
                addNewAddress: string;
                useAsDefaultBilling: string;
                useAsDefaultShipping: string;
                deliveryNotPossible: string;
            };
            registration: {
                continue: string;
                differentShippingAddress: string;
            };
            general: {
                yourAccount: string;
                newsletter: string;
                newsletterRegistrationSuccess: string;
                cannotDeliverToCountry: string;
                shippingNotPossible: string;
                overview: string;
                personalData: string;
                defaultPaymentMethod: string;
                defaultBillingAddress: string;
                defaultShippingAddress: string;
                customerGroupAccessRequested: string;
            };
            navigation: {
                overview: string;
                yourProfile: string;
                addresses: string;
                orders: string;
                logout: string;
            };
            recovery: {
                title: string;
                subtitle: string;
                requestEmail: string;
                emailSent: string;
                invalidLink: string;
                newPassword: string;
                passwordConfirmation: string;
            };
            payment: {
                change: string;
            };
            tasks: {
                registration: {
                    defaultStreet: string;
                    defaultCity: string;
                    defaultCountry: string;
                    defaultDepartment: string;
                    defaultVatRegNo: string;
                };
                deprecation: {
                    registerGuestDeprecated: string;
                    isCommercialDeprecated: string;
                };
            };
        };
        readonly "storefront/address": {
            common: {
                salutation: string;
                firstName: string;
                lastName: string;
                company: string;
                department: string;
                street: string;
                postalCode: string;
            };
            actions: {
                editAddress: string;
                useAsDefaultBilling: string;
                useAsDefaultShipping: string;
                addressOptions: string;
                deleteAddress: string;
            };
            badges: {
                defaultBilling: string;
                defaultShipping: string;
            };
            messages: {
                deliveryNotPossible: string;
            };
        };
        readonly "storefront/checkout": {
            common: {
                back: string;
                paymentMethod: string;
                cashOnDelivery: string;
                paidInAdvance: string;
                invoice: string;
                shippingMethod: string;
                standard: string;
                express: string;
                grandTotal: string;
                plusVat: string;
                vatSuffix: string;
            };
            cart: {
                shoppingCart: string;
                goToCheckout: string;
                displayShoppingCart: string;
                continueShopping: string;
                promoCode: string;
                emptyCart: string;
                quantity: string;
                stockReached: string;
            };
            confirm: {
                confirmOrder: string;
                orderSummary: string;
                shippingAddress: string;
                billingAddress: string;
                agreeToTerms: string;
                revocationNotice: string;
                completeOrder: string;
                submitOrder: string;
                termsAndConditions: string;
                immediateAccessToDigitalProduct: string;
            };
            finish: {
                thankYouForOrder: string;
            };
            orderEdit: {
                cancelOrder: string;
            };
        };
        readonly "storefront/consent": {
            cookie: {
                title: string;
                description: string;
                acceptAll: string;
                acceptSelected: string;
                decline: string;
                necessary: string;
                functional: string;
                statistics: string;
                acceptAllCookies: string;
                configure: string;
                onlyTechnicallyRequired: string;
                preferences: string;
                marketing: string;
            };
            privacy: {
                policy: string;
                readMore: string;
            };
        };
        readonly "storefront/contact": {
            title: string;
            link: {
                contactForm: string;
            };
            form: {
                contact: string;
                salutation: string;
                firstName: string;
                lastName: string;
                email: string;
                phone: string;
                subject: string;
                comment: string;
                submit: string;
                privacyPolicy: string;
                emailAddress: string;
            };
            email: {
                from: string;
                subject: string;
            };
        };
        readonly "storefront/header": {
            topBarNav: string;
            currencyDropdown: string;
            languageDropdown: string;
            skipToContentLink: string;
            searchInputAriaLabel: string;
            wishlistIcon: string;
            shoppingCart: string;
        };
        readonly "storefront/home": {
            account: {
                yourAccount: string;
            };
            consent: {
                close: string;
                onlyTechnicallyRequired: string;
                technicallyRequired: string;
                configure: string;
                acceptAllCookies: string;
                cookiePreferences: string;
                marketing: string;
                statistics: string;
                save: string;
            };
            filters: {
                filterPanel: string;
                labelPrefix: string;
                manufacturer: string;
                price: string;
                resetAll: string;
                freeShipping: string;
                rating: string;
                minRating: string;
            };
            listing: {
                addToShoppingCart: string;
            };
        };
        readonly "storefront/login": {
            emailAddress: string;
            password: string;
            loginButton: string;
            forgotPassword: string;
            logout: string;
            invalidCredentials: string;
            successfulLogout: string;
            passwordUpdated: string;
            register: {
                salutation: string;
                firstName: string;
                lastName: string;
                company: string;
                department: string;
                emailAddress: string;
                password: string;
                streetAddress: string;
                city: string;
                country: string;
                postalCode: string;
                state: string;
                differentShippingAddress: string;
                continue: string;
            };
        };
        readonly "storefront/navigation": {
            pageNotFound: {
                title: string;
                backToShop: string;
            };
            home: {
                yourAccount: string;
                manufacturerFilter: string;
                priceFilter: string;
                resetAll: string;
                freeShipping: string;
            };
            footer: {
                contactForm: string;
            };
            category: {
                sorting: string;
                addToCart: string;
                noProductsFound: string;
            };
        };
        readonly "storefront/offCanvasCart": {
            title: string;
            emptyCart: string;
            quantity: string;
            remove: string;
            subtotal: string;
            goToCart: string;
            continueShopping: string;
            addedToCart: string;
            general: {
                title: string;
            };
            buttons: {
                goToCheckout: string;
                goToCart: string;
                continueShopping: string;
            };
        };
        readonly "storefront/order": {
            actions: {
                cancelOrder: string;
                back: string;
            };
            shipping: {
                standard: string;
                express: string;
            };
        };
        readonly "storefront/pageNotFound": {
            title: string;
            message: string;
            backToHome: string;
            searchPlaceholder: string;
            suggestions: string;
            backToShop: string;
        };
        readonly "storefront/payment": {
            methods: {
                cashOnDelivery: string;
                paidInAdvance: string;
                invoice: string;
            };
            actions: {
                change: string;
                completePayment: string;
            };
        };
        readonly "storefront/product": {
            detail: {
                addToCart: string;
                addToWishlist: string;
                availableFrom: string;
                deliveryTime: string;
                description: string;
                price: string;
                quantity: string;
                relatedProducts: string;
                reviews: string;
                specifications: string;
                stock: string;
            };
            listing: {
                filter: string;
                noResults: string;
                showMore: string;
                sortBy: string;
                sorting: string;
                noProductsFound: string;
            };
            search: {
                noResults: string;
                placeholder: string;
                results: string;
            };
            addToCart: string;
            addToWishlist: string;
            removeFromWishlist: string;
            deliveryTime: string;
            quantity: string;
            review: {
                tabTitle: string;
                title: string;
                text: string;
                emptyText: string;
                submitMessage: string;
            };
        };
        readonly "storefront/recover": {
            passwordRecovery: string;
            subtitle: string;
            requestEmail: string;
            back: string;
            emailSent: string;
            newPassword: string;
            passwordConfirmation: string;
            changePassword: string;
            invalidLink: string;
        };
        readonly "storefront/wishlist": {
            removeProduct: string;
        };
    };
};
declare const baseNamespaces: {
    readonly administration: {
        readonly category: {
            general: {
                name: string;
                active: string;
                save: string;
                cancel: string;
                delete: string;
                customFields: string;
            };
            actions: {
                createCategory: string;
                addLandingPage: string;
                configureHomePage: string;
                newCategoryAfter: string;
            };
            tabs: {
                general: string;
                products: string;
                layout: string;
                seo: string;
            };
            fields: {
                categoryType: string;
                linkType: string;
                entity: string;
                openInNewTab: string;
            };
            headings: {
                landingPages: string;
            };
            errors: {
                entityTypeNotFound: string;
            };
            entities: {
                category: string;
                product: string;
                landingPage: string;
            };
        };
        readonly customer: {
            listing: {
                customers: string;
                bulkEdit: string;
                delete: string;
                cancel: string;
                startBulkEdit: string;
                bulkEditItemsSelected: string;
            };
            detail: {
                general: string;
                addresses: string;
                orders: string;
                accept: string;
                decline: string;
                edit: string;
                customerGroupRequestMessage: string;
                customerGroup: string;
                accountStatus: string;
                language: string;
            };
            bulkEdit: {
                headline: string;
                applyChanges: string;
                success: string;
                close: string;
                changes: {
                    customerGroup: string;
                    accountStatus: string;
                    language: string;
                    tags: string;
                    replyToRequest: string;
                };
                placeholders: {
                    selectCustomerGroup: string;
                    selectLanguage: string;
                    selectCustomerGroupRequestReply: string;
                };
            };
        };
        readonly customField: {
            common: {
                technicalName: string;
                position: string;
                labelEnglishGB: string;
            };
            listing: {
                addNewSet: string;
            };
            create: {
                assignTo: string;
                save: string;
                cancel: string;
            };
            detail: {
                type: string;
                modifiableViaStoreApi: string;
                placeholderEnglishGB: string;
                helpTextEnglishGB: string;
                availableInShoppingCart: string;
                select: string;
                newCustomField: string;
                editCustomField: string;
                add: string;
            };
            general: {
                customFields: string;
            };
            actions: {
                edit: string;
                delete: string;
                cancel: string;
                applyChanges: string;
            };
            dialogs: {
                warning: string;
                deleteCustomField: string;
            };
        };
        readonly dataSharing: {
            buttons: {
                agree: string;
                disableDataSharing: string;
                allowAll: string;
                rejectAll: string;
                savePreferences: string;
                declineUsageData: string;
                giveConsentUsageData: string;
            };
            checkboxes: {
                shareStoreData: string;
                shareUsageData: string;
            };
            headlines: {
                consentModal: string;
                storeData: string;
                usageData: string;
                dataConsent: string;
            };
            links: {
                storeDataCollectionDetails: string;
                privacyPolicy: string;
            };
            messages: {
                storeData: string;
                usageData: string;
                sharingData: string;
                termsAgreement: string;
            };
        };
        readonly document: {
            listing: {
                addDocument: string;
            };
            types: {
                invoice: string;
            };
            detail: {
                displayDocumentInMyAccount: string;
                displayDocumentInMyAccountSwitch: string;
                save: string;
            };
        };
        readonly landingPage: {
            create: {
                searchLayoutsPlaceholder: string;
                assignLayout: string;
                createNewLayout: string;
                selectLayout: string;
            };
            general: {
                name: string;
                save: string;
                active: string;
                salesChannels: string;
                seoUrl: string;
            };
            layout: {
                layout: string;
                changeLayout: string;
                editInDesigner: string;
            };
        };
        readonly layout: {
            listing: {
                createNewLayout: string;
            };
            create: {
                shopPage: string;
                landingPage: string;
                listingPage: string;
                productPage: string;
                cancel: string;
                save: string;
                fullWidth: string;
                sidebar: string;
                back: string;
                layoutName: string;
                createLayout: string;
            };
            detail: {
                save: string;
                settings: string;
                blocks: string;
                navigator: string;
                layoutAssignment: string;
            };
        };
        readonly login: {
            username: string;
            emailAddress: string;
            password: string;
            loginButton: string;
        };
        readonly flowBuilder: {
            listing: {
                delete: string;
                downloadFlow: string;
                testFlow: string;
                flowTemplates: string;
            };
            create: {
                addAction: string;
                addConditionIf: string;
                addActionThen: string;
                newFlow: string;
                name: string;
                description: string;
                priority: string;
                active: string;
                tags: string;
            };
            detail: {
                name: string;
            };
            templates: {
                createFromTemplate: string;
                createNewFlowFromTemplate: string;
            };
            messages: {
                deleteConfirmation: string;
            };
        };
        readonly dashboard: {
            dataSharing: {
                agree: string;
                notAtTheMoment: string;
                acceptMessage: string;
                notAtTheMomentMessage: string;
                agreementText: string;
            };
            shopwareServices: {
                close: string;
                exploreNow: string;
            };
            userMenu: {
                logout: string;
            };
            order: {
                orderTitle: string;
                orderOverview: string;
            };
        };
        readonly manufacturer: {
            listing: {
                addManufacturer: string;
            };
            create: {
                name: string;
                website: string;
                save: string;
                cancel: string;
            };
            detail: {
                customFields: string;
            };
            actions: {
                edit: string;
                delete: string;
                cancel: string;
            };
            dialogs: {
                warning: string;
            };
        };
        readonly media: {
            buttons: {
                uploadFile: string;
                addNewFolder: string;
            };
            search: {
                placeholder: string;
            };
            actions: {
                rename: string;
                delete: string;
            };
        };
        readonly order: {
            detail: {
                items: string;
                sendDocument: string;
                openActionsMenu: string;
            };
            contextMenu: {
                sendDocument: string;
                openDocument: string;
                markAsSent: string;
            };
            tabs: {
                general: string;
                details: string;
                documents: string;
            };
            listing: {
                addOrder: string;
            };
            actions: {
                view: string;
                delete: string;
                cancel: string;
            };
            dialogs: {
                warning: string;
            };
        };
        readonly payment: {
            common: {
                name: string;
                availabilityRule: string;
                cashOnDelivery: string;
                paidInAdvance: string;
                invoice: string;
            };
            detail: {};
            methods: {
                customPaymentMethod: string;
            };
        };
        readonly promotion: {
            tabs: {
                general: string;
                conditions: string;
                discounts: string;
            };
            cards: {
                preConditions: string;
            };
            headings: {
                promotionCodes: string;
            };
            actions: {
                addPromotion: string;
                addDiscount: string;
                duplicate: string;
                delete: string;
                edit: string;
                save: string;
                cancel: string;
            };
            fields: {
                priority: string;
            };
            sidebar: {
                refresh: string;
            };
        };
        readonly rule: {
            buttons: {
                createRule: string;
                add: string;
                addAssignment: string;
                save: string;
                cancel: string;
            };
            fields: {
                name: string;
                priority: string;
                description: string;
            };
            errors: {
                unknownRuleType: string;
            };
            testData: {
                ruleDescription: string;
            };
            text: {
                ruleNotInUse: string;
                filter: string;
            };
        };
        readonly settings: {
            header: {
                settings: string;
            };
            links: {
                basicInformation: string;
                cartSettings: string;
                languages: string;
                measurementSystem: string;
                numberRanges: string;
                productUnits: string;
                search: string;
                statusManagement: string;
                customerGroups: string;
                loginAndSignUp: string;
                salutations: string;
                flowBuilder: string;
                importExport: string;
                ruleBuilder: string;
                countries: string;
                currencies: string;
                snippets: string;
                tax: string;
                customFields: string;
                emailTemplates: string;
                media: string;
                newsletter: string;
                seo: string;
                sitemap: string;
                tags: string;
                deliveryTimes: string;
                documents: string;
                essentialCharacteristics: string;
                paymentMethods: string;
                products: string;
                shipping: string;
                cachesAndIndexes: string;
                eventLogs: string;
                firstRunWizard: string;
                integrations: string;
                mailer: string;
                messageQueueStatistics: string;
                privacy: string;
                shopwareAccount: string;
                shopwareServices: string;
                shopwareUpdates: string;
                storefront: string;
                usersAndPermissions: string;
            };
        };
        readonly shipping: {
            common: {
                name: string;
                availabilityRule: string;
            };
            listing: {
                addShippingMethod: string;
            };
            detail: {};
            methods: {
                standard: string;
                express: string;
                customShippingMethod: string;
            };
            dialogs: {
                warning: string;
                cancel: string;
                delete: string;
            };
        };
        readonly yourProfile: {
            tabs: {
                searchPreferences: string;
                privacyPreferences: string;
            };
            fields: {
                firstName: string;
                lastName: string;
                username: string;
                email: string;
            };
            buttons: {
                deselectAll: string;
            };
            links: {
                privacy: string;
            };
            checkboxes: {
                usageDataCheckbox: string;
            };
            headlines: {
                usageDataHeadline: string;
                cardTitle: string;
            };
        };
        readonly customerGroup: {
            listing: {
                customerGroups: string;
            };
            detail: {
                technicalUrl: string;
            };
            create: {
                title: string;
                cardTitle: string;
                save: string;
                cancel: string;
                customSignupForm: string;
                companySignupForm: string;
                seoMetaDescription: string;
            };
        };
        readonly firstRunWizard: {
            welcome: {
                text: string;
            };
            buttons: {
                install: string;
                installMigrationAssistant: string;
                installDemoData: string;
                next: string;
                skip: string;
                finish: string;
                back: string;
                configureLater: string;
                configureOwnSmtpServer: string;
            };
            headers: {
                dataImport: string;
                defaultValues: string;
                mailerConfiguration: string;
                payPalSetup: string;
                extensions: string;
                shopwareAccount: string;
                shopwareStore: string;
                done: string;
            };
            fields: {
                host: string;
                port: string;
                username: string;
                password: string;
                senderAddress: string;
                deliveryAddress: string;
                disableEmailDelivery: string;
            };
            placeholders: {
                selectSalesChannels: string;
                enterEmailAddress: string;
                enterPassword: string;
            };
            regions: {
                germanRegion: string;
                tools: string;
            };
            text: {
                smtpServer: string;
                globalRecommendations: string;
                allDone: string;
                forgotPassword: string;
            };
        };
        readonly shopwareServices: {
            headings: {
                futureProofStore: string;
            };
            buttons: {
                activateServices: string;
                grantPermissions: string;
                deactivate: string;
                exploreNow: string;
            };
            modals: {
                deactivateServices: string;
            };
            messages: {
                accessDenied: string;
            };
            links: {
                shopwareServices: string;
            };
            dashboard: {
                shopwareServicesIntroduction: string;
            };
        };
        readonly product: {
            detail: {
                customFields: string;
                colorProperty: string;
                sizeProperty: string;
                stockPlaceholder: string;
                restockTimePlaceholder: string;
            };
            variants: {
                properties: string;
            };
            flows: {
                tag: string;
            };
            errors: {
                followingErrorOccurred: string;
            };
            bulkEdit: {
                applyChanges: string;
                success: string;
                close: string;
            };
            listing: {
                bulkEdit: string;
                startBulkEdit: string;
            };
            tabs: {
                specifications: string;
                advancedPricing: string;
                variants: string;
                layout: string;
                crossSelling: string;
                seo: string;
                reviews: string;
            };
            buttons: {
                save: string;
                uploadFile: string;
                generateVariants: string;
                next: string;
                saveVariants: string;
            };
            modals: {
                generateVariants: string;
            };
            propertyValues: {
                blue: string;
                red: string;
                green: string;
                small: string;
                medium: string;
                large: string;
            };
        };
        readonly salesChannel: {
            tabs: {
                general: string;
                products: string;
                theme: string;
                analytics: string;
            };
            buttons: {
                addDomain: string;
            };
        };
    };
    readonly storefront: {
        readonly account: {
            common: {
                salutation: string;
                firstName: string;
                lastName: string;
                company: string;
                department: string;
                back: string;
                changePassword: string;
                passwordUpdated: string;
                cashOnDelivery: string;
                paidInAdvance: string;
                invoice: string;
            };
            login: {
                email: string;
                password: string;
                logIn: string;
                logOut: string;
                forgotPassword: string;
                invalidCredentials: string;
                successfulLogout: string;
            };
            profile: {
                saveChanges: string;
                changeEmail: string;
                emailConfirmation: string;
                emailUpdated: string;
                invalidEmail: string;
                emailUpdateFailure: string;
                passwordTooShort: string;
                passwordUpdateFailure: string;
            };
            orders: {
                download: string;
                cancelOrder: string;
                repeatOrder: string;
                changePaymentMethod: string;
                actions: string;
                expand: string;
                showDetails: string;
                creditItem: string;
                orderNumber: string;
                plusVat: string;
                includeVat: string;
                vatSuffix: string;
                shippingCosts: string;
                totalGross: string;
                headlineCompletePayment: string;
                buttonCompletePayment: string;
                editCompleted: string;
            };
            addresses: {
                street: string;
                streetAddress: string;
                city: string;
                country: string;
                postalCode: string;
                state: string;
                editAddress: string;
                addNewAddress: string;
                useAsDefaultBilling: string;
                useAsDefaultShipping: string;
                deliveryNotPossible: string;
            };
            registration: {
                continue: string;
                differentShippingAddress: string;
            };
            general: {
                overview: string;
                personalData: string;
                defaultPaymentMethod: string;
                defaultBillingAddress: string;
                defaultShippingAddress: string;
                yourAccount: string;
                newsletter: string;
                newsletterRegistrationSuccess: string;
                cannotDeliverToCountry: string;
                shippingNotPossible: string;
                customerGroupAccessRequested: string;
            };
            navigation: {
                overview: string;
                yourProfile: string;
                addresses: string;
                orders: string;
                logout: string;
            };
            recovery: {
                title: string;
                subtitle: string;
                requestEmail: string;
                emailSent: string;
                invalidLink: string;
                newPassword: string;
                passwordConfirmation: string;
            };
            payment: {
                change: string;
            };
        };
        readonly address: {
            common: {
                salutation: string;
                firstName: string;
                lastName: string;
                company: string;
                department: string;
                street: string;
                postalCode: string;
            };
            actions: {
                editAddress: string;
                useAsDefaultBilling: string;
                useAsDefaultShipping: string;
                addressOptions: string;
                deleteAddress: string;
            };
            badges: {
                defaultBilling: string;
                defaultShipping: string;
            };
            messages: {
                deliveryNotPossible: string;
            };
        };
        readonly checkout: {
            common: {
                back: string;
                paymentMethod: string;
                cashOnDelivery: string;
                paidInAdvance: string;
                invoice: string;
                shippingMethod: string;
                standard: string;
                express: string;
                grandTotal: string;
                plusVat: string;
                vatSuffix: string;
            };
            cart: {
                shoppingCart: string;
                goToCheckout: string;
                displayShoppingCart: string;
                continueShopping: string;
                promoCode: string;
                emptyCart: string;
                quantity: string;
                stockReached: string;
            };
            confirm: {
                completeOrder: string;
                submitOrder: string;
                termsAndConditions: string;
                immediateAccessToDigitalProduct: string;
            };
            finish: {
                thankYouForOrder: string;
            };
            orderEdit: {
                cancelOrder: string;
            };
        };
        readonly product: {
            addToCart: string;
            quantity: string;
            addToWishlist: string;
            removeFromWishlist: string;
            deliveryTime: string;
            review: {
                tabTitle: string;
                title: string;
                text: string;
                emptyText: string;
                submitMessage: string;
            };
            listing: {
                sorting: string;
                noProductsFound: string;
            };
        };
        readonly navigation: {
            pageNotFound: {
                title: string;
                backToShop: string;
            };
            home: {
                yourAccount: string;
                manufacturerFilter: string;
                priceFilter: string;
                resetAll: string;
                freeShipping: string;
            };
            footer: {
                contactForm: string;
            };
            category: {
                sorting: string;
                addToCart: string;
                noProductsFound: string;
            };
        };
        readonly contact: {
            title: string;
            link: {
                contactForm: string;
            };
            form: {
                contact: string;
                salutation: string;
                firstName: string;
                lastName: string;
                emailAddress: string;
                phone: string;
                subject: string;
                comment: string;
                submit: string;
                privacyPolicy: string;
            };
            email: {
                from: string;
                subject: string;
            };
        };
        readonly consent: {
            cookie: {
                onlyTechnicallyRequired: string;
                configure: string;
                acceptAllCookies: string;
                preferences: string;
                marketing: string;
            };
        };
        readonly header: {
            topBarNav: string;
            currencyDropdown: string;
            languageDropdown: string;
            skipToContentLink: string;
            searchInputAriaLabel: string;
            wishlistIcon: string;
            shoppingCart: string;
        };
        readonly home: {
            account: {
                yourAccount: string;
            };
            consent: {
                close: string;
                onlyTechnicallyRequired: string;
                technicallyRequired: string;
                configure: string;
                acceptAllCookies: string;
                cookiePreferences: string;
                marketing: string;
                statistics: string;
                save: string;
            };
            filters: {
                filterPanel: string;
                labelPrefix: string;
                manufacturer: string;
                price: string;
                resetAll: string;
                freeShipping: string;
                rating: string;
                minRating: string;
            };
            listing: {
                addToShoppingCart: string;
            };
        };
        readonly login: {
            emailAddress: string;
            password: string;
            loginButton: string;
            forgotPassword: string;
            logout: string;
            invalidCredentials: string;
            successfulLogout: string;
            passwordUpdated: string;
            register: {
                salutation: string;
                firstName: string;
                lastName: string;
                company: string;
                department: string;
                emailAddress: string;
                password: string;
                streetAddress: string;
                city: string;
                country: string;
                postalCode: string;
                state: string;
                differentShippingAddress: string;
                continue: string;
            };
        };
        readonly order: {
            actions: {
                cancelOrder: string;
                back: string;
            };
            shipping: {
                standard: string;
                express: string;
            };
        };
        readonly pageNotFound: {
            title: string;
            message: string;
            backToShop: string;
        };
        readonly payment: {
            methods: {
                cashOnDelivery: string;
                paidInAdvance: string;
                invoice: string;
            };
            actions: {
                change: string;
                completePayment: string;
            };
        };
        readonly recover: {
            passwordRecovery: string;
            subtitle: string;
            requestEmail: string;
            back: string;
            emailSent: string;
            newPassword: string;
            passwordConfirmation: string;
            changePassword: string;
            invalidLink: string;
        };
        readonly offCanvasCart: {
            general: {
                title: string;
            };
            buttons: {
                goToCheckout: string;
                goToCart: string;
                continueShopping: string;
            };
        };
        readonly wishlist: {
            removeProduct: string;
        };
    };
};

/** Flatten nested JSON keys to "a.b.c" */
type Paths<T> = T extends object ? {
    [K in keyof T & string]: T[K] extends object ? `${K}` | `${K}.${Paths<T[K]>}` : K;
}[keyof T & string] : never;
type TranslationKey<TNamespaces = typeof baseNamespaces> = TNamespaces extends Record<string, unknown> ? {
    [A in keyof TNamespaces]: {
        [N in keyof TNamespaces[A]]: `${A & string}:${N & string}:${Paths<TNamespaces[A][N]>}`;
    }[keyof TNamespaces[A]];
}[keyof TNamespaces] : never;
type TranslateFn<TKey extends string = TranslationKey> = (key: TKey, options?: Record<string, unknown>) => string;

declare class LanguageHelper {
    private readonly i18nInstance;
    private currentLng;
    private readonly fallbackLng;
    private readonly resources;
    private constructor();
    getLanguage(): string;
    setLanguage(rawLanguage: string): Promise<void>;
    translate(key: TranslationKey, options?: Record<string, unknown>): string;
    static createInstance(rawLanguage: string, customResources?: typeof BUNDLED_RESOURCES): Promise<LanguageHelper>;
    static setForContext(context: Record<string, unknown>, instance: LanguageHelper): void;
    static getFromContext(context: Record<string, unknown>): LanguageHelper | undefined;
}
declare function setCurrentContext(context: Record<string, unknown> | null): void;
declare function getCurrentContext(): Record<string, unknown> | null;
declare function translate(key: TranslationKey, options?: Record<string, unknown>): string;

/**
 * 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>;
}

declare const clearDelayedCache: (adminApiContext: AdminApiContext) => Promise<void>;

declare function mockApiCalls(page: Page): Promise<void>;

declare class Actor {
    page: Page;
    readonly name: string;
    baseURL: string | undefined;
    constructor(name: string, page: Page, baseURL?: string);
    expects: playwright_test.Expect<{}>;
    a11y_checks(locator: Locator): Promise<void>;
    fillsIn(locator: Locator, input: string): Promise<void>;
    presses(locator: Locator, key?: string): Promise<void>;
    selectsRadioButton(radioGroup: Locator, inputLabel: string): Promise<void>;
    attemptsTo(task: () => Promise<void>): Promise<void>;
    goesTo(url: string, forceReload?: boolean): Promise<void>;
    private camelCaseToLowerCase;
}

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;
}

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

interface TestDataFixtureTypes {
    TestDataService: TestDataService;
}

type FeaturesType = Record<string, boolean>;
interface HelperFixtureTypes {
    IdProvider: IdProvider;
    SaaSInstanceSetup: () => Promise<void>;
    InstanceMeta: {
        version: string;
        isSaaS: boolean;
        features: FeaturesType;
    };
    CustomTranslationResources: typeof BUNDLED_RESOURCES | undefined;
    Translate: TranslateFn;
}

interface Country {
    id: string;
}
interface Currency {
    id: string;
}
interface Language {
    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;
    Language: Language;
    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 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 consentDialogCloseButton: 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;
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes["InstanceMeta"];
    constructor(page: Page, instanceMeta: HelperFixtureTypes["InstanceMeta"]);
    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 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 offCanvasLineItemLabel: (productName: string) => Locator;
    readonly offCanvasLineItemProductNumber: (productNumber: string) => Locator;
    readonly offCanvasLineItemDeliveryDate: Locator;
    readonly wishlistAddedButton: Locator;
    readonly wishlistNotAddedButton: Locator;
    readonly propertyRadioGroup: (propertyName: string) => Locator;
    readonly productDetailConfigurator: Locator;
    readonly productDetailConfiguratorGroupTitle: Locator;
    readonly productDetailConfiguratorOptionInputs: Locator;
    readonly productName: Locator;
    readonly productDescriptionTitle: 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;
    readonly page: Page;
    constructor(page: Page);
    getReviewFilterRowOptionsByName(filterOptionName: string): Promise<{
        reviewFilterOptionCheckbox: Locator;
        reviewFilterOptionText: Locator;
        reviewFilterOptionPercentage: Locator;
    }>;
    url(productData: Product): string;
}

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

declare class CheckoutCart implements PageObject {
    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;
    readonly productNameLabel: (productName: string) => Locator;
    readonly productNumberLabel: (productNumber: string) => Locator;
    readonly productDeliveryDateLabel: Locator;
    readonly page: Page;
    constructor(page: Page);
    url(): string;
    getLineItemByProductNumber(productNumber: string): Promise<Record<string, Locator>>;
}

declare class OffCanvasCart implements PageObject {
    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;
    readonly page: Page;
    constructor(page: Page);
    url(): string;
    getLineItemByProductNumber(productNumber: string): Promise<Record<string, Locator>>;
}

declare class CheckoutConfirm implements PageObject {
    readonly headline: Locator;
    readonly termsAndConditionsCheckbox: Locator;
    readonly immediateAccessToDigitalProductCheckbox: Locator;
    readonly grandTotalPrice: Locator;
    readonly taxPrice: Locator;
    readonly submitOrderButton: Locator;
    /**
     * Payment and Shipping options
     */
    readonly paymentMethodRadioGroup: Locator;
    readonly shippingMethodRadioGroup: Locator;
    /**  @deprecated - Use 'paymentMethodRadioGroup' with selectsRadioButton() instead. */
    readonly paymentCashOnDelivery: Locator;
    /**  @deprecated - Use 'paymentMethodRadioGroup' with selectsRadioButton() instead. */
    readonly paymentPaidInAdvance: Locator;
    /**  @deprecated - Use 'paymentMethodRadioGroup' with selectsRadioButton() instead. */
    readonly paymentInvoice: Locator;
    /**  @deprecated - Use 'shippingMethodRadioGroup' with selectsRadioButton() instead. */
    readonly shippingStandard: Locator;
    /**  @deprecated - Use 'shippingMethodRadioGroup' with selectsRadioButton() instead. */
    readonly shippingExpress: Locator;
    /**
     * Product details
     */
    readonly cartLineItemImages: Locator;
    readonly page: Page;
    constructor(page: Page);
    url(): string;
}

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

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

declare class AccountNavigation {
    private readonly page;
    readonly overviewLink: Locator;
    readonly yourProfileLink: Locator;
    readonly addressesLink: Locator;
    readonly ordersLink: Locator;
    readonly logoutLink: Locator;
    constructor(page: Page);
}

declare abstract class BaseAccount implements PageObject {
    readonly page: Page;
    readonly navigation: AccountNavigation;
    protected constructor(page: Page);
    abstract url(): string;
}

declare class Account extends BaseAccount {
    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;
    readonly instanceMeta: HelperFixtureTypes["InstanceMeta"];
    constructor(page: Page, instanceMeta: HelperFixtureTypes["InstanceMeta"]);
    getCustomerGroupAlert(customerGroup: string): Promise<Locator>;
    url(): string;
}

declare class AccountLogin implements PageObject {
    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;
    readonly page: Page;
    constructor(page: Page);
    getShippingCountryLocatorByName(countryName: string): Promise<Locator>;
    url(): string;
}

declare class AccountRecover implements PageObject {
    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;
    readonly page: Page;
    constructor(page: Page);
    url(recoverLink?: string): string;
}

declare class AccountProfile extends BaseAccount {
    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 extends BaseAccount {
    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;
    readonly noOrdersAlert: Locator;
    constructor(page: Page);
    getOrderByOrderNumber(orderNumber: string): Promise<Record<string, Locator>>;
    url(): string;
    private buildTaxPricePattern;
    private escapeRegex;
}

declare class AccountOrderEdit extends BaseAccount {
    readonly headline: Locator;
    readonly paymentMethodRadioGroup: Locator;
    readonly shippingMethodRadioGroup: Locator;
    readonly grandTotalPrice: Locator;
    readonly taxPrice: Locator;
    readonly completePaymentButton: Locator;
    readonly editCompletedHeadline: Locator;
    constructor(page: Page);
    url(orderId?: string): string;
}

declare class AccountAddresses extends BaseAccount {
    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;
    readonly instanceMeta: HelperFixtureTypes["InstanceMeta"];
    constructor(page: Page, instanceMeta: HelperFixtureTypes["InstanceMeta"]);
    url(): string;
    private buildAddressRegex;
    private escapeRegex;
    getAvailableAddress(partialAddressData: Partial<Address>): Promise<Record<string, Locator>>;
    getDefaultShippingAddress(partialAddressData?: Partial<Address>): Promise<Locator>;
    getDefaultBillingAddress(partialAddressData?: Partial<Address>): Promise<Locator>;
}

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

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

declare class SearchSuggest extends Home implements PageObject {
    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;
    readonly page: Page;
    constructor(page: Page, instanceMeta: HelperFixtureTypes["InstanceMeta"]);
    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 completePaymentButton: Locator;
    readonly orderCancelButton: Locator;
    readonly dialogOrderCancel: Locator;
    readonly dialogOrderCancelButton: Locator;
    readonly dialogBackButton: Locator;
    /**
     * Payment and Shipping options
     */
    readonly paymentMethodRadioGroup: Locator;
    readonly shippingMethodRadioGroup: Locator;
    /**  @deprecated - Use 'paymentMethodRadioGroup' with selectsRadioButton() instead. */
    readonly paymentCashOnDelivery: Locator;
    /**  @deprecated - Use 'paymentMethodRadioGroup' with selectsRadioButton() instead. */
    readonly paymentPaidInAdvance: Locator;
    /**  @deprecated - Use 'paymentMethodRadioGroup' with selectsRadioButton() instead. */
    readonly paymentInvoice: Locator;
    /**  @deprecated - Use 'shippingMethodRadioGroup' with selectsRadioButton() instead. */
    readonly shippingStandard: Locator;
    /**  @deprecated - Use 'shippingMethodRadioGroup' with selectsRadioButton() instead. */
    readonly shippingExpress: Locator;
    readonly page: Page;
    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;
}

/**
 * @deprecated - Use AccountAddressDetails instead.
 */
declare class AccountAddressCreate extends BaseAccount {
    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 AccountAddressDetails extends BaseAccount {
    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);
    /**
     * The address details page is used for both creating and editing addresses. The URL contains the address ID when editing an existing address, but not when creating a new one. Therefore, the addressId parameter is optional.
     * @param addressId - The ID of the address being edited. This parameter is optional because the same page object is used for creating new addresses, where no address ID is present in the URL.
     */
    url(addressId?: string): string;
}

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

declare class ContactForm extends Home implements PageObject {
    /**
     * @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;
    readonly instanceMeta: HelperFixtureTypes["InstanceMeta"];
    constructor(page: Page, instanceMeta: HelperFixtureTypes["InstanceMeta"]);
    url(): string;
}

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

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

declare class Header implements PageObject {
    readonly mainNavigationLink: Locator;
    readonly topBarNav: Locator;
    readonly languagesDropdown: Locator;
    readonly languagesMenuOptions: Locator;
    readonly currenciesDropdown: Locator;
    readonly currenciesMenuOptions: Locator;
    readonly searchInput: Locator;
    readonly skipToMainContentLink: Locator;
    readonly wishlistIcon: Locator;
    readonly wishlistBasket: Locator;
    readonly page: Page;
    readonly cartTotal: 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;
    StorefrontAccountOrderEdit: AccountOrderEdit;
    StorefrontAccountAddresses: AccountAddresses;
    StorefrontAccountAddressCreate: AccountAddressCreate;
    StorefrontAccountAddressDetails: AccountAddressDetails;
    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;
    AccountOrderEdit: typeof AccountOrderEdit;
    AccountAddresses: typeof AccountAddresses;
    AccountAddressCreate: typeof AccountAddressCreate;
    AccountAddressDetails: typeof AccountAddressDetails;
    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 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 propertyName: (propertyName: string) => Locator;
    readonly propertyValueCheckbox: (propertyValueName: string) => Locator;
    /** @deprecated - Use 'propertyName' instead. */
    readonly propertyGroupColor: Locator;
    /** @deprecated - Use 'propertyName' instead. */
    readonly propertyGroupSize: Locator;
    /** @deprecated - Use 'propertyValueCheckbox' instead. */
    readonly propertyOptionGrid: Locator;
    /** @deprecated - Use 'propertyValueCheckbox' instead. */
    readonly propertyOptionColorBlue: Locator;
    /** @deprecated - Use 'propertyValueCheckbox' instead. */
    readonly propertyOptionColorRed: Locator;
    /** @deprecated - Use 'propertyValueCheckbox' instead. */
    readonly propertyOptionColorGreen: Locator;
    /** @deprecated - Use 'propertyValueCheckbox' instead. */
    readonly propertyOptionSizeSmall: Locator;
    /** @deprecated - Use 'propertyValueCheckbox' instead. */
    readonly propertyOptionSizeMedium: Locator;
    /** @deprecated - Use 'propertyValueCheckbox' instead. */
    readonly propertyOptionSizeLarge: Locator;
    /**
     * Cards
     */
    readonly customFieldCard: Locator;
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes["InstanceMeta"];
    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 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 contextMenuOpenDocument: Locator;
    readonly contextMenuMarkAsSent: Locator;
    readonly sendDocumentModal: Locator;
    readonly sendDocumentButton: Locator;
    readonly itemsCardHeader: Locator;
    readonly sentCheckmark: Locator;
    readonly orderPaymentStatus: Locator;
    readonly orderDeliveryStatus: Locator;
    readonly orderStatus: Locator;
    /**
     * Tabs
     */
    readonly generalTabLink: Locator;
    readonly detailsTabLink: Locator;
    readonly documentsTabLink: Locator;
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes["InstanceMeta"];
    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;
    }>;
    getDocumentRow(index: number): {
        row: Locator;
        contextMenuButton: Locator;
        sentCheckmark: Locator;
        documentType: Locator;
    };
}

declare class CustomerListing implements PageObject {
    readonly headline: Locator;
    readonly addCustomerButton: Locator;
    readonly bulkEditButton: Locator;
    readonly deleteButton: Locator;
    readonly bulkEditModal: Locator;
    readonly startBulkEditButton: Locator;
    readonly cancelButton: Locator;
    readonly modalHeaderCheckbox: Locator;
    readonly page: Page;
    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 editButton: Locator;
    readonly generalTab: Locator;
    readonly addressesTab: Locator;
    readonly ordersTab: 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;
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes["InstanceMeta"];
    readonly customerEmail: 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 headline: Locator;
    readonly addCustomerGroupButton: Locator;
    readonly page: Page;
    constructor(page: Page);
    getCustomerGroupByName(customerGroup: string): Promise<Record<string, Locator>>;
    url(): string;
}

declare class CustomerGroupCreate implements PageObject {
    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;
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes["InstanceMeta"];
    constructor(page: Page, instanceMeta: HelperFixtureTypes["InstanceMeta"]);
    url(): string;
}

declare class CustomerGroupDetail extends CustomerGroupCreate implements PageObject {
    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 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;
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes["InstanceMeta"];
    constructor(page: Page, instanceMeta: HelperFixtureTypes["InstanceMeta"]);
    url(): string;
}

declare class FlowBuilderCreate implements PageObject {
    readonly contentView: Locator;
    readonly saveButton: Locator;
    readonly header: Locator;
    readonly smartBarHeader: Locator;
    readonly generalTab: Locator;
    readonly flowTab: Locator;
    readonly nameField: Locator;
    readonly descriptionField: Locator;
    readonly priorityField: Locator;
    readonly activeSwitch: Locator;
    readonly triggerSelectField: Locator;
    readonly modalAddButton: Locator;
    readonly sequenceSelectorConditionButton: Locator;
    readonly conditionSelectField: Locator;
    readonly sequenceSelectorActionButton: Locator;
    readonly actionSelectField: Locator;
    readonly selectFieldResultList: Locator;
    readonly trueBlock: Locator;
    readonly trueBlockAddConditionButton: Locator;
    readonly trueBlockAddActionButton: Locator;
    readonly trueBlockActionSelectField: Locator;
    readonly trueBlockActionDescription: Locator;
    readonly mailSendModal: Locator;
    readonly mailSendModalTemplateSelectField: Locator;
    readonly falseBlock: Locator;
    readonly falseBlockAddConditionButton: Locator;
    readonly falseBlockAddActionButton: Locator;
    readonly falseBlockActionSelectField: Locator;
    readonly falseBlockActionDescription: Locator;
    readonly tagModal: Locator;
    readonly tagModalTagsSelectField: Locator;
    readonly delayCard: Locator;
    readonly conditionRule: Locator;
    readonly sequenceSeparator: Locator;
    readonly addActionField: Locator;
    readonly newFlowHeader: Locator;
    readonly resultListItem: Locator;
    readonly resultList: Locator;
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes["InstanceMeta"];
    constructor(page: Page, instanceMeta: HelperFixtureTypes["InstanceMeta"]);
    url(flowId?: string, tabName?: string): string;
    getSelectFieldListitem(selectField: Locator, listItem: string): Promise<Locator>;
}

declare class FlowBuilderListing implements PageObject {
    readonly page: Page;
    readonly contentView: Locator;
    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;
    readonly pagination: Locator;
    readonly testFlowNameCells: Locator;
    readonly flowTemplatesTab: Locator;
    constructor(page: Page);
    url(tabName?: string): string;
    getLineItemByFlowName(flowName: string): Promise<Record<string, Locator>>;
}

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

declare class FlowBuilderDetail extends FlowBuilderCreate implements PageObject {
    readonly saveButtonLoader: Locator;
    readonly saveButton: Locator;
    readonly generalTab: Locator;
    readonly flowTab: Locator;
    readonly alertWarning: Locator;
    readonly templateName: Locator;
    readonly alertMessage: Locator;
    readonly successMessage: Locator;
    readonly actionContentTag: Locator;
    readonly skeletonLoader: Locator;
    readonly messageClose: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes["InstanceMeta"]);
    url(flowId: string, tabName?: string): string;
    getTooltipText(toolTipArea: Locator): Promise<string>;
}

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

declare class Dashboard implements PageObject {
    readonly contentView: Locator;
    readonly adminMenuView: Locator;
    readonly adminMenuCatalog: Locator;
    readonly adminMenuOrder: Locator;
    readonly adminMenuOrderOverview: Locator;
    readonly adminMenuCustomer: Locator;
    readonly adminMenuContent: Locator;
    readonly adminMenuMarketing: Locator;
    readonly adminMenuExtension: Locator;
    readonly adminMenuSettings: 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;
    readonly page: Page;
    readonly shopwareServicesAdvertisementBanner: Locator;
    readonly shopwareServicesAdvertisementBannerCloseButton: Locator;
    readonly shopwareServicesExploreNowButton: Locator;
    readonly adminMenuUserActions: Locator;
    readonly adminMenuLogoutButton: Locator;
    constructor(page: Page);
    url(): string;
}

declare class ShippingListing implements PageObject {
    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;
    readonly page: Page;
    constructor(page: Page);
    url(): string;
}

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

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

declare class LandingPageCreate implements PageObject {
    /**
     * 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;
    readonly page: Page;
    constructor(page: Page);
    url(): string;
}

declare class LandingPageDetail implements PageObject {
    /**
     * 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;
    readonly page: Page;
    constructor(page: Page);
    url(landingPageUuid: string): string;
}

declare class Categories implements PageObject {
    /**
     * 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;
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes["InstanceMeta"];
    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 addNewSetButton: Locator;
    readonly customFieldRows: Locator;
    readonly page: Page;
    constructor(page: Page);
    getLineItemByCustomFieldSetName(customFieldSetName: string): Promise<Record<string, Locator>>;
    url(): string;
}

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

declare class CustomFieldDetail extends CustomFieldCreate {
    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;
    readonly instanceMeta: HelperFixtureTypes["InstanceMeta"];
    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 saveButton: Locator;
    readonly cancelButton: Locator;
    readonly customFieldCard: Locator;
    readonly customFieldSetTabs: Locator;
    readonly customFieldSetTabCustomContent: Locator;
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes["InstanceMeta"];
    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 header: Locator;
    readonly nameInput: Locator;
    readonly priorityInput: Locator;
    readonly descriptionInput: Locator;
    readonly typeItem: Locator;
    readonly tagItem: Locator;
    readonly conditionTypeSelectionInput: Locator;
    readonly conditionValueSelectionInput: Locator;
    readonly filtersResultPopoverSelectionList: Locator;
    readonly saveButton: Locator;
    readonly cancelButton: Locator;
    readonly valueNotAvailableTooltip: Locator;
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes["InstanceMeta"];
    constructor(page: Page, instanceMeta: HelperFixtureTypes["InstanceMeta"]);
    url(): string;
    getSelectFieldListitem(selectField: Locator, listItem: string): Promise<Locator>;
}

declare class RuleDetail extends RuleCreate implements PageObject {
    readonly contentView: Locator;
    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 assignmentModal: Locator;
    readonly assignmentModalAddButton: Locator;
    readonly assignmentModalSearchField: Locator;
    readonly conditionSelectField: Locator;
    readonly conditionLineItemGoodsTotalOperator: Locator;
    readonly conditionLineItemGoodsTotalValue: Locator;
    readonly conditionDateRangeOperator: Locator;
    readonly conditionDateRangeDateFieldFirst: Locator;
    readonly conditionDateRangeDateFieldSecond: Locator;
    readonly conditionCustomerSurnameOperator: Locator;
    readonly conditionCustomerSurnameValue: Locator;
    readonly conditionCartLineItemTaxationMatchOperator: Locator;
    readonly conditionCartLineItemTaxationOperator: Locator;
    readonly conditionCartLineItemTaxationValue: Locator;
    readonly conditionTimeRangeValueFirst: Locator;
    readonly conditionTimeRangeValueSecond: Locator;
    readonly conditionOrderCreatedByAdminValue: Locator;
    readonly conditionLineItemGoodsTotalFilter: Locator;
    readonly conditionFilterModal: Locator;
    readonly conditionCartLineItemInStockOperator: Locator;
    readonly conditionCartLineItemInStockValue: Locator;
    readonly conditionFilterModalCloseButtonX: Locator;
    readonly conditionORContainer: Locator;
    readonly adminMenuAvatar: Locator;
    readonly conditionDateRangeUseTimeOperator: Locator | undefined;
    readonly conditionDateRangeTimezoneOperator: Locator | undefined;
    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 createRuleButton: Locator;
    readonly header: Locator;
    readonly grid: Locator;
    readonly page: Page;
    readonly gridCell: Locator;
    constructor(page: Page);
    url(searchTerm: string): string;
}

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

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

declare class ManufacturerDetail extends ManufacturerCreate {
    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 {
    /**
     * Multi selection
     */
    readonly productsTable: Locator;
    readonly bulkEditButton: Locator;
    readonly page: Page;
    /**
     * 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 {
    /**
     * 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;
    readonly page: Page;
    constructor(page: Page);
    url(): string;
    getDropdownEntry(entry: string): Promise<Locator>;
}

declare class CustomerBulkEdit implements PageObject {
    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;
    readonly page: Page;
    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 contentView: Locator;
    readonly header: Locator;
    readonly page: Page;
    readonly basicInformationLink: Locator;
    readonly cartSettingsLink: Locator;
    readonly languagesLink: Locator;
    readonly measurementSystemLink: Locator;
    readonly numberRangesLink: Locator;
    readonly productUnitsLink: Locator;
    readonly searchLink: Locator;
    readonly statusManagementLink: Locator;
    readonly customerGroupsLink: Locator;
    readonly loginAndSignUpLink: Locator;
    readonly salutationsLink: Locator;
    readonly flowBuilderLink: Locator;
    readonly importExportLink: Locator;
    readonly ruleBuilderLink: Locator;
    readonly countriesLink: Locator;
    readonly currenciesLink: Locator;
    readonly snippetsLink: Locator;
    readonly taxLink: Locator;
    readonly customFieldsLink: Locator;
    readonly emailTemplatesLink: Locator;
    readonly mediaLink: Locator;
    readonly newsletterLink: Locator;
    readonly seoLink: Locator;
    readonly sitemapLink: Locator;
    readonly tagsLink: Locator;
    readonly deliveryTimesLink: Locator;
    readonly documentsLink: Locator;
    readonly essentialCharacteristicsLink: Locator;
    readonly paymentMethodsLink: Locator;
    readonly productsLink: Locator;
    readonly shippingLink: Locator;
    readonly cachesAndIndexesLink: Locator;
    readonly eventLogsLink: Locator;
    readonly firstRunWizardLink: Locator;
    readonly integrationsLink: Locator;
    readonly mailerLink: Locator;
    readonly messageQueueStatisticsLink: Locator;
    readonly privacyLink: Locator;
    readonly shopwareAccountLink: Locator;
    readonly shopwareServicesLink: Locator;
    readonly shopwareUpdatesLink: Locator;
    readonly storefrontLink: Locator;
    readonly usersAndPermissionsLink: Locator;
    constructor(page: Page);
    url(): string;
}

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

declare class DocumentDetail implements PageObject {
    /** @deprecated - Use 'displayDocumentInMyAccountSwitch' instead. */
    readonly showInAccountSwitch: Locator;
    readonly displayDocumentInMyAccountSwitch: Locator;
    readonly saveButton: Locator;
    readonly documentTypeSelect: Locator;
    readonly page: Page;
    constructor(page: Page);
    url(documentId: string): string;
}

declare class ShopwareServices implements PageObject {
    readonly header: Locator;
    readonly deactivatedBanner: Locator;
    readonly activateServicesButton: Locator;
    readonly permissionBanner: Locator;
    readonly permissionGrantButton: Locator;
    readonly serviceCards: Locator;
    readonly deactivateServicesConfirmButton: Locator;
    readonly deactivateServicesButton: Locator;
    readonly deactivateServicesModal: Locator;
    readonly page: Page;
    constructor(page: Page);
    url(): string;
}

declare class PromotionsListing implements PageObject {
    private readonly instanceMeta;
    readonly page: Page;
    readonly smartBar: Locator;
    readonly smartBarHeader: Locator;
    readonly languageSelect: Locator;
    readonly smartBarAddPromotionButton: Locator;
    readonly emptyState: Locator;
    readonly emptyStateAddPromotionButton: Locator;
    readonly promotionsTable: Locator;
    readonly sidebarRefreshButton: Locator;
    constructor(page: Page, instanceMeta: HelperFixtureTypes["InstanceMeta"]);
    /**
     * Returns the url to the listing page.
     *
     * @param searchTerms - Includes search terms for filtering of the promotions list.
     */
    url(searchTerms?: string[]): string;
    /**
     * Returns the table row containing the promotion with the given promotion name.
     *
     * @param promotionName - Promotion name you are looking for.
     */
    getPromotionRow(promotionName: string): Promise<Record<string, Locator>>;
}

declare class PromotionCreate implements PageObject {
    readonly page: Page$1;
    readonly instanceMeta: HelperFixtureTypes["InstanceMeta"];
    readonly smartBar: Locator$1;
    readonly smartBarHeader: Locator$1;
    readonly languageSelect: Locator$1;
    readonly saveButton: Locator$1;
    readonly cancelButton: Locator$1;
    readonly generalCard: Locator$1;
    readonly nameInput: Locator$1;
    readonly priorityInput: Locator$1;
    constructor(page: Page$1, instanceMeta: HelperFixtureTypes["InstanceMeta"]);
    /**
     * Returns the url to the creation page.
     */
    url(): string;
}

declare class PromotionDetail extends PromotionCreate {
    readonly page: Page$1;
    readonly instanceMeta: HelperFixtureTypes["InstanceMeta"];
    readonly tabGeneralLink: Locator$1;
    readonly tabConditionsLink: Locator$1;
    readonly tabDiscountsLink: Locator$1;
    readonly promotionCodesCard: Locator$1;
    readonly promotionCodesHeading: Locator$1;
    readonly promotionCodesSelection: Locator$1;
    readonly preConditionsCard: Locator$1;
    readonly addDiscountButton: Locator$1;
    readonly discountCards: Locator$1;
    constructor(page: Page$1, instanceMeta: HelperFixtureTypes["InstanceMeta"]);
    /**
     * Returns the url to the detail page.
     *
     * @param promotionId - Id of the promotion to show the details of.
     * @param tab - The tab to open. Defaults to 'general'. Other options are 'conditions' and 'discounts'.
     */
    url(promotionId?: string, tab?: "general" | "conditions" | "discounts"): string;
}

declare class Media implements PageObject {
    readonly page: Page;
    readonly uploadFileButton: Locator;
    readonly addNewFolderButton: Locator;
    readonly mediaGridItems: Locator;
    readonly mediaItemCheckbox: Locator;
    readonly mediaItemPreview: Locator;
    readonly mediaItemName: Locator;
    readonly mediaItemContextMenu: Locator;
    readonly searchInput: Locator;
    constructor(page: Page);
    url(): string;
    /**
     * Gets the title/name of a media item by its image alt text
     * @param alt The alt text of the image
     * @returns Promise that resolves to the title text
     */
    getMediaNameByAlt(alt: string): Promise<string>;
    /**
     * Gets a specific media item container by its name/title
     * @param mediaName The name/title of the media item
     * @returns Locator for the specific media item container
     */
    getMediaItemByName(mediaName: string): Locator;
    /**
     * Gets the context menu button for a specific media item by media name
     * @param mediaName The name/title of the media item
     * @returns Locator for the context menu button
     */
    getContextMenuButtonByName(mediaName: string): Locator;
    /**
     * Gets a specific context menu item by its text
     * @param itemText The text of the context menu item (e.g., 'Rename', 'Delete', etc.)
     * @returns Locator for the specific context menu item
     */
    getContextMenuItem(itemText: string): Locator;
}

declare class YourProfile implements PageObject {
    readonly contentView: Locator;
    readonly page: Page;
    readonly searchPreferencesTab: Locator;
    readonly firstNameField: Locator;
    readonly lastNameField: Locator;
    readonly userNameField: Locator;
    readonly emailField: Locator;
    readonly deselectAllButton: Locator;
    readonly privacyPreferencesTab: Locator;
    readonly dataSharingCardTitle: Locator;
    readonly dataSharingUsageDataHeadline: Locator;
    readonly dataSharingUsageDataCheckbox: Locator;
    readonly privacyPolicyLink: Locator;
    constructor(page: Page);
    url(tabName?: string): string;
}

declare class ThemesListing implements PageObject {
    readonly contentView: Locator;
    readonly page: Page;
    readonly installedTheme: (title: string) => Locator;
    constructor(page: Page);
    url(): string;
}

declare class ThemesDetail implements PageObject {
    readonly contentView: Locator;
    readonly page: Page;
    readonly scrollableElement: Locator;
    readonly themeCard: (headline: string) => Locator;
    readonly sidebarButton: Locator;
    constructor(page: Page);
    url(): string;
}

declare class MediaListing implements PageObject {
    readonly page: Page;
    readonly scrollableElementVertical: Locator;
    readonly mediaFolder: (title: string) => Locator;
    readonly emptyState: Locator;
    readonly updatedAtDate: Locator;
    constructor(page: Page);
    url(): string;
}

declare class LayoutListing implements PageObject {
    readonly createNewLayoutButton: Locator;
    readonly viewChangeButton: Locator;
    readonly listingGrid: Locator;
    readonly page: Page;
    readonly pagination: Locator;
    constructor(page: Page);
    url(): string;
}

declare class LayoutCreate implements PageObject {
    readonly shopPageButton: Locator;
    readonly landingPageButton: Locator;
    readonly listingPageButton: Locator;
    readonly productPageButton: Locator;
    readonly cancelButton: Locator;
    readonly saveButton: Locator;
    readonly fullWidthButton: Locator;
    readonly sidebarButton: Locator;
    readonly backButton: Locator;
    readonly layoutNameInput: Locator;
    readonly createLayoutButton: Locator;
    readonly page: Page;
    constructor(page: Page);
    url(): string;
}

declare class ListingPageLayoutDetail implements PageObject {
    readonly addSectionButton: Locator;
    readonly sectionSelectionField: Locator;
    readonly fullWidthSection: Locator;
    readonly sidebarSection: Locator;
    readonly sectionEmptyState: Locator;
    readonly saveButton: Locator;
    readonly loadingSpinner: Locator;
    readonly loaderButton: Locator;
    readonly productListingBlock: Locator;
    readonly sidebarTitle: Locator;
    readonly settingsButton: Locator;
    readonly blocksButton: Locator;
    readonly navigatorButton: Locator;
    readonly layoutAssignmentButton: Locator;
    readonly page: Page;
    constructor(page: Page);
    url(layoutId: string): string;
}

declare class SalesChannelDetail implements PageObject {
    readonly page: Page$1;
    readonly generalTabLink: Locator$1;
    readonly productsTabLink: Locator$1;
    readonly themeTabLink: Locator$1;
    readonly analyticsTabLink: Locator$1;
    readonly addDomainButton: Locator$1;
    constructor(page: Page$1);
    url(salesChannelId: string): string;
}

declare class OrderListing implements PageObject {
    readonly addOrderButton: Locator;
    readonly orderRows: Locator;
    readonly page: Page;
    readonly instanceMeta: HelperFixtureTypes["InstanceMeta"];
    constructor(page: Page, instanceMeta: HelperFixtureTypes["InstanceMeta"]);
    getLineItemByOrderNumber(orderNumber: string): Promise<{
        orderNumberText: Locator;
        orderCustomerNameText: Locator;
        orderDeliveryAddressText: Locator;
        orderTotalAmountText: Locator;
        orderStateText: Locator;
        orderPaymentStateText: Locator;
        orderDeliveryStateText: Locator;
        orderDateText: Locator;
        orderCheckbox: Locator;
        orderContextButton: Locator;
        orderViewButton: Locator;
        orderDeleteButton: Locator;
        warningDialog: Locator;
        warningDialogCancelButton: Locator;
        warningDialogDeleteButton: Locator;
    }>;
    url(): string;
}

declare class DataSharingConsentModal implements PageObject {
    readonly page: Page;
    readonly consentModal: Locator;
    readonly allowAllButton: Locator;
    readonly rejectAllButton: Locator;
    readonly savePreferencesButton: Locator;
    readonly declineUsageDataButton: Locator;
    readonly giveConsentUsageDataButton: Locator;
    readonly shareStoreDataHeadline: Locator;
    readonly shareStoreDataText: Locator;
    readonly shareStoreDataCheckbox: Locator;
    readonly shareUsageDataHeadline: Locator;
    readonly shareUsageDataText: Locator;
    readonly shareUsageDataCheckbox: Locator;
    readonly storeDataCollectionDetailsLink: Locator;
    readonly privacyPolicyLink: Locator;
    constructor(page: Page);
    url(): 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;
    AdminPromotionsListing: PromotionsListing;
    AdminPromotionCreate: PromotionCreate;
    AdminPromotionDetail: PromotionDetail;
    AdminSalesChannelDetail: SalesChannelDetail;
    AdminShopwareServices: ShopwareServices;
    AdminMedia: Media;
    AdminYourProfile: YourProfile;
    AdminThemesListing: ThemesListing;
    AdminThemesDetail: ThemesDetail;
    AdminMediaListing: MediaListing;
    AdminLayoutListing: LayoutListing;
    AdminListingPageLayoutDetail: ListingPageLayoutDetail;
    AdminLayoutCreate: LayoutCreate;
    AdminOrderListing: OrderListing;
    AdminDataSharingConsentModal: DataSharingConsentModal;
}
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;
    SalesChannelDetail: typeof SalesChannelDetail;
    ShopwareServices: typeof ShopwareServices;
    PromotionsListing: typeof PromotionsListing;
    PromotionCreate: typeof PromotionCreate;
    PromotionDetail: typeof PromotionDetail;
    Media: typeof Media;
    YourProfile: typeof YourProfile;
    ThemesListing: typeof ThemesListing;
    ThemesDetail: typeof ThemesDetail;
    MediaListing: typeof MediaListing;
    LayoutListing: typeof LayoutListing;
    ListingPageLayoutDetail: typeof ListingPageLayoutDetail;
    LayoutCreate: typeof LayoutCreate;
    OrderListing: typeof OrderListing;
    DataSharingConsentModal: typeof DataSharingConsentModal;
};

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"];
}

interface FeatureFixtureTypes {
    FeatureService: FeatureService;
}

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

interface StoreBaseConfig {
    storefrontTypeId: string;
    currentLocaleId: string;
    currentLanguageId: string;
    currentCurrencyId: string;
    defaultCurrencyId: string;
    defaultLanguageId: string;
    invoicePaymentMethodId: string;
    defaultShippingMethod: string;
    taxId: string;
    currentCountryId: string;
    currentSnippetSetId: 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;
    };
}

/**
 * Creates a new admin page context (login page) without the actual login.
 * @param browser - The Playwright Browser instance.
 * @param SalesChannelBaseConfig - The sales channel base configuration fixture.
 * @returns The Playwright Page instance for the admin login page.
 */
declare function createNewAdminPageContext(browser: Browser, SalesChannelBaseConfig: DefaultSalesChannelTypes["SalesChannelBaseConfig"]): Promise<Page$1>;
/**
 * Performs admin login on the given page with the provided merchant user.
 * @param adminLoginPage - The Playwright Page instance for the admin login page.
 * @param merchant - The merchant user.
 * @param AdminApiContext - The API request context for admin API calls.
 * @returns The logged-in admin Page instance.
 */
declare function loginToAdministration(adminLoginPage: Page$1, merchant: User, AdminApiContext: FixtureTypes["AdminApiContext"]): Promise<Page$1>;

type FileChooserLike = {
    setFiles(files: {
        name: string;
        mimeType: string;
        buffer: Buffer;
    }): Promise<void>;
};
type ResponseLike = {
    ok(): boolean;
};
type UploadMediaTarget = {
    page: {
        waitForEvent(event: 'filechooser'): Promise<FileChooserLike>;
        waitForResponse(urlOrPredicate: string | ((response: {
            url(): string;
            ok(): boolean;
        }) => boolean)): Promise<ResponseLike>;
    };
    uploadMediaButton: {
        click(): Promise<void>;
    };
};
declare function uploadRandomPngMedia(target: UploadMediaTarget, imageName: string): Promise<void>;

/**
 * Generic task type that accepts any parameters
 */
type Task<TArgs extends unknown[] = any[]> = (...args: TArgs) => () => 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;
} & {
    CreateFlow: Task;
} & {
    LoginViaReviewsTab: Task;
} & {
    CheckAccessToShopwareServices: Task;
} & {
    CheckVisibilityOfServicesBanner: Task;
} & {
    DeactivateShopwareServices: Task;
} & {
    Login: Task;
} & {
    Logout: Task;
} & {
    Register: Task;
} & {
    RegisterGuest: Task;
} & {
    ChangeStorefrontCurrency: Task;
} & {
    AddNewAddress: Task;
} & {
    AddProductToCart: Task;
} & {
    CloseTheOffCanvasCart: Task;
} & {
    ChangeProductQuantity: Task;
} & {
    ProceedFromProductToCheckout: Task;
} & {
    ProceedFromCartToCheckout: Task;
} & {
    ConfirmTermsAndConditions: Task;
} & {
    SelectPaymentMethod: Task;
} & {
    SelectShippingMethod: Task;
} & {
    SelectInvoicePaymentOption: Task;
} & {
    SelectCashOnDeliveryPaymentOption: Task;
} & {
    SelectPaidInAdvancePaymentOption: Task;
} & {
    SelectStandardShippingOption: Task;
} & {
    SelectExpressShippingOption: Task;
} & {
    SubmitOrder: Task;
} & {
    OpenSearchResultPage: Task;
} & {
    OpenSearchSuggestPage: Task;
} & {
    SearchForTerm: Task;
} & {
    ValidateAccessibility: (pageName: string, assertViolations?: boolean | number, createReport?: boolean, ruleTags?: string[], outputDir?: string) => () => Promise<axe_core.Result[]>;
} & {
    RemoveProductFromWishlist: Task;
} & {
    AddProductToCartFromWishlist: Task;
} & {
    AddProductToWishlist: Task;
} & {
    SelectProductFilterOption: Task;
} & {
    CheckVisibilityInHome: Task;
}, playwright_test.PlaywrightWorkerArgs & playwright_test.PlaywrightWorkerOptions & FixtureTypes>;

export { Actor, AdminPageObjects, BUNDLED_RESOURCES, COUNTRY_ADDRESS_DATA, FeatureService, IdProvider, LanguageHelper, RuleType, StorefrontPageObjects, TestDataService, assertScreenshot, baseNamespaces, clearDelayedCache, compareFlowTemplateWithFlow, createNewAdminPageContext, createRandomImage, createSolidColorImage, encodeImage, extractIdFromUrl, formatPrice, getCountryAddressData, getCountryCodeFromLocale, getCountryId, getCurrency, getCurrencyCodeFromLocale, getCurrencySymbolFromLocale, getCurrentContext, getDefaultShippingMethodId, getFlow, getFlowId, getFlowTemplate, getLanguageCode, getLanguageData, getLocale, getMediaId, getOrderTransactionId, getPaymentMethodId, getPromotionWithDiscount, getSalutationId, getShippingMethodId, getSnippetSetId, getStateMachineId, getStateMachineStateId, getTaxId, getThemeId, hideElements, isSaaSInstance, isThemeCompiled, loginToAdministration, mockApiCalls, replaceElements, replaceElementsIndividually, setCurrentContext, setOrderStatus, setViewport, test, translate, updateAdminUser, uploadRandomPngMedia };
export type { AccountData, AclRole, Address, CalculatedTaxes, Category$1 as Category, CategoryCustomizableLinkData, CategoryData, CmsPage, Country$1 as Country, CreatedRecord, Currency$2 as Currency, CustomField, CustomFieldData, CustomFieldSet, Customer, CustomerAddress, CustomerGroup, DataServiceOptions, DeliveryTime, FixtureTypes, Flow, FlowConfig, FlowTemplate, Language$2 as Language, Manufacturer, Media$1 as Media, Options, Order, OrderDelivery, OrderLineItem, OrderStatus, PageObject, PaymentMethod$1 as PaymentMethod, Price, Product, ProductCrossSelling, ProductPrice, ProductReview, Promotion, PromotionDiscount, PropertyGroup, PropertyGroupOption, RegistrationData, ReplaceTarget, Rule, RuleAssignmentEntity, SalesChannel, SalesChannelAnalytics, SalesChannelDomain, SalesChannelRecord, Salutation, ShippingMethod$1 as ShippingMethod, SimpleLineItem, StateMachine, StateMachineState, SyncApiOperation, SystemConfig, Tag, TagData, Task, Tax$1 as Tax, TaxRules, TranslateFn, TranslationKey, UploadMediaTarget, User, VariantListingConfig };