import * as vue from 'vue';
import { CSSProperties, ComputedRef, AnchorHTMLAttributes, ImgHTMLAttributes, App, EffectScope, Ref } from 'vue';
import { createAPIClient, ApiError } from '@shopware/api-client';
import { operations as operations$1, components } from '@shopware/api-client/store-api-types';
import { getListingFilters, TierPrice } from '@shopware-pwa/helpers-next';

type operations = operations$1;
type Schemas = components["schemas"];
type ApiClient = ReturnType<typeof createAPIClient<operations>>;

type BlockType<SLOT_NAMES> = Schemas["CmsBlock"] & {
    slots: Array<Schemas["CmsSlot"] & {
        slot: SLOT_NAMES;
    }>;
};
type THREE_COLUMNS = "left" | "center" | "right";
type TWO_COLUMNS = "left" | "right";
type CmsBlockText = BlockType<"content">;
type CmsBlockTextHero = BlockType<"content">;
type CmsBlockTextTeaser = BlockType<"content">;
type CmsBlockTextTeaserSection = BlockType<TWO_COLUMNS>;
type CmsBlockTextTwoColumn = BlockType<TWO_COLUMNS>;
type CmsBlockTextThreeColumn = BlockType<THREE_COLUMNS>;
type CmsBlockImage = BlockType<"image">;
type CmsBlockImageCover = BlockType<"image">;
type CmsBlockImageTwoColumn = BlockType<TWO_COLUMNS>;
type CmsBlockImageThreeColumn = BlockType<THREE_COLUMNS>;
type CmsBlockImageThreeCover = BlockType<THREE_COLUMNS>;
type CmsBlockImageFourColumn = BlockType<"left" | "center-left" | "center-right" | "right">;
type CmsBlockImageBubbleRow = BlockType<THREE_COLUMNS>;
type CmsBlockImageHighlightRow = BlockType<THREE_COLUMNS>;
type CmsBlockImageSimpleGrid = BlockType<"left-top" | "left-bottom" | "right">;
type CmsBlockImageSlider = BlockType<"imageSlider">;
type CmsBlockImageGallery = BlockType<"imageGallery">;
type CmsBlockYoutubeVideo = BlockType<"video">;
type CmsBlockVimeoVideo = BlockType<"video">;
type CmsBlockImageText = BlockType<TWO_COLUMNS>;
type CmsBlockImageTextCover = BlockType<TWO_COLUMNS>;
type CmsBlockCenterText = BlockType<THREE_COLUMNS>;
type CmsBlockImageTextRow = BlockType<"left-image" | "left-text" | "center-image" | "center-text" | "right-image" | "right-text">;
type CmsBlockImageTextGallery = BlockType<"left-image" | "left-text" | "center-image" | "center-text" | "right-image" | "right-text">;
type CmsBlockImageTextBubble = BlockType<"left-image" | "left-text" | "center-image" | "center-text" | "right-image" | "right-text">;
type CmsBlockTextOnImage = BlockType<"content">;
type CmsBlockSidebarFilter = BlockType<"content">;
type CmsBlockCategoryNavigation = BlockType<"content">;
type CmsBlockProductHeading = BlockType<TWO_COLUMNS>;
type CmsBlockProductThreeColumn = BlockType<THREE_COLUMNS>;
type CmsBlockProductListing = BlockType<"content">;
type CmsBlockProductSlider = BlockType<"productSlider">;
type CmsBlockGalleryBuybox = BlockType<TWO_COLUMNS>;
type CmsBlockProductDescriptionReviews = BlockType<"content">;
type CmsBlockCrossSelling = BlockType<"content">;
type CmsBlockForm = BlockType<"content">;

type SourceType = "static" | "mapped";
type Position = "left" | "center" | "right";
type DisplayMode = Exclude<CSSProperties["objectFit"], undefined> | "standard";
type BoxLayout = "standard" | "image" | "minimal";
type VerticalAlign = "flex-start" | "center" | "flex-end" | "";
type ElementConfig<VALUE_TYPE> = {
    source: SourceType;
    value: VALUE_TYPE;
};
type TextElementConfig = {
    content: ElementConfig<string>;
    verticalAlign: ElementConfig<VerticalAlign>;
};
type ElementFieldConfig = {
    name: string;
    source: SourceType;
    value: string | null;
    apiAlias: string;
};
type CmsElementText = Schemas["CmsSlot"] & {
    type: "text" | typeof String;
    slot: typeof String;
    config: TextElementConfig;
    fieldConfig: ElementFieldConfig[];
    data: {
        content: string;
        apiAlias: "cms_text";
    };
    translated: {
        config: TextElementConfig;
    };
};
type ImageElementConfig = {
    url: ElementConfig<string>;
    media: ElementConfig<string>;
    newTab: ElementConfig<boolean>;
    product: ElementConfig<string>;
    boxLayout: ElementConfig<BoxLayout>;
    displayMode: ElementConfig<DisplayMode>;
    minHeight: ElementConfig<string | number>;
    verticalAlign: ElementConfig<VerticalAlign>;
    horizontalAlign: ElementConfig<VerticalAlign>;
};
type CmsElementImage = Schemas["CmsSlot"] & {
    type: "image";
    config: ImageElementConfig;
    data: {
        mediaId: string;
        url: string;
        newTab: boolean;
        apiAlias: "cms_image";
        media: Schemas["Media"];
    };
};
type SliderElementConfig = {
    minWidth?: ElementConfig<string>;
    minHeight: ElementConfig<string | number>;
    verticalAlign?: ElementConfig<VerticalAlign>;
    displayMode?: ElementConfig<"standard" | "cover" | "contain">;
    navigationDots?: ElementConfig<"outside" | "inside" | "">;
    navigationArrows?: ElementConfig<"outside" | "inside" | "">;
};
type ImageSliderElementConfig = ImageElementConfig & SliderElementConfig & {
    sliderItems: ElementConfig<Array<{
        url: null | string;
        newTab: boolean;
        mediaId: string;
        mediaUrl: string;
    }>>;
};
type CmsElementImageSlider = Schemas["CmsSlot"] & {
    type: "image-slider";
    config: ImageSliderElementConfig;
    data: {
        apiAlias: "cms_image_slider";
        navigation: unknown;
        sliderItems: {
            url: string;
            newTab: boolean;
            media: Schemas["Media"];
            mediaId: string;
            apiAlias: "cms_image_slider_item";
        }[];
    };
};
type ImageGalleryElementConfig = ImageSliderElementConfig & {
    galleryPosition: ElementConfig<Position>;
    magnifierOverGallery: ElementConfig<boolean>;
    keepAspectRatioOnZoom: ElementConfig<boolean>;
    fullScreen: ElementConfig<boolean>;
    zoom: ElementConfig<boolean>;
};
type CmsElementImageGallery = Schemas["CmsSlot"] & {
    type: "image-gallery";
    config: ImageGalleryElementConfig;
    data: {
        apiAlias: "cms_image_slider";
        navigation: unknown;
        sliderItems: Array<{
            url: null | string;
            newTab: boolean;
            media: Schemas["Media"];
            apiAlias: "cms_image_slider_item";
        } | Schemas["ProductMedia"]>;
    };
};
type YouTubeVideoElementConfig = {
    end: ElementConfig<string>;
    url: ElementConfig<string>;
    loop: ElementConfig<boolean>;
    start: ElementConfig<string>;
    videoID: ElementConfig<string>;
    autoPlay: ElementConfig<boolean>;
    displayMode: ElementConfig<DisplayMode>;
    previewMedia: ElementConfig<string>;
    showControls: ElementConfig<boolean>;
    needsConfirmation: ElementConfig<boolean>;
    advancePrivacyMode: ElementConfig<boolean>;
};
type CmsElementYoutubeVideo = Schemas["CmsSlot"] & {
    type: "youtube-video";
    config: YouTubeVideoElementConfig;
    data: {
        mediaId: string | null;
        url: null | string;
        newTab: null | boolean;
        media: null | Schemas["Media"];
        apiAlias: "cms_image";
    };
};
type VimeoVideoElementConfig = {
    loop: ElementConfig<boolean>;
    color: ElementConfig<string>;
    title: ElementConfig<boolean>;
    mute: ElementConfig<boolean>;
    byLine: ElementConfig<boolean>;
    videoID: ElementConfig<string>;
    autoplay: ElementConfig<boolean>;
    controls: ElementConfig<boolean>;
    portrait: ElementConfig<boolean>;
    doNotTrack: ElementConfig<boolean>;
    previewMedia: ElementConfig<string>;
    needsConfirmation: ElementConfig<boolean>;
};
type CmsElementVimeoVideo = Schemas["CmsSlot"] & {
    type: "vimeo-video";
    config: VimeoVideoElementConfig;
    data: {
        mediaId: string | null;
        url: null | string;
        newTab: null | boolean;
        media: null | Schemas["Media"];
        apiAlias: "cms_image";
    };
};
type ProductBoxElementConfig = {
    boxLayout: ElementConfig<BoxLayout>;
    product: ElementConfig<string>;
};
type CmsElementProductBox = Schemas["CmsSlot"] & {
    type: "product-box";
    config: ProductBoxElementConfig;
    data: {
        productId: string;
        product: Schemas["Product"];
        apiAlias: "cms_product_box";
    };
};
type ProductSliderElementConfig = {
    title: ElementConfig<string>;
    border: ElementConfig<boolean>;
    rotate: ElementConfig<boolean>;
    products: ElementConfig<string[]>;
    boxLayout: ElementConfig<BoxLayout>;
    elMinWidth: ElementConfig<string>;
    navigation: ElementConfig<boolean>;
    displayMode: ElementConfig<DisplayMode>;
    verticalAlign: ElementConfig<VerticalAlign>;
    productStream: ElementConfig<string>;
    productStreamSorting: ElementConfig<string>;
};
type CmsElementProductSlider = Schemas["CmsSlot"] & {
    type: "product-slider";
    config: ProductSliderElementConfig;
    data: {
        apiAlias: "cms_product_slider";
        products: Schemas["Product"][];
    };
};
type CmsSidebarFilterElementConfig = {
    boxLayout: ElementConfig<BoxLayout>;
    content: ElementConfig<string>;
    displayMode: ElementConfig<DisplayMode>;
    media: ElementConfig<string>;
    minHeight: ElementConfig<string | number>;
    newTab: ElementConfig<boolean>;
    url: ElementConfig<string>;
    verticalAlign: ElementConfig<VerticalAlign>;
};
type CmsElementSidebarFilter = Schemas["CmsSlot"] & {
    type: "sidebar-filter";
    config: CmsSidebarFilterElementConfig;
};
type CmsProductListingElementConfig = {
    filters: ElementConfig<string>;
    boxLayout: ElementConfig<BoxLayout>;
    showSorting: ElementConfig<boolean>;
    defaultSorting: ElementConfig<string>;
    useCustomSorting: ElementConfig<boolean>;
    availableSortings: ElementConfig<string[]>;
    propertyWhitelist: ElementConfig<string[]>;
};
type CmsElementProductListing = Schemas["CmsSlot"] & {
    type: "product-listing";
    config: CmsProductListingElementConfig;
    data: {
        apiAlias: "cms_product_listing";
        listing: Schemas["ProductListingResult"];
    };
};
type CategoryNavigationElementConfig = unknown;
type CmsElementCategoryNavigation = Schemas["CmsSlot"] & {
    type: "category-navigation";
    config: CategoryNavigationElementConfig;
};
type ProductDescriptionReviewsElementConfig = {
    product: ElementConfig<string>;
    alignment: ElementConfig<VerticalAlign>;
};
type CmsElementProductDescriptionReviews = Schemas["CmsSlot"] & {
    type: "product-description-reviews";
    config: ProductDescriptionReviewsElementConfig;
    data: {
        productId: null | string;
        ratingSuccess: boolean;
        product?: Schemas["Product"];
        reviews: {
            elements: Schemas["ProductReview"][];
        };
        apiAlias: "cms_product_description_reviews";
    };
};
type BuyBoxElementConfig = ProductDescriptionReviewsElementConfig;
type CmsElementBuyBox = Schemas["CmsSlot"] & {
    type: "buy-box";
    config: BuyBoxElementConfig;
    data: {
        configuratorSettings: Schemas["PropertyGroup"][] | null;
        productId: null | string;
        ratingSuccess: boolean;
        product?: Schemas["Product"];
        reviews: Schemas["ProductReview"][];
        apiAlias: "cms_product_description_reviews";
    };
};
type CrossSellingElementConfig = {
    product: ElementConfig<string>;
    alignment: ElementConfig<VerticalAlign>;
    boxLayout: ElementConfig<BoxLayout>;
    elMinWidth: ElementConfig<string>;
    displayMode: ElementConfig<DisplayMode>;
};
type CmsElementCrossSelling = Schemas["CmsSlot"] & {
    type: "cross-selling";
    config: CrossSellingElementConfig;
    data: {
        apiAlias: "cms_cross_selling";
        crossSellings: Schemas["CrossSellingElement"][];
    };
};
type FormElementConfig = {
    type: ElementConfig<"contact" | "newsletter">;
    title: ElementConfig<string>;
    mailReceiver: ElementConfig<string[]>;
    confirmationText: ElementConfig<string>;
    defaultMailReceiver: ElementConfig<boolean>;
};
type CmsElementForm = Schemas["CmsSlot"] & {
    type: "form";
    config: FormElementConfig;
    data: Schemas["Salutation"][];
};
type CmsElementProductName = Schemas["CmsSlot"] & {
    type: "product-name";
    config: TextElementConfig;
    fieldConfig: ElementFieldConfig[];
    data: {
        content: string;
        apiAlias: "cms_text";
    };
    translated: {
        config: TextElementConfig;
    };
};
type CmsElementManufacturerLogo = Schemas["CmsSlot"] & {
    type: "manufacturer-logo";
    config: ImageElementConfig;
    data: {
        mediaId: string;
        url: string;
        newTab: boolean;
        apiAlias: "cms_manufacturer_logo";
        media: Schemas["Media"];
    };
};

type CmsSectionBlock<TYPE extends Schemas["CmsSection"]["type"], SECTION_POSITIONS> = Schemas["CmsSection"] & {
    type: TYPE;
    blocks: Array<Schemas["CmsBlock"] & {
        sectionPosition: SECTION_POSITIONS;
    }>;
};
type CmsSectionDefault = CmsSectionBlock<"default", "main">;
type CmsSectionSidebar = CmsSectionBlock<"sidebar", "sidebar" | "main">;

type ImageContainerAttrs = {
    href?: string;
    target?: string;
    rel?: string;
};
type UseCmsElementImage = {
    containerStyle: ComputedRef<CSSProperties>;
    anchorAttrs: ComputedRef<AnchorHTMLAttributes>;
    imageAttrs: ComputedRef<ImgHTMLAttributes>;
    imageContainerAttrs: ComputedRef<ImageContainerAttrs>;
    imageLink: ComputedRef<{
        newTab: boolean;
        url: string;
    }>;
    displayMode: ComputedRef<DisplayMode>;
    isVideoElement: ComputedRef<boolean>;
    mimeType: ComputedRef<string | undefined>;
};
/**
 * Composable to get cms element image
 *
 * @category CMS (Shopping Experiences)
 */
declare function useCmsElementImage(element: CmsElementImage | CmsElementManufacturerLogo): UseCmsElementImage;

/**
 * Composable to get cms element config
 *
 * @category CMS (Shopping Experiences)
 */
declare function useCmsElementConfig<T extends Schemas["CmsSlot"] & {
    config: T["config"] extends {
        [key in infer X extends keyof T["config"]]: ElementConfig<unknown>;
    } ? {
        [key in X]: ElementConfig<T["config"][key]["value"]>;
    } : never;
}>(element: T): {
    getConfigValue: <ELEMENT_CONFIG extends keyof T["config"]>(key: ELEMENT_CONFIG) => (typeof element.config)[ELEMENT_CONFIG]["value"];
};

declare function createShopwareContext(app: App, options: {
    devStorefrontUrl?: string | null;
    enableDevtools?: boolean;
}): vue.Raw<{
    install(app: App): void;
    _a: App<any>;
    _e: EffectScope;
    devStorefrontUrl: string | null | undefined;
    state: {
        interceptors: {};
    } | undefined;
}>;

type UseAddressReturn = {
    /**
     * List of customer addresses
     */
    customerAddresses: ComputedRef<Schemas["CustomerAddress"][]>;
    /**
     * Loads the addresses that are available under `customerAddresses` property
     */
    loadCustomerAddresses(): Promise<Schemas["CustomerAddress"][]>;
    /**
     * Allows to create new address for a current customer
     */
    createCustomerAddress(customerAddress: Schemas["CustomerAddress"]): Promise<Schemas["CustomerAddress"]>;
    /**
     * Allows to update existing address for a current customer
     */
    updateCustomerAddress(customerAddress: Schemas["CustomerAddress"]): Promise<Schemas["CustomerAddress"]>;
    /**
     * Allows to delete existing address for a current customer
     */
    deleteCustomerAddress(addressId: string): Promise<void>;
    /**
     * Sets the address for given ID as default billing address
     */
    setDefaultCustomerBillingAddress(addressId: string): Promise<string>;
    /**
     * Sets the address for given ID as default shipping address
     */
    setDefaultCustomerShippingAddress(addressId: string): Promise<string>;
    /**
     * Returns formatted error message
     *
     * @param {ShopwareError} error
     */
    errorMessageBuilder(error: ApiError): string | null;
};
/**
 * Composable to manage customer addresses
 *
 * With this composable you can:
 * - Fetch customer addresses
 * - Return customer addresses
 * - Create new customer address
 * - Update existing customer address
 * - Delete existing customer address
 * - Set default billing address
 * - Set default shipping address
 * - Format error message
 *
 * @public
 *
 * @category Cart & Checkout
 */
declare function useAddress(): UseAddressReturn;

type UseAddToCartReturn = {
    /**
     * Add to cart method
     * @type {function}
     */
    addToCart(): Promise<Schemas["Cart"]>;
    /**
     * If you want to add more that 1 product set quantity before invoking `addToCart`
     */
    quantity: Ref<number>;
    /**
     * Returns product count in stock
     */
    getStock: ComputedRef<number | undefined>;
    /**
     * Returns product count in available stock
     */
    getAvailableStock: ComputedRef<number | undefined>;
    /**
     * Flag if product is already in cart
     */
    isInCart: ComputedRef<boolean>;
    /**
     * count of the product quantity already in the cart
     */
    count: ComputedRef<number>;
};
/**
 * Composable to manage adding product to cart
 *
 * With this composable you can:
 * - Add product to cart
 * - Get product quantity
 * - Get product stock
 * - Get product available stock
 * - Check if product is in cart
 * - Get product count in cart
 *
 * @public
 * @category Cart & Checkout
 */
declare function useAddToCart(product: Ref<Schemas["Product"] | undefined>): UseAddToCartReturn;

/**
 * @internal
 */
type Breadcrumb = {
    name: string;
    path?: string;
} | Schemas["Breadcrumb"];
/**
 * @public
 */
type UseBreadcrumbsReturn = {
    /**
     * Clear breadcrumbs store
     */
    clearBreadcrumbs(): void;
    /**
     * List of breadcrumbs
     */
    breadcrumbs: ComputedRef<Breadcrumb[]>;
    /**
     * Build breadcrumbs dynamically for a category by fetching them from the API
     *
     * @param {operations["readBreadcrumb get /breadcrumb/{id}"]["response"]} breadcrumbs
     */
    buildDynamicBreadcrumbs(breadcrumbs: operations["readBreadcrumb get /breadcrumb/{id}"]["response"]): Promise<void>;
    /**
     * Add a breadcrumb to the breadcrumbs list
     *
     * @param {Breadcrumb} breadcrumb
     */
    pushBreadcrumb(breadcrumb: Breadcrumb): void;
};
/**
 * Composable for breadcrumbs management.
 * Read the [guide](https://frontends.shopware.com/getting-started/page-elements/breadcrumbs.html#building-breadcrumbs-for-cms-pages).
 *
 * @public
 * @category CMS (Shopping Experiences)
 */
declare function useBreadcrumbs(newBreadcrumbs?: Breadcrumb[]): UseBreadcrumbsReturn;

/**
 * Composable to manage cart
 *
 * @public
 * @category Cart & Checkout
 */
type UseCartReturn = {
    /**
     * Add product by id and quantity
     */
    addProduct(params: {
        id: string;
        quantity?: number;
    }): Promise<Schemas["Cart"]>;
    /**
     * Add products by array of items
     */
    addProducts(items: operations["addLineItem post /checkout/cart/line-item"]["body"]["items"]): Promise<Schemas["Cart"]>;
    /**
     * Adds a promotion code to the cart
     */
    addPromotionCode(promotionCode: string): Promise<Schemas["Cart"]>;
    /**
     * Lists all applied and active promotion codes
     */
    appliedPromotionCodes: ComputedRef<Schemas["LineItem"][]>;
    /**
     * Current Cart object
     */
    cart: ComputedRef<Schemas["Cart"] | undefined>;
    /**
     * All items in the cart
     */
    cartItems: ComputedRef<Schemas["LineItem"][]>;
    /**
     * Changes the quantity of a product in the cart
     */
    changeProductQuantity(params: {
        id: string;
        quantity: number;
    }): Promise<Schemas["Cart"]>;
    /**
     * The number of items in the cart
     */
    count: ComputedRef<number>;
    /**
     * Refreshes the cart object and related data
     * If @param newCart is provided, it will be used as a new cart object
     */
    refreshCart(newCart?: Schemas["Cart"]): Promise<Schemas["Cart"]>;
    /**
     * Removes the provided LineItem from the cart
     */
    removeItem(lineItem: Schemas["LineItem"]): Promise<Schemas["Cart"]>;
    /**
     * The total price of the cart (including calculated costs like shipping)
     */
    totalPrice: ComputedRef<number>;
    /**
     * Shipping price
     *
     * @deprecated Use `shippingCosts` instead
     */
    shippingTotal: ComputedRef<number>;
    /**
     * Shipping costs
     */
    shippingCosts: ComputedRef<Schemas["CartDelivery"][]>;
    /**
     * The total price of all cart items
     */
    subtotal: ComputedRef<number>;
    /**
     * `true` if the cart contains no items
     */
    isEmpty: ComputedRef<boolean>;
    /**
     * `true` if cart contains only digital items
     */
    isVirtualCart: ComputedRef<boolean>;
    /**
     * Get cart errors
     */
    consumeCartErrors(): Schemas["Cart"]["errors"];
};
/**
 * Cart management logic.
 *
 * Used as [Shared](https://frontends.shopware.com/framework/composables/shared-composables.html) Composable `useCart`
 *
 * @category Cart & Checkout
 */
declare function useCartFunction(): UseCartReturn;
declare const useCart: typeof useCartFunction;

type UseCartItemReturn = {
    /**
     * Calculated price {number} for the current item
     */
    itemRegularPrice: ComputedRef<number | undefined>;
    /**
     * Calculated price {number} for the current item if list price is set
     */
    itemSpecialPrice: ComputedRef<number | undefined>;
    /**
     * Total price for the current item of given quantity in the cart
     */
    itemTotalPrice: ComputedRef<number | undefined>;
    /**
     * Thumbnail url for the current item's entity
     */
    itemImageThumbnailUrl: ComputedRef<string>;
    /**
     * Options (of variation) for the current item
     */
    itemOptions: ComputedRef<Schemas["LineItem"]["payload"]["options"]>;
    /**
     * Type of the current item: "product" or "promotion"
     */
    itemType: ComputedRef<Schemas["LineItem"]["type"] | undefined>;
    /**
     * Determines if the current item is a product
     */
    isProduct: ComputedRef<boolean>;
    /**
     * Determines if the current item is a promotion
     */
    isPromotion: ComputedRef<boolean>;
    /**
     * Determines if the current item can be removed from cart
     */
    isRemovable: ComputedRef<boolean>;
    /**
     * Determines if the current item's quantity can be changed
     */
    isStackable: ComputedRef<boolean>;
    /**
     * Determines if the current item is a digital product (to download)
     */
    isDigital: ComputedRef<boolean>;
    /**
     * Stock information for the current item
     */
    itemStock: ComputedRef<number | undefined>;
    /**
     * Quantity of the current item in the cart
     */
    itemQuantity: ComputedRef<number | undefined>;
    /**
     * Changes the current item quantity in the cart
     */
    changeItemQuantity(quantity: number): Promise<Schemas["Cart"]>;
    /**
     * Removes the current item from the cart
     */
    removeItem(): Promise<Schemas["Cart"]>;
};
/**
 * Composable to manage specific cart item
 * @public
 * @category Cart & Checkout
 */
declare function useCartItem(cartItem: Ref<Schemas["LineItem"]>): UseCartItemReturn;

type UseCategoryReturn = {
    /**
     * Current category entity
     */
    category: ComputedRef<Schemas["Category"]>;
};
/**
 * Composable to get the category from current CMS context
 *
 * @category Product
 * @public
 */
declare function useCategory(category?: Ref<Schemas["Category"]>): UseCategoryReturn;

type UseCategorySearchReturn = {
    /**
     * Search for category by ID
     * Accepts optional query params and associations
     */
    search(categoryId: string, options?: {
        withCmsAssociations?: boolean;
        query?: Schemas["Criteria"];
    }): Promise<Schemas["Category"]>;
    /**
     * Search based on the query
     */
    advancedSearch(options: {
        withCmsAssociations?: boolean;
        query: Schemas["Criteria"];
    }): Promise<Schemas["Category"][]>;
};
/**
 * Composable for category search.
 * @public
 * @category Navigation & Routing
 */
declare function useCategorySearch(): UseCategorySearchReturn;

type UseCheckoutReturn = {
    /**
     * Fetches all available shipping methods
     */
    getShippingMethods(options?: {
        forceReload: boolean;
    }): Promise<ComputedRef<Schemas["ShippingMethod"][]>>;
    /**
     * List of available shipping methods
     */
    shippingMethods: ComputedRef<Schemas["ShippingMethod"][]>;
    /**
     * Fetches all available payment methods
     */
    getPaymentMethods(options?: {
        forceReload: boolean;
    }): Promise<ComputedRef<Schemas["PaymentMethod"][]>>;
    /**
     * List of available payment methods
     */
    paymentMethods: ComputedRef<Schemas["PaymentMethod"][]>;
    /**
     * Creates order based on the current cart
     */
    createOrder(params?: operations["createOrder post /checkout/order"]["body"]): Promise<Schemas["Order"]>;
    /**
     * Shipping address for the current session
     */
    shippingAddress: ComputedRef<Schemas["CustomerAddress"] | undefined>;
    /**
     * Billing address for the current session
     */
    billingAddress: ComputedRef<Schemas["CustomerAddress"] | undefined>;
    /**
     * Selected shipping method for the current session
     * Sugar for {@link useSessionContext.selectedShippingMethod}
     */
    selectedShippingMethod: ComputedRef<Schemas["ShippingMethod"] | null>;
    /**
     * Sets shipping method for the current session
     * Sugar for {@link useSessionContext.setShippingMethod}
     */
    setShippingMethod(shippingMethod: {
        id: string;
    }): Promise<void>;
    /**
     * Selected payment method for the current session
     * Sugar for {@link useSessionContext.selectedPaymentMethod}
     */
    selectedPaymentMethod: ComputedRef<Schemas["PaymentMethod"] | null>;
    /**
     * Sets payment method for the current session
     * Sugar for {@link useSessionContext.setPaymentMethod}
     */
    setPaymentMethod(paymentMethod: {
        id: string;
    }): Promise<void>;
};
/**
 * Composable to manage checkout process
 * @public
 * @category Cart & Checkout
 */
declare function useCheckout(): UseCheckoutReturn;

type ArrayElement$1<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[] ? ElementType : never;
type UseCmsBlockReturn = {
    /**
     * Cms block content
     */
    block: Schemas["CmsBlock"];
    /**
     * Get slot content by slot name (identifier)
     * @example getSlotContent("main")
     */
    getSlotContent(slotName: string): ArrayElement$1<Schemas["CmsBlock"]["slots"]>;
};
/**
 * Composable to get cms block content
 * @public
 * @category CMS (Shopping Experiences)
 */
declare function useCmsBlock<BLOCK_TYPE extends Schemas["CmsBlock"]>(content: BLOCK_TYPE): UseCmsBlockReturn;

type UseCmsMetaReturn = {
    /**
     * Meta title for current page/entity
     */
    title: ComputedRef<string>;
    /**
     * Meta tags for current page/entity
     */
    meta: ComputedRef<{
        name: string;
        content: string;
    }[]>;
};
/**
 * TODO: remove parameter and use reactive state of cmsResponse provided by useCms composable
 * @category CMS (Shopping Experiences)
 */
declare function useCmsMeta(entity: Schemas["Category"] | Schemas["Product"] | Schemas["LandingPage"]): UseCmsMetaReturn;

type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[] ? ElementType : never;
type UseCmsSectionType = {
    /**
     * CMS section
     */
    section: Schemas["CmsSection"];
    /**
     * Position of the section
     */
    getPositionContent(position: ArrayElement<Schemas["CmsSection"]["blocks"]>["sectionPosition"]): Array<Schemas["CmsBlock"]>;
};
/**
 * Composable to get cms section content
 * @public
 * @category CMS (Shopping Experiences)
 */
declare function useCmsSection<SECTION_TYPE extends Schemas["CmsSection"]>(content: SECTION_TYPE): UseCmsSectionType;

/**
 * @category CMS (Shopping Experiences)
 * @returns
 */
declare function useCmsTranslations(): {};

/**
 * Context helper composable to provide and inject data.
 * It takes `injectionName` to inject the context. If no context is provided, it will create a new one and provide it.
 * If `context` is provided in params, it will create new context, use param as value and provide it.
 * If `replace` is provided, it will replace the existing context with the new value.
 *
 * @public
 * @category Context & Language
 */
declare function useContext<T>(injectionName: string, params?: {
    context?: Ref<T> | T;
    replace?: T;
}): Ref<T, T>;

type UseCountriesReturn = {
    mountedCallback(): Promise<void>;
    getCountries: ComputedRef<Schemas["Country"][]>;
    fetchCountries(): Promise<operations["readCountry post /country"]["response"]>;
    getStatesForCountry(countryId: string): Schemas["CountryState"][] | null;
};
/**
 * Composable to manage countries
 * @public
 * @category Context & Language
 */
declare function useCountries(): UseCountriesReturn;

type UseCustomerOrdersReturn = {
    /**
     * All placed orders belonging to the logged-in customer
     */
    orders: Ref<Schemas["Order"][]>;
    /**
     * Changes the current page of the orders list
     *
     * In order to change a page with additional parameters please use `loadOrders` method.
     */
    changeCurrentPage(pageNumber: number | string): Promise<void>;
    /**
     * Fetches the orders list and assigns the result to the `orders` property
     */
    loadOrders(parameters?: operations["readOrder post /order"]["body"]): Promise<void>;
    /**
     * Current page number
     */
    currentPage: ComputedRef<number>;
    /**
     * total pages
     */
    totalPages: ComputedRef<number>;
    /**
     * Limit of orders per page
     */
    limit: Ref<number>;
};
/**
 * Composable for fetching the orders list.
 * @public
 * @category Customer & Account
 */
declare function useCustomerOrders(): UseCustomerOrdersReturn;

type UseCustomerPasswordReturn = {
    /**
     * Change customer's current password
     */
    updatePassword(updatePasswordData: operations["changePassword post /account/change-password"]["body"]): Promise<operations["changePassword post /account/change-password"]["response"]>;
    /**
     * Reset customer's password
     */
    resetPassword(resetPasswordData: operations["sendRecoveryMail post /account/recovery-password"]["body"]): Promise<operations["sendRecoveryMail post /account/recovery-password"]["response"]>;
};
/**
 * Composable for customer password management.
 * @public
 * @category Customer & Account
 */
declare function useCustomerPassword(): UseCustomerPasswordReturn;

type UseDefaultOrderAssociationsReturn = Schemas["Criteria"] & {
    checkPromotion?: boolean;
};
/**
 * Returns default order associations. You can override this composable in your project.
 * @public
 * @category Order
 */
declare function useDefaultOrderAssociations(): UseDefaultOrderAssociationsReturn;

type UseInternationalizationReturn = {
    /**
     * StorefrontUrl is needed to specify language of emails
     *
     *  @returns {string} storefront URL
     */
    getStorefrontUrl(): string;
    /**
     * Get available languages from backend
     *
     * @returns {Promise<operations['readLanguages post /language']['body']>} list of languages
     */
    getAvailableLanguages(): Promise<operations["readLanguages post /language"]["response"]>;
    /**
     * Change current language
     *
     * @param {string} languageId
     * @returns {Promise<Schemas['ContextTokenResponse']>} context object
     */
    changeLanguage(languageId: string): Promise<operations["updateContext patch /context"]["response"]>;
    /**
     * Get language code from backend language id
     *
     * @param {string} languageId
     * @returns {string} language code
     */
    getLanguageCodeFromId(languageId: string): string;
    /**
     * Get backend language id from language code
     *
     * @param {string} languageCode
     * @returns {string} language
     */
    getLanguageIdFromCode(languageCode: string): string;
    /**
     * Replace to dev url if it is set
     *
     * @param {string} url
     * @returns {string} prefixed url
     */
    replaceToDevStorefront(url: string): string;
    /**
     * List of available languages
     */
    languages: Ref<Schemas["Language"][]>;
    /**
     * Currently used language
     */
    currentLanguage: Ref<string>;
    /**
     * Current prefix from the context
     */
    currentPrefix: Ref<string>;
    /**
     * Add prefix to the Url
     * @param {string | RouteObject} link
     */
    formatLink(link: string | RouteObject): string | RouteObject;
};
type RouteObject = {
    path: string;
    [key: string]: unknown;
};
/**
 * Composable for internationalization management.
 * @public
 * @category Context & Language
 */
declare function useInternationalization(pathResolver?: (path: string) => string): UseInternationalizationReturn;

type UseLandingSearchReturn = {
    /**
     * Search for landing page by ID
     * Accepts optional media associations
     */
    search(navigationId: string, options?: {
        withCmsAssociations?: boolean;
    }): Promise<Schemas["LandingPage"]>;
};
/**
 * Composable for landing page search.
 * @public
 * @category Navigation & Routing
 */
declare function useLandingSearch(): {
    search: (navigationId: string, options?: {
        withCmsAssociations?: boolean;
    }) => Promise<Schemas["LandingPage"]>;
};

type ListingType = "productSearchListing" | "categoryListing";
type ShortcutFilterParam<T extends keyof Schemas["ProductListingCriteria"] = keyof Schemas["ProductListingCriteria"]> = {
    code: T;
    value: Schemas["ProductListingCriteria"][T];
};
type UseListingReturn = {
    /**
     * Listing that is currently set
     * {@link ListingResult} object
     */
    getInitialListing: ComputedRef<Schemas["ProductListingResult"] | null>;
    /**
     * Sets the initial listing - available synchronously
     * @param {@link initialListing} - initial listing to set
     * @returns
     */
    setInitialListing(initialListing: Schemas["ProductListingResult"]): Promise<void>;
    /**
     * @deprecated - use `search` instead
     * Searches for the listing based on the criteria
     * @param criteria {@link Schemas['Criteria']}
     * @returns
     */
    initSearch(criteria: operations["searchPage post /search"]["body"]): Promise<Schemas["ProductListingResult"]>;
    /**
     * Searches for the listing based on the criteria
     * @param criteria
     * @returns
     */
    search(criteria: operations["readProductListing post /product-listing/{categoryId}"]["body"] | operations["searchPage post /search"]["body"]): Promise<void>;
    /**
     * Loads more (next page) elements to the listing
     */
    loadMore(criteria?: operations["searchPage post /search"]["body"]): Promise<void>;
    /**
     * Listing that is currently set
     */
    getCurrentListing: ComputedRef<Schemas["ProductListingResult"] | null>;
    /**
     * Listing elements ({@link Product}) that are currently set
     */
    getElements: ComputedRef<Schemas["ProductListingResult"]["elements"]>;
    /**
     * Available sorting orders
     */
    getSortingOrders: ComputedRef<Schemas["ProductSorting"][] | {
        key: string;
        label: string;
    }[] | undefined>;
    /**
     * Current sorting order
     */
    getCurrentSortingOrder: ComputedRef<string | undefined>;
    /**
     * Changes the current sorting order
     * @param order - i.e. "name-asc"
     * @returns
     */
    changeCurrentSortingOrder(order: string, query?: operations["searchPage post /search"]["body"]): Promise<void>;
    /**
     * Current page number
     */
    getCurrentPage: ComputedRef<number>;
    /**
     * Changes the current page number
     * @param pageNumber - page number to change to
     * @returns
     */
    changeCurrentPage(page: number, query?: operations["searchPage post /search"]["body"]): Promise<void>;
    /**
     * Total number of elements found for the current search criteria
     */
    getTotal: ComputedRef<number>;
    /**
     * Total number of pages found for the current search criteria
     */
    getTotalPagesCount: ComputedRef<number>;
    /**
     * Number of elements per page
     */
    getLimit: ComputedRef<number>;
    /**
     * Initial filters
     */
    getInitialFilters: ComputedRef<ReturnType<typeof getListingFilters>>;
    /**
     * All available filters
     */
    getAvailableFilters: ComputedRef<ReturnType<typeof getListingFilters>>;
    /**
     * Filters that are currently set
     */
    getCurrentFilters: ComputedRef<Schemas["ProductListingResult"]["currentFilters"]>;
    /**
     * Sets the filters to be applied for the listing
     * @param filters
     * @returns
     */
    setCurrentFilters(filters: ShortcutFilterParam[]): Promise<void>;
    /**
     * Indicates if the listing is being fetched
     */
    loading: ComputedRef<boolean>;
    /**
     * Indicates if the listing is being fetched via `loadMore` method
     */
    loadingMore: ComputedRef<boolean>;
    /**
     * Resets the filters - clears the current filters
     */
    resetFilters(): Promise<void>;
    /**
     * Change selected filters to the query object
     */
    filtersToQuery(filters: Schemas["ProductListingCriteria"]): Record<string, unknown>;
};
/**
 * @public
 * @category Product
 */
declare function useListing(params?: {
    listingType: ListingType;
    categoryId?: string;
    defaultSearchCriteria?: operations["searchPage post /search"]["body"];
}): UseListingReturn;
declare const createCategoryListingContext: () => UseListingReturn;
/**
 * Temporary workaround over `useListing` to support shared data. This composable API will change in the future.
 *
 * You need to call `createCategoryListingContext` before this composable.
 */
declare const useCategoryListing: () => UseListingReturn;
/**
 * Temporary workaround over `useListing` to support shared data. This composable API will change in the future.
 */
declare const useProductSearchListing: () => UseListingReturn;
/**
 * Factory to create your own listing.
 *
 * By default you can use useListing composable, which provides you predefined listings for category(cms) listing and product search listing.
 * Using factory you can provide our own compatible search method and use it for example for creating listing of orders in my account.
 *
 * @public
 */
declare function createListingComposable({ searchMethod, searchDefaults, listingKey, }: {
    searchMethod(searchParams: operations["readProductListing post /product-listing/{categoryId}"]["body"] | operations["searchPage post /search"]["body"]): Promise<Schemas["ProductListingResult"]>;
    searchDefaults: operations["searchPage post /search"]["body"];
    listingKey: string;
}): UseListingReturn;

type UseLocalWishlistReturn = {
    /**
     * Get wishlist products from localstorage
     */
    getWishlistProducts(): void;
    /**
     * Add product to wishlist by its id
     */
    addToWishlist(id: string): Promise<void>;
    /**
     * Remove product from wishlist by its id
     */
    removeFromWishlist(id: string): Promise<void>;
    /**
     * Remove all products from wishlist
     */
    clearWishlist(): Promise<void>;
    /**
     * List of wishlist items
     */
    items: ComputedRef<string[]>;
    /**
     * Count of wishlist items
     */
    count: ComputedRef<number>;
};
/**
 * Composable for wishlist management.
 * @public
 * @category Wishlist
 */
declare function useLocalWishlist(): UseLocalWishlistReturn;

/**
 *
 * Provides state for navigation trees depending on navigation type.
 */
type UseNavigationReturn = {
    /**
     * List of navigation elements
     */
    navigationElements: ComputedRef<Schemas["NavigationRouteResponse"] | null>;
    /**
     * Load navigation elements
     */
    loadNavigationElements(params: operations["readNavigation post /navigation/{activeId}/{rootId}"]["body"]): Promise<Schemas["NavigationRouteResponse"]>;
};
/**
 * Composable for navigation.
 * Provides state for navigation trees depending on navigation type.
 *
 * @example
 * ```
 * // get main navigation
 * useNavigation()
 * // get footer navigation
 * useNavigation({ type: "footer-navigation" } )
 * ```
 * @public
 * @category Navigation & Routing
 */
declare function useNavigation(params?: {
    type?: Schemas["NavigationType"] | string;
}): UseNavigationReturn;

type UseNavigationContextReturn = {
    /**
     * SEO URL from the navigation context
     */
    navigationContext: ComputedRef<Schemas["SeoUrl"] | null>;
    /**
     * Route name from the navigation context
     */
    routeName: ComputedRef<Schemas["SeoUrl"]["routeName"] | undefined>;
    /**
     * Foreign key (ID) for current navigation context
     */
    foreignKey: ComputedRef<string>;
};
/**
 * Composable to get navigation context from the URL.
 * @public
 * @category Navigation & Routing
 */
declare function useNavigationContext(context?: Ref<Schemas["SeoUrl"] | null>): UseNavigationContextReturn;

type UseNavigationSearchReturn = {
    /**
     * Get {@link SeoUrl} entity for given path
     * @example resolvePath("/my-category/my-product") or resolvePath("/") for home page
     */
    resolvePath(path: string): Promise<Schemas["SeoUrl"] | null>;
};
/**
 * Composable to get search for SeoUrl entity for given path.
 * @public
 * @category Navigation & Routing
 */
declare function useNavigationSearch(): UseNavigationSearchReturn;

type UseNewsletterReturn = {
    /**
     * Subscribes the user to the newsletter
     * @param params {@link operations['subscribeToNewsletter post /newsletter/subscribe']['body']}
     */
    newsletterSubscribe(params: Omit<operations["subscribeToNewsletter post /newsletter/subscribe"]["body"], "storefrontUrl">): Promise<void>;
    /**
     * Removes the email from the newsletter
     * @param email
     */
    newsletterUnsubscribe(email: string): Promise<void>;
    /**
     * Get newsletter status from the API call
     */
    getNewsletterStatus(): Promise<Schemas["AccountNewsletterRecipient"]>;
    /**
     * Indicates if the user is subscribed to the newsletter
     *
     * Returns `true` if the user is subscribed to the newsletter, `false` otherwise
     */
    isNewsletterSubscriber: ComputedRef<boolean>;
    /**
     * Newsletter status
     */
    newsletterStatus: Ref<Schemas["AccountNewsletterRecipient"]["status"]>;
    /**
     * Inform about newsletter confirmation
     */
    confirmationNeeded: ComputedRef<boolean>;
};
/**
 * Composable for newsletter subscription.
 * @public
 * @category Customer & Account
 */
declare function useNewsletter(): UseNewsletterReturn;

type NotificationType = "info" | "warning" | "success" | "danger";
/**
 * @private
 */
type Notification = {
    type: NotificationType;
    message: string;
    id: number;
};
/**
 * @private
 */
type NotificationOptions = {
    /**
     * @private
     */
    type?: NotificationType;
    timeout?: number;
    persistent?: boolean;
};
/**
 * @public
 */
type UseNotificationsReturn = {
    /**
     * List of active notifications
     */
    notifications: ComputedRef<Notification[]>;
    /**
     * Removes a specific notification by its ID
     */
    removeOne(id: number): void;
    /**
     * Resets the notification list - clear all notifications
     */
    removeAll(): void;
    /**
     * Push an info notification to the current list
     */
    pushInfo(message: string, options?: NotificationOptions): void;
    /**
     * Pushes a warning notification to the current list
     */
    pushWarning(message: string, options?: NotificationOptions): void;
    /**
     * Pushes an error notification to the current list
     */
    pushError(message: string, options?: NotificationOptions): void;
    /**
     * Pushes a success notification to the current list
     */
    pushSuccess(message: string, options?: NotificationOptions): void;
};
/**
 * Composable for managing notifications (flash messages) on frontend.
 * @public
 */
declare function useNotifications(): UseNotificationsReturn;

type UseOrderDetailsReturn = {
    /**
     * {@link Schemas['Order']} object
     */
    order: ComputedRef<Schemas["Order"] | undefined | null>;
    /**
     * Order status (e.g. 'Open', 'Cancelled')
     */
    status: ComputedRef<string | undefined>;
    /**
     * Order status technical name (e.g. 'open', 'cancelled')
     */
    statusTechnicalName: ComputedRef<string | undefined>;
    /**
     * Order total price
     */
    total: ComputedRef<number | undefined>;
    /**
     * Order subtotal price for all items
     */
    subtotal: ComputedRef<number | undefined>;
    /**
     * Order shipping costs
     */
    shippingCosts: ComputedRef<number | undefined>;
    /**
     * Shipping address
     */
    shippingAddress: ComputedRef<Schemas["OrderAddress"] | undefined>;
    /**
     * Billing address
     */
    billingAddress: ComputedRef<Schemas["OrderAddress"] | undefined>;
    /**
     * Basic personal details
     */
    personalDetails: ComputedRef<{
        email: string | undefined;
        firstName: string | undefined;
        lastName: string | undefined;
    }>;
    /**
     * Payment URL for external payment methods (e.g. async payment in external payment gateway)
     */
    paymentUrl: Ref<null | string>;
    /**
     * Returns current selected shipping method for the order. Last element in delivery array.
     */
    shippingMethod: ComputedRef<Schemas["ShippingMethod"] | undefined | null>;
    /**
     * Returns current selected payment method for the order. Last element in transactions array.
     */
    paymentMethod: ComputedRef<Schemas["PaymentMethod"] | undefined | null>;
    /**
     * Get order object including additional associations.
     * useDefaults describes what order object should look like.
     */
    loadOrderDetails(): Promise<Schemas["OrderRouteResponse"]>;
    /**
     * Handle payment for existing error.
     *
     * Pass custom success and error URLs (optionally).
     */
    handlePayment(successUrl?: string, errorUrl?: string, paymentDetails?: unknown): void;
    /**
     * Cancel an order.
     *
     * Action cannot be reverted.
     */
    cancel(): Promise<Schemas["StateMachineState"]>;
    /**
     * Changes the payment method for current cart.
     * @param paymentMethodId - ID of the payment method to be set
     * @returns
     */
    changePaymentMethod(paymentMethodId: string): Promise<Schemas["SuccessResponse"]>;
    /**
     * Get media content
     *
     * @param {string} downloadId
     * @returns {Blob}
     */
    getMediaFile: (downloadId: string) => Promise<Blob>;
    /**
     * Get order documents
     * @param {string} documentId
     * @param {string} deepLinkCode
     * @returns
     */
    getDocumentFile: (documentId: string, deepLinkCode: string) => Promise<Schemas["Document"]>;
    /**
     * Check if order has documents
     */
    hasDocuments: ComputedRef<boolean>;
    /**
     * Get order documents
     */
    documents: ComputedRef<Schemas["Document"][]>;
    /**
     * Fetches all available payment methods
     */
    getPaymentMethods(): Promise<Schemas["PaymentMethod"][]>;
    paymentChangeable: ComputedRef<boolean>;
};
/**
 * Composable for managing an existing order.
 * @public
 * @category Customer & Account
 */
declare function useOrderDetails(orderId: string, associations?: Schemas["Criteria"]["associations"]): UseOrderDetailsReturn;

type UseOrderPaymentReturn = {
    /**
     * If the payment can be done after the order is placed
     */
    isAsynchronous: ComputedRef<boolean | undefined>;
    /**
     * Active payment transaction
     */
    activeTransaction: ComputedRef<Schemas["OrderTransaction"] | undefined>;
    /**
     * Payment status
     */
    state: ComputedRef<Schemas["StateMachineState"] | null | undefined>;
    paymentUrl: Ref<null | string>;
    /**
     * Payment method set for the order
     */
    paymentMethod: ComputedRef<Schemas["PaymentMethod"] | undefined | null>;
    /**
     * Invokes the payment process for the order in the backend
     */
    handlePayment(
    /**
     * URL to redirect after successful payment
     */
    successUrl?: string, 
    /**
     * URL to redirect after failed payment
     */
    errorUrl?: string, 
    /**
     * additional payment details to provide
     */
    paymentDetails?: unknown): Promise<undefined | unknown>;
    /**
     * Change a payment method for the order
     */
    changePaymentMethod(paymentMethodId: string): Promise<Schemas["SuccessResponse"] | undefined>;
};
/**
 * Composable for managing an existing order.
 * @public
 * @category Customer & Account
 */
declare function useOrderPayment(order: ComputedRef<Schemas["Order"] | null | undefined>): UseOrderPaymentReturn;

type UsePriceReturn = {
    /**
     * Format price i.e. (2) -> 2.00 $
     */
    getFormattedPrice(value: number | string | undefined): string;
    /**
     * Update configuration
     */
    update(params: {
        localeCode: string | undefined;
        currencyCode: string;
    }): void;
    /**
     * Currency code
     */
    currencyCode: ComputedRef<string>;
};
/**
 * Composable for getting formatted price
 * Set the default currency code and locale in order to format a price correctly
 *
 * @public
 * @category Product
 */
declare function _usePrice(params?: {
    localeCode: string | undefined;
    currencyCode: string;
}): UsePriceReturn;
/**
 * @category Product
 */
declare const usePrice: typeof _usePrice;

type UseProductReturn = {
    /**
     * Returns product object
     * {@link Product} object
     */
    product: ComputedRef<Schemas["Product"]>;
    /**
     * {@link PropertyGroup} array that defines the product possible configurations
     */
    configurator: ComputedRef<Schemas["PropertyGroup"][]>;
    /**
     * Merges the current product with the new variant data
     * @param variant - {@link Product} object with the new variant data
     */
    changeVariant(variant?: Partial<Schemas["Product"]>): void;
};
/**
 * Composable for product management.
 * @public
 * @category Product
 */
declare function useProduct(product?: Ref<Schemas["Product"]> | Schemas["Product"], configurator?: Ref<Schemas["PropertyGroup"][]> | Schemas["PropertyGroup"][]): UseProductReturn;

type UseProductAssociationsReturn = {
    /**
     * Start loading resources. Search Parameters and HTTP method can be passed.
     *
     */
    loadAssociations(params: {
        method?: "post" | "get";
        searchParams: Schemas["Criteria"];
    }): Promise<void>;
    /**
     * If it's loading - indicator
     */
    isLoading: ComputedRef<boolean>;
    /**
     * Product associations, like CrossSelling[]
     */
    productAssociations: ComputedRef<Schemas["CrossSellingElementCollection"]>;
};
/**
 * Get product association entity.
 * @public
 * @category Product
 */
declare function useProductAssociations(product: ComputedRef<Schemas["Product"]>, options: {
    associationContext: "cross-selling" | "reviews";
}): UseProductAssociationsReturn;

type UseProductConfiguratorReturn = {
    /**
     * Handler for action when the selected option is changed
     */
    handleChange(attribute: string, option: string, onChangeHandled: () => void): Promise<void>;
    findVariantForSelectedOptions(options?: {
        [key: string]: string;
    }): Promise<Schemas["Product"] | undefined>;
    /**
     * Indicates if the options are being (re)loaded
     */
    isLoadingOptions: Ref<boolean>;
    /**
     * Object of currently selected options
     */
    getSelectedOptions: ComputedRef<{
        [key: string]: string;
    }>;
    /**
     * All assigned properties which the variant can be made of
     */
    getOptionGroups: ComputedRef<Schemas["PropertyGroup"][]>;
};
/**
 * Composable to change product variant.
 * @public
 * @category Product
 */
declare function useProductConfigurator(): UseProductConfiguratorReturn;

type UseProductPriceReturn = {
    /**
     * Whole calculated price object
     */
    price: ComputedRef<Schemas["CalculatedPrice"] | undefined>;
    /**
     * Calculated price value for one selling unit
     */
    totalPrice: ComputedRef<number | undefined>;
    /**
     * Current unit price value
     */
    unitPrice: ComputedRef<number | undefined>;
    /**
     * Can be used if isListPrice is set to true
     */
    referencePrice: ComputedRef<Schemas["CalculatedPrice"]["referencePrice"] | undefined>;
    /**
     * determines if `price` contains the minimum tier price
     */
    displayFrom: ComputedRef<boolean>;
    /**
     * cheapest price value for a variant if exists
     */
    displayFromVariants: ComputedRef<number | false | undefined>;
    /**
     * array of TierPrice object
     */
    tierPrices: ComputedRef<TierPrice[]>;
    /**
     * determines whether a discount price is set
     */
    isListPrice: ComputedRef<boolean>;
    /**
     * price for products with regulation price
     */
    regulationPrice: ComputedRef<number | undefined>;
};
/**
 * The purpose of the `useProductPrice` function is to abstract the logic to expose most useful helpers for price displaying.
 *
 * @public
 * @category Product
 */
declare function useProductPrice(product: Ref<Schemas["Product"] | undefined>): UseProductPriceReturn;

type UseProductReviewsReturn = {
    /**
     * All reviews added to the product
     */
    productReviews: ComputedRef<Schemas["ProductReview"][]>;
    /**
     * Adds a review to the product
     * @param data `title` - review title, `content` - review content, `points` - review points (range of 1-5)
     * @returns
     */
    addReview(data: {
        title: string;
        content: string;
        points: number;
    }): Promise<void>;
    /**
     * Fetches the reviews list and assigns the result to the `productReviews` property
     * @param parameters {@link Schemas["Criteria"]}
     * @returns
     */
    loadProductReviews(parameters?: Schemas["Criteria"]): Promise<operations["readProductReviews post /product/{productId}/reviews"]["response"]>;
};
/**
 * Composable for listing customer orders.
 * @public
 * @category Product
 */
declare function useProductReviews(product: Ref<Schemas["Product"]>): UseProductReviewsReturn;

type UseProductSearchReturnOptions = {
    withCmsAssociations?: boolean;
    criteria?: Partial<Schemas["Criteria"]>;
    associations?: Partial<Schemas["Association"]>;
};
type UseProductSearchReturn = {
    /**
     * Searches for a product by its id
     * @param productId
     * @param options - optional parameters accepts `withCmsAssociations` flag to fetch cms-related associations and criteria
     * @returns {Promise<Schemas['ProductDetailResponse']>}
     */
    search: (productId: string, options?: UseProductSearchReturnOptions) => Promise<Schemas["ProductDetailResponse"]>;
};
/**
 * Composable for product search.
 * @public
 * @category Navigation & Routing
 */
declare function useProductSearch(): UseProductSearchReturn;

type UseProductSearchSuggestReturn = {
    /**
     * Current search term
     */
    searchTerm: Ref<string>;
    /**
     * Indicates if the search is in progress
     */
    loading: ComputedRef<boolean>;
    /**
     * Performs the search
     * @param additionalCriteria - additional search criteria of type {@link ShopwareSearchParams}
     * @returns
     */
    search(additionalCriteria?: Partial<operations["searchPage post /search"]["body"]>): Promise<void>;
    /**
     * Loads more products for current search criteria
     */
    loadMore(criteria: operations["searchPage post /search"]["body"]): Promise<void>;
    /**
     * Returns the product list found by the search
     */
    getProducts: ComputedRef<Schemas["ProductListingResult"]["elements"]>;
    /**
     * Returns the total number of products found by the search
     */
    getTotal: ComputedRef<number>;
};
/**
 * Composable for product suggest search.
 * @public
 * @category Product
 */
declare function useProductSearchSuggest(): UseProductSearchSuggestReturn;

type UseProductWishlistReturn = {
    /**
     * Removes product from wishlist
     */
    removeFromWishlist(): Promise<void>;
    /**
     * Adds product to wishlist
     */
    addToWishlist(): Promise<void>;
    /**
     * Indicates whether a product is in wishlist
     */
    isInWishlist: Ref<boolean>;
};
/**
 * Manage wishlist for a single product.
 *
 * @public
 * @category Product
 */
declare function useProductWishlist(productId: string): UseProductWishlistReturn;

type UseSalutationsReturn = {
    /**
     * All available salutations
     */
    getSalutations: ComputedRef<Schemas["Salutation"][]>;
    /**
     * Fetches the salutations list and assigns the result to the `salutations` property
     */
    fetchSalutations(): Promise<operations["readSalutation post /salutation"]["response"]>;
};
/**
 * Composable for fetching the salutations list.
 * @public
 * @category Context & Language
 */
declare function useSalutations(): UseSalutationsReturn;

type UseSessionContextReturn = {
    /**
     * Patches the context in order to use new language
     */
    setLanguage(language: Partial<Schemas["Language"]>): Promise<void>;
    /**
     * Patches the context in order to use new countryId
     *
     * @param {string} countryId
     */
    setCountry(countryId: string): Promise<void>;
    /**
     * current context's language
     */
    sessionContext: ComputedRef<Schemas["SalesChannelContext"] | undefined>;
    /**
     * Fetches the session context and assigns the result to the `sessionContext` property
     */
    refreshSessionContext(): Promise<void>;
    /**
     * current context's language
     */
    selectedShippingMethod: ComputedRef<Schemas["ShippingMethod"] | null>;
    /**
     * Patches the context in order to use new shipping method
     */
    setShippingMethod(shippingMethod: Partial<Schemas["ShippingMethod"]>): Promise<void>;
    /**
     * current context's payment method
     */
    selectedPaymentMethod: ComputedRef<Schemas["PaymentMethod"] | null>;
    /**
     * Patches the context in order to use new payment method
     */
    setPaymentMethod(paymentMethod: {
        id: string;
    }): Promise<void>;
    /**
     * current context's currency
     */
    currency: ComputedRef<Schemas["Currency"] | null>;
    /**
     * Patches the context in order to use new currency
     */
    setCurrency(currency: Partial<Schemas["Currency"]>): Promise<void>;
    /**
     * current context's shipping address
     */
    activeShippingAddress: ComputedRef<Schemas["CustomerAddress"] | null>;
    /**
     * Patches the context in order to use new shipping address
     */
    setActiveShippingAddress(address: Partial<Schemas["CustomerAddress"]>): Promise<void>;
    /**
     * current context's billing address
     */
    activeBillingAddress: ComputedRef<Schemas["CustomerAddress"] | null>;
    /**
     * current context's tax state
     */
    taxState: ComputedRef<string | undefined>;
    /**
     * Patches the context in order to use new billing address
     */
    setActiveBillingAddress(address: Partial<Schemas["CustomerAddress"]>): Promise<void>;
    /**
     * Patches the context with new context
     */
    setContext(context: Schemas["SalesChannelContext"]): void;
    /**
     * current context's country id
     */
    countryId: ComputedRef<string | undefined>;
    /**
     * current sales channel country id
     */
    salesChannelCountryId: ComputedRef<string | undefined>;
    /**
     * current language id
     */
    languageId: ComputedRef<string | undefined>;
    /**
     * current language id chain
     */
    languageIdChain: ComputedRef<string>;
    /**
     * current context's customer object
     */
    userFromContext: ComputedRef<Schemas["Customer"] | undefined>;
};
/**
 * Composable for session management.
 * SessionContext contain all related data like user, currency, country, shippingMethod, paymentMethod etc.
 * @public
 * @category Context & Language
 */
declare function useSessionContext(newContext?: Schemas["SalesChannelContext"]): UseSessionContextReturn;

type ShopwareContext = {
    devStorefrontUrl: string | null;
    /**
     * Shopware API client
     */
    apiClient: ApiClient;
};
/**
 * @public
 * @category Context & Language
 */
declare function useShopwareContext(): ShopwareContext;

type UseSyncWishlistReturn = {
    /**
     * Get products from wishlist
     */
    getWishlistProducts(defaultSearchCriteria?: Schemas["Criteria"]): Promise<void>;
    /**
     * Merge products with wishlist already existing in API wishlist
     */
    mergeWishlistProducts(itemsToMerge: string[]): void;
    /**
     * Add product to wishlist
     */
    addToWishlistSync(id: string): void;
    /**
     * Remove product from wishlist
     */
    removeFromWishlistSync(id: string): void;
    /**
     * Wishlist items (Product IDs)
     */
    items: ComputedRef<string[]>;
    /**
     * Wishlist items count
     */
    count: ComputedRef<number>;
    /**
     * Current page number
     */
    currentPage: ComputedRef<number>;
};
/**
 * Composable to manage wishlist via API
 * @public
 * @category Wishlist
 */
declare function useSyncWishlist(): UseSyncWishlistReturn;

declare function useUrlResolver(): {
    resolveUrl: (url: string) => string;
    getUrlPrefix: () => string;
};

type UseUserReturn = {
    /**
     * Logs-in user with given credentials
     * @param params - username and password
     *
     * @see https://github.com/shopware/frontends/issues/112 if login fails due to missing context token
     */
    login(params: {
        username: string;
        password: string;
    }): Promise<void>;
    /**
     * Registers the user for given credentials
     * @param params {@link CustomerRegistrationParams}
     * @returns {@link Customer} object on success
     */
    register(params: Omit<operations["register post /account/register"]["body"], "storefrontUrl">): Promise<Schemas["Customer"]>;
    /**
     * Whole {@link Customer} object
     */
    user: ComputedRef<Schemas["Customer"] | undefined>;
    /**
     * Indicates if the user is logged in
     */
    isLoggedIn: ComputedRef<boolean>;
    /**
     * Indicates if the user is logged in as a customer (not a guest)
     */
    isCustomerSession: ComputedRef<boolean>;
    /**
     * Indicates if the user is logged in as a guest
     */
    isGuestSession: ComputedRef<boolean>;
    /**
     * {@link Country} of the user
     */
    country: Ref<Schemas["Country"] | null>;
    /**
     * {@link Salutation} of the user
     */
    salutation: Ref<Schemas["Salutation"] | null>;
    /**
     * Default billing address id
     */
    defaultBillingAddressId: ComputedRef<string | null>;
    /**
     * Default shipping address id
     */
    defaultShippingAddressId: ComputedRef<string | null>;
    /**
     * Fetches the user data from the API
     */
    refreshUser(params?: Schemas["Criteria"]): Promise<Schemas["Customer"]>;
    /**
     * Logs out the user
     */
    logout(): Promise<operations["logoutCustomer post /account/logout"]["response"]>;
    /**
     * Loads the {@link Country} of the user
     */
    loadCountry(countryId: string): Promise<operations["readCountry post /country"]["response"]>;
    /**
     * Loads the {@link Salutation} for given id
     */
    loadSalutation(salutationId: string): Promise<operations["readSalutation post /salutation"]["response"]>;
    /**
     * Updates the user profile data
     * @param personals {@link RequestParameters<'changeProfile'>}
     * @returns
     */
    updatePersonalInfo(personals: operations["changeProfile post /account/change-profile"]["body"]): Promise<void>;
    /**
     * Updates the user email
     * @param updateEmailData - {@link RequestParameters<'changeEmail'>}
     * @returns
     */
    updateEmail(updateEmailData: operations["changeEmail post /account/change-email"]["body"]): Promise<void>;
    /**
     * Sets the default payment method for given id
     * @param paymentMethodId
     * @returns
     */
    setDefaultPaymentMethod(paymentMethodId: string): Promise<void>;
    /**
     * Default payment method for the user
     */
    userDefaultPaymentMethod: ComputedRef<Schemas["PaymentMethod"]["translated"] | null>;
    /**
     * Default billing address for the user
     */
    userDefaultBillingAddress: ComputedRef<Schemas["CustomerAddress"] | null>;
    /**
     * Default shipping address for the user
     */
    userDefaultShippingAddress: ComputedRef<Schemas["CustomerAddress"] | null>;
};
/**
 * Composable for user management.
 * @public
 * @category Customer & Account
 */
declare function useUser(): UseUserReturn;

type UseWishlistReturn = {
    /**
     * Merge products with wishlist between async (API) and sync (localstorage) wishlists
     */
    mergeWishlistProducts(): void;
    /**
     * Get products list added to wishlist
     */
    getWishlistProducts(query?: Schemas["Criteria"]): Promise<void>;
    /**
     * Clear wishlist
     */
    clearWishlist(): void;
    /**
     * Wishlist items (Product IDs)
     */
    items: ComputedRef<string[]>;
    /**
     * Current page number
     */
    currentPage: ComputedRef<number>;
    /**
     * total pages count
     */
    totalPagesCount: ComputedRef<number>;
    /**
     * total wishlist items count
     */
    count: ComputedRef<number>;
    /**
     * Indicates if the wishlist can be synced
     */
    canSyncWishlist: ComputedRef<boolean>;
};
/**
 * Composable to manage wishlist
 * @public
 * @category Wishlist
 */
declare function useWishlist(): UseWishlistReturn;

type UseB2bQuoteManagement = {
    getQuoteList: () => Promise<Schemas["Quote"][]>;
    getQuote: (quoteId: string) => Promise<Schemas["Quote"]>;
    declineQuote: (quoteId: string, comment: string) => Promise<void>;
    requestChangeQuote: (quoteId: string, comment: string) => Promise<void>;
    requestQuote: (comment: string) => Promise<Schemas["Quote"]>;
    createOrderFromQuote: (quoteId: string, comment: string) => Promise<Schemas["Order"]>;
    changeShippingMethod: (quoteId: string, shippingMethodId: string) => Promise<void>;
    changePaymentMethod: (quoteId: string, paymentMethodId: string) => Promise<void>;
};
type ChangePaymentShippingMethodParams = {
    quoteId: string;
    paymentMethodId?: string;
    shippingMethodId?: string;
};
/**
 * Composable to manage quotes in the B2BQuote module.
 *
 * With this composable you can:
 * - Get list of quotes
 * - Get quote details
 * - Decline quote
 * - Request change of the quote
 * - Change shipping method
 * - Change payment method
 * - Create order from quote
 * - Request quote
 *
 * @category B2B
 * @returns {UseB2bQuoteManagement}
 */
declare function useB2bQuoteManagement(): UseB2bQuoteManagement;

type useCartNotificationReturn = {
    codeErrorsNotification(): void;
    getErrorsCodes(): Schemas["CartError"][];
};
/**
 * UI composable
 *
 * @category Cart & Checkout
 * @returns
 */
declare function useCartNotification(): useCartNotificationReturn;

type UseCartErrorParamsResolver = {
    resolveCartError: (errorObject: ErrorObjectParam) => {
        params: {
            [key: string]: string | number | null | undefined;
        } | null;
        messageKey: string;
    };
};
type ErrorObjectParam = {
    messageKey: string;
    key: string;
    message?: string;
    code?: number;
    level?: number;
};
/**
 * @category Cart & Checkout
 *
 * @returns
 */
declare function useCartErrorParamsResolver(): UseCartErrorParamsResolver;

declare function resolveCmsComponent(content: Schemas["CmsSection"] | Schemas["CmsBlock"] | Schemas["CmsSlot"]): {
    componentName: string;
    componentNameToResolve: never;
    isResolved: boolean;
    resolvedComponent: vue.ConcreteComponent<{}, any, any, vue.ComputedOptions, vue.MethodOptions, {}, any> | undefined;
    resolved?: undefined;
    error?: undefined;
} | {
    componentName: string;
    componentNameToResolve: never;
    resolvedComponent: undefined;
    resolved: boolean;
    isResolved: boolean;
    error: string;
};
declare function getDefaultApiParams(): {
    [composableName: string]: unknown;
};

export { type BoxLayout, type Breadcrumb, type ChangePaymentShippingMethodParams, type CmsBlockCategoryNavigation, type CmsBlockCenterText, type CmsBlockCrossSelling, type CmsBlockForm, type CmsBlockGalleryBuybox, type CmsBlockImage, type CmsBlockImageBubbleRow, type CmsBlockImageCover, type CmsBlockImageFourColumn, type CmsBlockImageGallery, type CmsBlockImageHighlightRow, type CmsBlockImageSimpleGrid, type CmsBlockImageSlider, type CmsBlockImageText, type CmsBlockImageTextBubble, type CmsBlockImageTextCover, type CmsBlockImageTextGallery, type CmsBlockImageTextRow, type CmsBlockImageThreeColumn, type CmsBlockImageThreeCover, type CmsBlockImageTwoColumn, type CmsBlockProductDescriptionReviews, type CmsBlockProductHeading, type CmsBlockProductListing, type CmsBlockProductSlider, type CmsBlockProductThreeColumn, type CmsBlockSidebarFilter, type CmsBlockText, type CmsBlockTextHero, type CmsBlockTextOnImage, type CmsBlockTextTeaser, type CmsBlockTextTeaserSection, type CmsBlockTextThreeColumn, type CmsBlockTextTwoColumn, type CmsBlockVimeoVideo, type CmsBlockYoutubeVideo, type CmsElementBuyBox, type CmsElementCategoryNavigation, type CmsElementCrossSelling, type CmsElementForm, type CmsElementImage, type CmsElementImageGallery, type CmsElementImageSlider, type CmsElementManufacturerLogo, type CmsElementProductBox, type CmsElementProductDescriptionReviews, type CmsElementProductListing, type CmsElementProductName, type CmsElementProductSlider, type CmsElementSidebarFilter, type CmsElementText, type CmsElementVimeoVideo, type CmsElementYoutubeVideo, type CmsSectionBlock, type CmsSectionDefault, type CmsSectionSidebar, type DisplayMode, type ElementConfig, type ErrorObjectParam, type ImageContainerAttrs, type ListingType, type Notification, type NotificationOptions, type Position, type RouteObject, type ShopwareContext, type ShortcutFilterParam, type SliderElementConfig, type SourceType, type UseAddToCartReturn, type UseAddressReturn, type UseBreadcrumbsReturn, type UseCartErrorParamsResolver, type UseCartItemReturn, type UseCartReturn, type UseCategoryReturn, type UseCategorySearchReturn, type UseCheckoutReturn, type UseCmsBlockReturn, type UseCmsElementImage, type UseCmsMetaReturn, type UseCountriesReturn, type UseCustomerOrdersReturn, type UseCustomerPasswordReturn, type UseDefaultOrderAssociationsReturn, type UseInternationalizationReturn, type UseLandingSearchReturn, type UseListingReturn, type UseLocalWishlistReturn, type UseNavigationContextReturn, type UseNavigationReturn, type UseNavigationSearchReturn, type UseNewsletterReturn, type UseNotificationsReturn, type UseOrderDetailsReturn, type UseOrderPaymentReturn, type UsePriceReturn, type UseProductAssociationsReturn, type UseProductConfiguratorReturn, type UseProductPriceReturn, type UseProductReturn, type UseProductReviewsReturn, type UseProductSearchReturn, type UseProductSearchSuggestReturn, type UseProductWishlistReturn, type UseSalutationsReturn, type UseSessionContextReturn, type UseSyncWishlistReturn, type UseUserReturn, type UseWishlistReturn, type VerticalAlign, createCategoryListingContext, createListingComposable, createShopwareContext, getDefaultApiParams, resolveCmsComponent, useAddToCart, useAddress, useB2bQuoteManagement, useBreadcrumbs, useCart, useCartErrorParamsResolver, useCartFunction, useCartItem, useCartNotification, type useCartNotificationReturn, useCategory, useCategoryListing, useCategorySearch, useCheckout, useCmsBlock, useCmsElementConfig, useCmsElementImage, useCmsMeta, useCmsSection, useCmsTranslations, useContext, useCountries, useCustomerOrders, useCustomerPassword, useDefaultOrderAssociations, useInternationalization, useLandingSearch, useListing, useLocalWishlist, useNavigation, useNavigationContext, useNavigationSearch, useNewsletter, useNotifications, useOrderDetails, useOrderPayment, usePrice, useProduct, useProductAssociations, useProductConfigurator, useProductPrice, useProductReviews, useProductSearch, useProductSearchListing, useProductSearchSuggest, useProductWishlist, useSalutations, useSessionContext, useShopwareContext, useSyncWishlist, useUrlResolver, useUser, useWishlist };