@plentymarkets/shop-api 0.88.0

package/server/index.js

@@ -0,0 +1,2579 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var axios = require('axios');
+var middleware = require('@vue-storefront/middleware');
+var consola = require('consola');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
+var consola__default = /*#__PURE__*/_interopDefaultLegacy(consola);
+
+/**
+ * Method getProduct - Used to get product instance.
+ *
+ * @remarks
+ * calls /rest/storefront/items/${ params.id }
+ * if used with query ?withVariationAttributeMap=true it returns the product with mapped variations.
+ *
+ * @param params
+ * ProductParams
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * let params = {
+ *  id: productId,
+ * };
+ * const { data, error } = await useAsyncData(() => useSdk().plentysystems.getProduct(params));
+ * ```
+ */
+const getProduct = async (context, params) => {
+    const url = new URL(`/rest/storefront/items/${params.id}`, context.config.api.url);
+    url.searchParams.set('withVariationAttributeMap', 'true');
+    if (params.variationId) {
+        url.searchParams.set('variationId', params.variationId.toString());
+    }
+    const { data: response } = await context.client.get(url.href);
+    const data = response.data;
+    const mappedProduct = {
+        ...data.item.documents[0].data,
+        variationAttributeMap: {
+            variations: data.variations,
+            attributes: data.attributes,
+        },
+        seoSettings: data.seoSettings,
+    };
+    return { data: mappedProduct };
+};
+
+/**
+ * Method getCategoryTemplate - Used to get category template instance.
+ *
+ *
+ * @param params
+ * CategoryTemplateParams
+ *
+ * @returns
+ * CategoryTemplate
+ * @example
+ * ``` ts
+ * const { data } = await getCategoryTemplate(() => useSdk().plentysystems.getCategoryTemplate(1));
+ * ```
+ */
+const getCategoryTemplate = async (context, params) => {
+    const url = new URL(`rest/storefront/categories/template/${params.id}`, context.config.api.url);
+    const { data } = await context.client.get(url.href);
+    return { data: data };
+};
+
+/**
+ * getCategoryTree - method for retriving the list with the categories and subcategories ready to be consumed by tree navigation
+ *
+ * @remarks
+ * calls /rest/storefront/categories and returns a list of CategoryTreeItems, subcategories are set in children prop.
+ *
+ * @returns
+ *
+ * @example
+ * const { data, error } = await useAsyncData(() => sdk.plentysystems.getCategoryTree());
+ * ```
+ */
+const getCategoryTree = async (context) => {
+    const url = new URL('/rest/storefront/categories', context.config.api.url);
+    url.searchParams.set('level', '5');
+    const { data: response } = await context.client.get(url.href);
+    return { data: response.data };
+};
+
+/**
+ * Method getLegalTexts- Method that returns content consumable in legal text pages
+ *
+ * @remarks
+ * calls /rest/storefront/legal
+ * response should contain a prop htmlText which contains html formated information.
+ *
+ * @param params
+ * type: LegalTextsParams - type of legal texts
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data, error } = await useAsyncData(() => sdk.plentysystems.getLegalTexts(params));
+ * ```
+ */
+const getLegalTexts = async (context, params) => {
+    const url = new URL('/rest/storefront/legal', context.config.api.url);
+    url.searchParams.set('type', params.type);
+    const { data: response } = await context.client.get(url.href);
+    return { data: response.data };
+};
+
+/**
+ * Method doLogin - logs in as user with email and password
+ *
+ * @remarks
+ *
+ * Calls /rest/storefront/contact/login/
+ * This method should be used when a customer wants to log in with email and password.
+ *
+ * @param params
+ * email: string - customer's email
+ * password: string - customer's password
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * await useSdk().plentysystems.doLogin({ email: email, password: password});
+ * ```
+ */
+const doLogin = async (context, params) => {
+    const url = new URL('/rest/storefront/contact/login/', context.config.api.url);
+    const { data: response } = await context.client.post(url.href, {
+        email: params.email,
+        password: params.password,
+    });
+    return { data: response.data };
+};
+
+function getMappedCartItems(basketItems) {
+    return basketItems.map((basketItem) => {
+        return {
+            ...basketItem,
+            variation: basketItem.variation.data,
+        };
+    });
+}
+
+var AddressType;
+(function (AddressType) {
+    AddressType[AddressType["Billing"] = 1] = "Billing";
+    AddressType[AddressType["Shipping"] = 2] = "Shipping";
+})(AddressType || (AddressType = {}));
+var AddressOptionType;
+(function (AddressOptionType) {
+    AddressOptionType[AddressOptionType["VATNumber"] = 1] = "VATNumber";
+    AddressOptionType[AddressOptionType["ExternalAddressID"] = 2] = "ExternalAddressID";
+    AddressOptionType[AddressOptionType["EntryCertificate"] = 3] = "EntryCertificate";
+    AddressOptionType[AddressOptionType["Telephone"] = 4] = "Telephone";
+    AddressOptionType[AddressOptionType["Email"] = 5] = "Email";
+    AddressOptionType[AddressOptionType["PostNumber"] = 6] = "PostNumber";
+    AddressOptionType[AddressOptionType["PersonalId"] = 7] = "PersonalId";
+    AddressOptionType[AddressOptionType["BBFC"] = 8] = "BBFC";
+    AddressOptionType[AddressOptionType["Birthday"] = 9] = "Birthday";
+    AddressOptionType[AddressOptionType["SessionID"] = 10] = "SessionID";
+    AddressOptionType[AddressOptionType["Title"] = 11] = "Title";
+    AddressOptionType[AddressOptionType["ContactPerson"] = 12] = "ContactPerson";
+    AddressOptionType[AddressOptionType["ExternalCustomerID"] = 13] = "ExternalCustomerID";
+})(AddressOptionType || (AddressOptionType = {}));
+
+class ApiError {
+    constructor(errorParams) {
+        this.key = '';
+        this.code = '';
+        this.message = '';
+        this.cause = null;
+        this.events = undefined;
+        this.key = errorParams.key;
+        this.code = errorParams.code;
+        this.message = errorParams.message;
+        this.cause = errorParams.cause;
+        this.events = errorParams.events;
+    }
+}
+
+const mapAddressForClient = (addressData) => {
+    const address = {
+        id: addressData.id,
+        firstName: addressData.name2,
+        lastName: addressData.name3,
+        streetName: addressData.address1,
+        apartment: addressData.address2,
+        city: addressData.town,
+        state: addressData.stateId?.toString(),
+        country: addressData.countryId?.toString(),
+        zipCode: addressData.postalCode,
+        phoneNumber: '',
+        email: '',
+        primary: Boolean(addressData?.pivot?.isPrimary || 0),
+        companyName: addressData.name1,
+        vatNumber: addressData.taxIdNumber,
+    };
+    addressData.options.forEach((option) => {
+        switch (option.typeId) {
+            case AddressOptionType.Telephone:
+                address.phoneNumber = option.value;
+                break;
+            case AddressOptionType.Email:
+                address.email = option.value;
+                break;
+        }
+    });
+    return address;
+};
+
+const logRequest = (request) => {
+    consola__default["default"].log('Request-url:', request.url);
+    consola__default["default"].log('Request-headers:', request.headers);
+    consola__default["default"].log('Request-data:', request.data);
+};
+const logResponse = (response) => {
+    consola__default["default"].log('Response-url:', response.config.url);
+    consola__default["default"].log('Response-headers:', response.headers);
+    consola__default["default"].log('Response-data:', response.data);
+};
+
+/**
+ * Method getSession - get client session based on cookie
+ *
+ * @remarks
+ * calls /rest/storefront/session/ and returns user session and cart
+ *
+ * @returns
+ * Promise<{data: SessionResult}>
+ *
+ * @example
+ * ``` ts
+ * const { data, error } = await useAsyncData(() => sdk.plentysystems.getSession());
+ * ```
+ */
+const getSession = async (context) => {
+    const url = new URL('/rest/storefront/session/', context.config.api.url);
+    const { data } = await context.client.get(url.href);
+    const cartItems = data.data.cartItems;
+    const cart = { ...data.data.cart, items: getMappedCartItems(cartItems) };
+    return {
+        data: {
+            user: data.data.customer ||
+                (data.data.guest ? { guestMail: data.data.guest } : null),
+            basket: cart,
+        },
+    };
+};
+
+/**
+ * Method getAddresses - Get billing or shipping addresses from the current session (guest or logged in).
+ *
+ * @remarks
+ * * Calls /rest/storefront/contact/addresses
+ * * This method is used to get all billing or shipping addresses
+ *
+ * @param { GetAddressesParams } params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getAddresses({typeId: AddressType.Billing});
+ * const { data } = await useSdk().plentysystems.getAddresses({typeId: AddressType.Shipping});
+ * ```
+ */
+const getAddresses = async (context, params) => {
+    const url = new URL('/rest/storefront/contact/addresses', context.config.api.url);
+    url.searchParams.set('addressTypeId', params.typeId.toString());
+    const { data } = await context.client.get(url.href);
+    const response = data.data;
+    const mappedResponse = response.map((addressData) => mapAddressForClient(addressData)) || [];
+    mappedResponse.sort((a, b) => b.primary > a.primary ? 1 : -1);
+    return { data: mappedResponse };
+};
+
+/**
+ * Method doSaveAddress - Create a new billing or shipping address to the current session (guest or logged in).
+ *
+ * @remarks
+ * * Calls /rest/storefront/contact/addresses/
+ * * This method is used to create a new billing or shipping address
+ *
+ * @param { DoSaveAddressParams } params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doSaveAddress({
+ *     typeId: AddressType.Billing,
+ *     addressData: {
+ *       country: '12',
+ *       firstName: 'John',
+ *       lastName: 'Doe',
+ *       streetName: 'Main Street',
+ *       apartment: '1',
+ *       city: 'New York',
+ *       state: null,
+ *       zipCode: '12345',
+ *       phoneNumber: null
+ *     }
+ * });
+ * ```
+ */
+const doSaveAddress = async (context, params) => {
+    const url = new URL('/rest/storefront/contact/addresses/', context.config.api.url);
+    url.searchParams.set('addressTypeId', params.typeId.toString());
+    url.searchParams.set('version', '2');
+    const payload = {
+        ...mapAddressForServer(params.addressData),
+    };
+    const { data } = await context.client.post(url.href, payload);
+    const response = data.data;
+    const mappedResponse = response.map((addressData) => mapAddressForClient(addressData)) || [];
+    mappedResponse.sort((a, b) => b.primary > a.primary ? 1 : -1);
+    return { data: mappedResponse };
+};
+function mapAddressForServer(address) {
+    return {
+        ...(address.id && { id: address.id }),
+        gender: '',
+        countryId: Number(address?.country ?? 0),
+        email: address.email,
+        name1: address.companyName,
+        name2: address.firstName,
+        name3: address.lastName,
+        vatNumber: address.vatNumber,
+        contactPerson: '',
+        address1: address.streetName,
+        address2: address.apartment,
+        postalCode: address.zipCode,
+        town: address.city,
+        telephone: address.phoneNumber,
+        stateId: address.state,
+        ...(address.primary && { isPrimary: true }),
+        ...(address.id && { pivot: { isPrimary: true } }),
+    };
+}
+
+/**
+ * Method setCheckoutAddress - sets a billing or shipping address as default.
+ *
+ * @remarks
+ * * Calls /rest/storefront/contact/addresses/${addressId}
+ * * This method is used to set a billing or shipping address as default
+ *
+ * @param { SetAddressDefaultParams } params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.setCheckoutAddress({
+ *     typeId: AddressType.Shipping,
+ *     addressId: 331
+ * });
+ * ```
+ */
+const setCheckoutAddress = async (context, params) => {
+    const url = new URL(`/rest/storefront/contact/addresses/${params.addressId}`, context.config.api.url);
+    url.searchParams.set('addressTypeId', params.typeId.toString());
+    const { data: response } = await context.client.put(url.href);
+    return { data: response.data };
+};
+
+/**
+ * Method deleteAddress - Delete address from the current session (guest or logged in).
+ *
+ * @remarks
+ * * Calls /rest/storefront/contact/addresses/${addressId}
+ * * This method is used to delete address
+ *
+ * @param { SetAddressDefaultParams } params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.deleteAddress({
+ *     typeId: AddressType.Billing,
+ *     addressId: 2564
+ * });
+ * ```
+ */
+const deleteAddress = async (context, params) => {
+    const url = new URL(`/rest/storefront/contact/addresses/${params.addressId}`, context.config.api.url);
+    url.searchParams.set('addressTypeId', params.typeId.toString());
+    url.searchParams.set('version', '2');
+    const { data } = await context.client.delete(url.href);
+    const response = data.data;
+    const mappedResponse = response.map((addressData) => mapAddressForClient(addressData)) || [];
+    mappedResponse.sort((a, b) => b.primary > a.primary ? 1 : -1);
+    return { data: mappedResponse };
+};
+
+/**
+ * Method getActiveShippingCountries -  Used to get all active shipping countries.
+ *
+ * @remarks
+ * * Calls /rest/storefront/countries.
+ * * Method should be used to get all active shipping countries.
+ *
+ * @returns
+ * A collection of ActiveShippingCountry items.
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getActiveShippingCountries();
+ * ```
+ */
+const getActiveShippingCountries = async (context) => {
+    const url = new URL('/rest/storefront/countries', context.config.api.url);
+    const { data: response } = await context.client.get(url.href);
+    return { data: response.data };
+};
+
+/**
+ * Method getAggregatedCountries - Used to get a combined list of active shipping countries and EU geo-regulated countries.
+ *
+ * @remarks
+ * * Calls /rest/storefront/countries/with-geo-regulated.
+ * * Method should be used to get a combined list of:
+ * - Active shipping countries
+ * - EU geo-regulated countries
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getAggregatedCountries();
+ * ```
+ */
+const getAggregatedCountries = async (context) => {
+    const url = new URL('/rest/storefront/countries/with-geo-regulated', context.config.api.url);
+    const { data: response } = await context.client.get(url.href);
+    return { data: response.data };
+};
+
+/**
+ * Method getReview - Get reviews from a product
+ *
+ * @remarks
+ * * Calls the /rest/storefront/feedbacks/feedback/helper/feedbacklist/${params.productId}/1
+ * * This method is used to get reviews from a product.
+ *
+ * @param { ReviewSearchParams } params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getReview({ itemId: 1100 });
+ * ```
+ */
+const getReview = async (context, params) => {
+    const page = params.page ? params.page : 1;
+    const feedbacksPerPage = params.feedbacksPerPage
+        ? params.feedbacksPerPage
+        : 10;
+    const url = new URL(`/rest/storefront/feedbacks/feedback/helper/feedbacklist/${params.itemId}/${page}`, context.config.api.url);
+    url.searchParams.set('feedbacksPerPage', feedbacksPerPage.toString());
+    const { data } = await context.client.get(url.href);
+    return { data: data };
+};
+
+/**
+ * Method getCart - returns the cart data from the current session.
+ *
+ * @remarks
+ * * Calls /rest/storefront/session/
+ * * This method is used to get the cart data from the current session.
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getCart();
+ * ```
+ */
+const getCart = async (context) => {
+    const url = new URL('/rest/storefront/session/', context.config.api.url);
+    const { data } = await context.client.get(url.href);
+    const cart = { ...data.data.cart, items: getMappedCartItems(data.data.cartItems) };
+    return { data: cart };
+};
+
+/**
+ * Method doAddCartItem - Adds a product with selected quantity to the cart.
+ *
+ * @remarks
+ * * Calls /rest/storefront/cart/items/
+ * * This method is used to add a product to the cart.
+ *
+ * @param { DoAddItemParams } params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doAddCartItem({
+ *     productId: 1100,
+ *     quantity: 1
+ * });
+ * ```
+ */
+const doAddCartItem = async (context, params) => {
+    const url = new URL('/rest/storefront/cart/items/', context.config.api.url);
+    const { data } = await context.client.post(url.href, {
+        variationId: params.productId,
+        quantity: params.quantity ?? 1,
+        basketItemOrderParams: params.basketItemOrderParams,
+    });
+    const basketItems = data.events?.AfterBasketChanged?.basketItems;
+    const basketItemWithVariation = data.events?.AfterBasketItemAdd?.basketItems?.[0] ||
+        data.events?.AfterBasketItemUpdate?.basketItems?.[0];
+    if (basketItems && basketItemWithVariation) {
+        const item = basketItems.find((basketItem) => basketItem.id === basketItemWithVariation.id);
+        if (item) {
+            item.variation = basketItemWithVariation.variation.data;
+        }
+    }
+    return {
+        data: {
+            ...data.events.AfterBasketChanged.basket,
+            items: data.events.AfterBasketChanged.basketItems,
+        },
+    };
+};
+
+/**
+ * Method deleteCartItem - deletes a cart item from the cart.
+ *
+ * @remarks
+ * * Calls /rest/storefront/cart/items/${params.cartItemId}/
+ * * This method deletes a cart item from the cart.
+ *
+ * @param { DeleteCartItemParams } params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.deleteCartItem({ cartItemId: 6682 });
+ * ```
+ */
+const deleteCartItem = async (context, params) => {
+    const url = new URL(`/rest/storefront/cart/items/${params.cartItemId}/`, context.config.api.url);
+    const { data } = await context.client.delete(url.href);
+    return {
+        data: {
+            ...data.events.AfterBasketChanged.basket,
+            items: data.events.AfterBasketChanged.basketItems,
+        },
+    };
+};
+
+/**
+ * Method setCartItemQuantity - Changes the quantity of a cart item
+ *
+ * @remarks
+ * * Calls /rest/storefront/cart/items/${params.cartItemId}
+ * * This method is used to change the quantity of a cart item
+ *
+ * @param {SetCartItemQuantityParams} params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.setCartItemQuantity({
+ *     cartItemId: 6683,
+ *     productId: 1100,
+ *     quantity: 5
+ * });
+ * ```
+ */
+const setCartItemQuantity = async (context, params) => {
+    const url = new URL(`/rest/storefront/cart/items/${params.cartItemId}`, context.config.api.url);
+    const { data } = await context.client.put(url.href, {
+        variationId: params.productId,
+        quantity: params.quantity ?? 1,
+        id: params.cartItemId,
+    });
+    if (data.events?.AfterBasketChanged) {
+        return {
+            data: {
+                ...data.events.AfterBasketChanged.basket,
+                items: data.events.AfterBasketChanged.basketItems,
+            },
+        };
+    }
+    if (data?.data?.placeholder?.stock) {
+        return {
+            data: {
+                availableStock: data.data.placeholder.stock,
+            },
+        };
+    }
+    throw new ApiError({
+        key: 'unknownError',
+        code: '503',
+        message: '',
+        cause: '',
+    });
+};
+
+/**
+ * Method deleteAllCartItems - deletes all items from the cart
+ *
+ * @remarks
+ * Calls /rest/storefront/cart/all_items
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.deleteAllCartItems();
+ * ```
+ */
+const deleteAllCartItems = async (context) => {
+    const url = new URL('/rest/storefront/cart/all_items', context.config.api.url);
+    const { data } = await context.client.delete(url.href);
+    return {
+        data: {
+            ...data?.events?.AfterBasketChanged?.basket,
+            items: data?.events?.AfterBasketChanged?.basketItems,
+        },
+    };
+};
+
+/**
+ * Method deleteCart - Deletes the complete cart.
+ *
+ * @remarks
+ * * Calls /rest/storefront/cart/
+ * * This method is used to delete the complete cart.
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.deleteCart();
+ * ```
+ */
+const deleteCart = async (context) => {
+    const url = new URL('/rest/storefront/cart/', context.config.api.url);
+    const { data: response } = await context.client.delete(url.href);
+    return { data: response.data };
+};
+
+/**
+ * Method doSubscribeNewsletter - to subscribe to the newsletter
+ *
+ * @remarks
+ * * Calls /rest/io/customer/newsletter
+ * * This method is used to subscribe to the newsletter
+ *
+ * @param {NewsletterParams} params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doSubscribeNewsletter({
+ *     email: 'test@plentymarkets.com',
+ *     firstName: 'John',
+ *     lastName: 'Doe',
+ *     emailFolder: 10
+ * });
+ * ```
+ */
+const doSubscribeNewsletter = async (context, params) => {
+    const url = new URL('/rest/storefront/newsletter', context.config.api.url);
+    const { data } = await context.client.post(url.href, params);
+    return { data: data };
+};
+
+/**
+ * Method deleteNewsletterSubscription - unsubscribes user from newsletter
+ *
+ * @remarks
+ * * Calls /rest/io/customer/newsletter/{params.email}
+ * * This method is used to unsubscribe user from newsletter
+ *
+ * @param { NewsletterParams } params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.deleteNewsletterSubscription({
+ *     email: 'test@plentymarkets.com'
+ * });
+ * ```
+ */
+const deleteNewsletterSubscription = async (context, params) => {
+    const url = new URL('/rest/storefront/newsletter/' + params.email, context.config.api.url);
+    const { data } = await context.client.delete(url.href);
+    return { data: data };
+};
+
+/**
+ * Method getSearch - returns a list of products based on the search term
+ *
+ * @remarks
+ * * Calls /rest/io/item/search/
+ * * This method is used to search for products based on the search term.
+ *
+ * @param { ItemSearchParams } params
+ * term: string - The search term
+ *
+ * @returns
+ * products: Product[] - The list of products
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getSearch({ term: 'Drone' });
+ * ```
+ */
+const getSearch = async (context, params) => {
+    const url = new URL('/rest/storefront/items', context.config.api.url);
+    if (!params.term && !params.tagName && !params.tagId) {
+        return { data: {} };
+        // @TODO error handling
+    }
+    url.searchParams.set('type', params.type || 'search');
+    if (params.term) {
+        url.searchParams.set('query', params.term);
+    }
+    if (params.tagName) {
+        url.searchParams.set('tagName', params.tagName);
+    }
+    if (params.tagId) {
+        url.searchParams.set('tagIds[]', params.tagId);
+    }
+    if (params.page) {
+        url.searchParams.set('page', params.page?.toString());
+    }
+    if (params.itemsPerPage) {
+        url.searchParams.set('items', params.itemsPerPage?.toString());
+    }
+    if (params.sort) {
+        url.searchParams.set('sorting', params.sort);
+    }
+    if (params.facets) {
+        url.searchParams.set('facets', params.facets);
+    }
+    if (params.priceMin) {
+        url.searchParams.set('priceMin', params.priceMin);
+    }
+    if (params.priceMax) {
+        url.searchParams.set('priceMax', params.priceMax);
+    }
+    const { data: response } = await context.client.get(url.href);
+    const data = response.data;
+    const products = data.itemList.documents.map((document) => document.data);
+    const itemSearchResult = {
+        products: products,
+        facets: data.facets,
+        languageUrls: data.urls,
+        pagination: {
+            perPageOptions: [20, 40, 100],
+            totals: data.itemList.total,
+        },
+    };
+    return { data: itemSearchResult };
+};
+
+/**
+ * Method getShippingProvider - Used to get the shipping provider.
+ *
+ * @remarks
+ * * Calls /rest/storefront/checkout/shipping/profiles/
+ * * Method should be used to get the shipping provider.
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ *  const { data } = await useSdk().plentysystems.getShippingProvider();
+ * ```
+ */
+const getShippingProvider = async (context) => {
+    const url = new URL('/rest/storefront/checkout/shipping/profiles/', context.config.api.url);
+    const { data: response } = await context.client.get(url.href);
+    return {
+        data: {
+            list: response.data,
+            selected: 0,
+        },
+    };
+};
+
+/**
+ * Method setShippingProvider - Used to set the shipping provider.
+ *
+ * @remarks
+ * * Calls /rest/storefront/checkout/shipping
+ * * Method should be used to set the shipping provider.
+ *
+ * @param { ShippingProviderParams } params
+ * shippingId: id of the shipping provider.
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.setShippingProvider({
+ *     shippingId: 1
+ * });
+ * ```
+ */
+const setShippingProvider = async (context, params) => {
+    const url = new URL('/rest/storefront/checkout/shipping', context.config.api.url);
+    const { data: response } = await context.client.put(url.href, {
+        shippingProfileId: params.shippingId,
+    });
+    return { data: response.data };
+};
+
+/**
+ * Method getOrders - Used to get the orders from the user.
+ *
+ * @remarks
+ * * Calls /rest/storefront/orders
+ * * This method is used to get the orders from the user.
+ *
+ * @param { UseUserOrderSearchParams } params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getOrders({
+ *     page: 0
+ * });
+ * ```
+ */
+const getOrders = async (context, params) => {
+    const url = new URL('/rest/storefront/orders', context.config.api.url);
+    url.searchParams.set('page', params?.page?.toString() ?? '1');
+    url.searchParams.set('items', '5');
+    const { data: response } = await context.client.get(url.href);
+    const data = response.data;
+    const shippingCostTypeId = 6;
+    data.data.entries.map((entry) => {
+        entry.order.orderItems = entry.order.orderItems.filter((item) => item.typeId !== shippingCostTypeId);
+    });
+    return { data: data };
+};
+
+/**
+ * Method getPaymentProviders - Used to get all available payment providers in the shop
+ *
+ * @remarks
+ * * Calls /rest/storefront/checkout/payment/providers/
+ * * This method is used to get all available payment providers in the shop.
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getPaymentProviders();
+ * ```
+ */
+const getPaymentProviders = async (context) => {
+    const url = new URL('/rest/storefront/checkout/payment/providers/', context.config.api.url);
+    const { data: response } = await context.client.get(url.href);
+    return { data: { list: response.data, selected: 0 } };
+};
+
+/**
+ * Method setPaymentProvider - Used to set the payment provider
+ *
+ * @remarks
+ * * Calls /rest/storefront/checkout/payment/
+ * * This method is used to set the payment provider for the checkout
+ *
+ * @param { SetPaymentProviderParams } params
+ * paymentId: number = id from the payment provider which should be set
+ *
+ * @returns
+ * selected: number = id of the selected payment provider
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.setPaymentProvider({paymentId: 6001});
+ * ```
+ */
+const setPaymentProvider = async (context, params) => {
+    const url = new URL('/rest/storefront/checkout/payment/', context.config.api.url);
+    const { data: response } = await context.client.put(url.href, {
+        paymentMethodId: params.paymentId,
+    });
+    return { data: response.data };
+};
+
+/**
+ * Method setMobilePaymentProviderList - Used to update the payment provider list
+ *
+ * @remarks
+ * * Calls /rest/storefront/checkout/payment/mobile-providers
+ * * This method is used to update the payment provider list for the checkout
+ *
+ * @param { SetMobilePaymentProviderListParams } params
+ * mobilePayments: string[] = array with the mobile payments id's ex. ['PAYPAL_APPLE_PAY', 'PAYPAL_GOOGLE_PAY']
+ *
+ * @returns
+ * selected: string[] = the list of payments
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.setMobilePaymentProviderList({mobilePayments: ['PAYPAL_APPLE_PAY', 'PAYPAL_GOOGLE_PAY']});
+ * ```
+ */
+const setMobilePaymentProviderList = async (context, params) => {
+    const url = new URL('/rest/storefront/checkout/payment/mobile-providers', context.config.api.url);
+    const { data } = await context.client.post(url.href, {
+        mobilePayments: params.mobilePayments,
+    });
+    return { data: data };
+};
+
+/**
+ * Method getReturns - Used to get return orders.
+ *
+ * @remarks
+ * * Calls /rest/io/customer/order/return
+ * * Method should be used to get the return orders.
+ *
+ * @param { UseUserOrderSearchParams } params
+ * page: page number
+ * items: number of items
+ *
+ * @returns
+ * A list of return orders.
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getReturns({
+ *     page: 1,
+ *     items: 5
+ * });
+ * ```
+ */
+const getReturns = async (context, params) => {
+    const url = new URL('/rest/storefront/returns', context.config.api.url);
+    url.searchParams.set('page', params?.page?.toString() ?? '1');
+    url.searchParams.set('items', params?.items?.toString() ?? '5');
+    const { data: response } = await context.client.get(url.href);
+    return { data: response.data };
+};
+
+/**
+ * Method getWhishlist - returns wish list for the current user.
+ *
+ * @remarks
+ * * Calls /rest/storefront/wishlist/
+ * * This method is used to get the wish list for the current user.
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getWishlist();
+ * ```
+ */
+const getWishlist = async (context) => {
+    const url = new URL('/rest/storefront/wishlist/', context.config.api.url);
+    const { data } = await context.client.get(url.href);
+    const items = data.data.documents.map((wishListItem) => wishListItem.data);
+    return { data: items };
+};
+
+/**
+ * Method doAddWishlistItem - Adds a product in the wishlist of the logged-in user.
+ *
+ * @remarks
+ * * Calls /rest/storefront/wishlist
+ * * This method is used to add a product to the wishlist of the logged-in user.
+ *
+ * @param { AddWishlistItemParams } params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doAddWishlistItem({
+ *     variationId: 1100,
+ * });
+ * ```
+ */
+const doAddWishlistItem = async (context, params) => {
+    const url = new URL('/rest/storefront/wishlist', context.config.api.url);
+    const { data } = await context.client.post(url.href, params);
+    return { data: data };
+};
+
+/**
+ * Method deleteWishlistItem - Deletes a product from the wishlist of the logged-in user.
+ *
+ * @remarks
+ * * Calls /rest/storefront/wishlist
+ * * This method is used to delete a product from the wishlist of the logged-in user.
+ *
+ * @param { DeleteWishlistItemParams } params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.deleteWishlistItem({
+ *     variationId: 1100,
+ * });
+ * ```
+ */
+const deleteWishlistItem = async (context, params) => {
+    const url = new URL(`/rest/storefront/wishlist/${params.variationId}`, context.config.api.url);
+    const { data } = await context.client.delete(url.href);
+    return { data: Boolean(data.data) };
+};
+
+/**
+ * @remarks
+ * * Calls /rest/storefront/offers
+ * * Method should be used to place an sales order from on offer.
+ *
+ * @returns Sales Order
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doAcceptOffer(params);
+ * ```
+ */
+const doAcceptOffer = async (context, params) => {
+    const url = new URL(`/rest/storefront/offers/${params.offerId}`, context.config.api.url);
+    if (params.accessKey) {
+        url.searchParams.set('accessKey', params.accessKey);
+    }
+    const { data: response } = await context.client.post(url.href);
+    return { data: response.data };
+};
+
+/**
+ * Method doCreatePayPalTransaction - creates a PayPal transaction from the current cart
+ *
+ * @remarks
+ * * Calls /rest/payment/payPal/smart_payment/create/{params.fundingSource}/
+ * * This method is used to create a PayPal transaction from the current cart.
+ *
+ * @param { PayPalCreateTransactionParams } params
+ * fundingSource: string - PayPal funding source
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doCreatePayPalTransaction({ fundingSource: 'paypal' });
+ * ```
+ */
+const doCreatePayPalTransaction = async (context, params) => {
+    const url = new URL('/rest/payment/payPal/smart_payment/create/' + params.fundingSource + '/', context.config.api.url);
+    const { data } = await context.client.post(url.href, {
+        // eslint-disable-next-line camelcase
+        bn_code_override: 'paypal_pwa'
+    });
+    return { data: data };
+};
+
+/**
+ * Method doApprovePayPalTransaction - checks the PayPal transaction and approves it.
+ *
+ * @remarks
+ * * Calls /rest/payment/payPal/smart_payment/{params.transactionId}/{params.payerId}/capture
+ * * This method is used to approve the PayPal transaction.
+ * * It will only change the status of the PayPal transaction if the user has approved the transaction on the PayPal side.
+ *
+ * @param { PayPalApproveTransactionParams } params
+ * transactionId: string - The transaction ID of the PayPal transaction.
+ * payerId: string - The PayPal payer ID of the PayPal transaction.
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doApprovePayPalTransaction({
+ *     transactionId: '7PE78730EB4411431',
+ *     payerId: 'A676SPCN9SBDQ'
+ * });
+ * ```
+ */
+const doApprovePayPalTransaction = async (context, params) => {
+    const url = new URL('/rest/payment/payPal/smart_payment/' +
+        params.transactionId +
+        '/' +
+        params.payerId +
+        '/capture', context.config.api.url);
+    const { data } = await context.client.post(url.href, {
+        // eslint-disable-next-line camelcase
+        bn_code_override: 'paypal_pwa'
+    });
+    return { data: data };
+};
+
+/**
+ * Method getExecutePayPalOrder - checks the PayPal payment status and changed the plenty order status accordingly
+ *
+ * @remarks
+ * * Calls rest/payment/payPal/{params.mode}/{params.plentyOrderId}/{params.paypalTransactionId}/{params.paypalMerchantId}/execute-payment
+ * * This method is used to check the PayPal payment status and changed the plenty order status accordingly
+ *
+ * @param { PayPalExecuteParams } params
+ * mode: string - mode of the payment (e.g. paypal)
+ * plentyOrderId: number - plenty order id
+ * paypalOrderId: string - PayPal transaction id
+ * paypalMerchantId: string - PayPal merchant id
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getExecutePayPalOrder({
+ *     plentyOrderId: 1606,
+ *     paypalTransactionId: '6GY88326V4505594A',
+ *     mode: 'paypal',
+ * });
+ * ```
+ */
+const getExecutePayPalOrder = async (context, params) => {
+    const url = new URL(`/rest/payment/payPal/${params.mode}/${params.plentyOrderId}/${params.paypalTransactionId}/execute-payment?bn_code_override=paypal_pwa`, context.config.api.url);
+    const { data } = await context.client.get(url.href);
+    return { data: data };
+};
+
+const removeTralingSlash = (str) => str.replace(/\/$/, '');
+
+/**
+ * Method getFacet - Used to get the category facets.
+ *
+ * @remarks
+ * * Calls /rest/storefront/items
+ * * Method should be used to get the category facets.
+ *
+ * @param { FacetSearchCriteria } params
+ * categoryId: id of the category.
+ * page: current page number.
+ * itemsPerPage: number of items per page.
+ * sort: type of sorting.
+ * facets: search facet
+ *
+ * @returns
+ * Category facets.
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getFacet({
+ *     categoryId: '17',
+ *     categorySlug: "armchair-stool",
+ *     page: 1,
+ *     itemsPerPage: 20,
+ *     sort: 'sorting.price.avg_asc',
+ *     facets: 'feedback-2'
+ * });
+ * ```
+ */
+const getFacet = async (context, params) => {
+    const allCategories = '0';
+    const categoryId = params.categoryId?.toString() || allCategories;
+    const url = new URL('/rest/storefront/items', context.config.api.url);
+    url.searchParams.set('categoryId', categoryId);
+    url.searchParams.set('type', 'category');
+    if (params.categoryUrlPath) {
+        params.categoryUrlPath = removeTralingSlash(params.categoryUrlPath);
+        url.searchParams.set('categoryUrlPath', params.categoryUrlPath);
+    }
+    if (params.page) {
+        url.searchParams.set('page', params.page?.toString());
+    }
+    if (params.itemsPerPage) {
+        url.searchParams.set('items', params.itemsPerPage?.toString());
+    }
+    if (params.sort) {
+        url.searchParams.set('sorting', params.sort);
+    }
+    if (params.facets) {
+        url.searchParams.set('facets', params.facets);
+    }
+    if (params.priceMin) {
+        url.searchParams.set('priceMin', params.priceMin);
+    }
+    if (params.priceMax) {
+        url.searchParams.set('priceMax', params.priceMax);
+    }
+    const { data: response } = await context.client.get(url.href);
+    const itemList = response.data.itemList;
+    if (!itemList) {
+        throw new Error('Category not found');
+    }
+    const products = itemList.documents.map((document) => document.data);
+    const facet = {
+        category: response.data.category,
+        products: products,
+        facets: response.data.facets,
+        languageUrls: response.data.urls,
+        pagination: {
+            perPageOptions: [20, 40, 100],
+            totals: itemList.total,
+        },
+    };
+    return { data: facet };
+};
+
+/**
+ * Method doLoginAsGuest - logs in as a guest.
+ *
+ * @remarks
+ * * Calls /rest/storefront/guest/
+ * * This method should be used when a customer wants to log in as a guest.
+ *
+ * @param { LoginAsGuestParams } params
+ * email: string - customer's email
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * await useSdk().plentysystems.doLoginAsGuest({email: 'guest.plenty@example.com'});
+ * ```
+ */
+const doLoginAsGuest = async (context, params) => {
+    const url = new URL('/rest/storefront/guest/', context.config.api.url);
+    await context.client.post(url.href, {
+        email: params.email,
+    });
+    return { data: null };
+};
+
+/**
+ * Method doRegisterUser - Creates a new user account.
+ *
+ * @remarks
+ * * Calls /rest/io/customer/
+ * * This method is used to register a new user account.
+ *
+ * @param { RegisterParams } params
+ * email: string - User email address.
+ * password: string - User password.
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doRegisterUser({
+ *     email: email,
+ *     password: 'Testuser1234'
+ * });
+ * ```
+ */
+const doRegisterUser = async (context, params) => {
+    const url = new URL('/rest/storefront/customer/', context.config.api.url);
+    const { data } = await context.client.post(url.href, {
+        'cf-turnstile-response': params['cf-turnstile-response'],
+        contact: {
+            password: params.password,
+            typeId: 1,
+            referrerId: 1,
+            options: {
+                typeId: {
+                    value: params.email,
+                    subTypeId: 4,
+                    priority: 0,
+                    typeId: 2,
+                },
+            },
+        },
+    });
+    return { data: data };
+};
+
+/**
+ * @remarks
+ * * Calls /rest/storefront/offers/reject
+ * * Method should be used to reject an offer.
+ *
+ * @returns string
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doRejectOffer(params);
+ * ```
+ */
+const doRejectOffer = async (context, params) => {
+    const url = new URL(`/rest/storefront/offers/reject/${params.offerId}`, context.config.api.url);
+    const payload = {};
+    if (params.accessKey) {
+        payload.accessKey = params.accessKey;
+    }
+    if (params.text) {
+        payload.text = params.text;
+    }
+    const { data: response } = await context.client.post(url.href, payload);
+    return { data: response.data };
+};
+
+/**
+ * Method doLogoutUser - Logs out the currently logged-in user/guest.
+ *
+ * @remarks
+ * * Calls /rest/storefront/contact/logout/
+ * * This method can be used to log out the currently logged-in user/guest.
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * await useSdk().plentysystems.doLogoutUser();
+ * ```
+ */
+const doLogoutUser = async (context) => {
+    const url = new URL('/rest/storefront/contact/logout/', context.config.api.url);
+    await context.client.post(url.href);
+    return { data: null };
+};
+
+/**
+ * Method doChangeUserPassword - changes user password
+ *
+ * @remarks
+ * * Calls /rest/io/customer/password/
+ * * This method is used to change the password of the logged-in user.
+ *
+ * @param { UserChangePasswordParams } params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doChangeUserPassword({
+ *     oldPassword: 'Testuser1234',
+ *     password: 'Testuser1234',
+ *     password2: 'Testuser1234'
+ * });
+ * ```
+ */
+const doChangeUserPassword = async (context, params) => {
+    const url = new URL('/rest/io/customer/password/', context.config.api.url);
+    const { data } = await context.client.post(url.href, params);
+    return { data: data };
+};
+
+/**
+ * Method getOffer - gets the Offer data.
+ *
+ * @remarks
+ * * Calls /rest/storefront/offers/${params.offerId}
+ * * Method uses OfferSearchParams
+ *
+ * @param { OfferSearchParams } params
+ * offerId: int;
+ * accessKey: string;
+ * postcode: string;
+ *
+ * @returns Offer | GetOfferError
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getOffer({
+ *   offerId: '138',
+ *   accessKey: '4L95RS31F',
+ *   postcode: '34131'
+ * });
+ * ```
+ */
+const getOffer = async (context, params) => {
+    const url = new URL(`/rest/storefront/offers/${params.offerId}`, context.config.api.url);
+    if (params.accessKey) {
+        url.searchParams.set('accessKey', params.accessKey);
+    }
+    if (params.postcode) {
+        url.searchParams.set('postcode', params.postcode);
+    }
+    const { data } = await context.client.get(url.href);
+    return { data: data };
+};
+
+/**
+ * Method getOrder - Used to get the order data.
+ *
+ * @remarks
+ * * Calls /rest/storefront/orders/${params.orderId}
+ * * Method should be used to get the order data.
+ *
+ * @param { OrderSearchParams } params
+ * orderId: string;
+ * accessKey: string;
+ * name: string;
+ * postcode: string;
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getOrder({
+ *   orderId: '1383',
+ *   name: 'Backpack Gaia',
+ *   accessKey: '1231234',
+ *   postcode: '012799'
+ * });
+ * ```
+ */
+const getOrder = async (context, params) => {
+    const url = new URL(`/rest/storefront/orders/${params.orderId}`, context.config.api.url);
+    if (params.name) {
+        url.searchParams.set('name', params.name);
+    }
+    if (params.accessKey) {
+        url.searchParams.set('accessKey', params.accessKey);
+    }
+    if (params.postcode) {
+        url.searchParams.set('postcode', params.postcode);
+    }
+    const { data } = await context.client.get(url.href);
+    const shippingCostTypeId = 6;
+    if (data?.order?.orderItems) {
+        data.order.orderItems = data.order.orderItems.filter((item) => item.typeId !== shippingCostTypeId);
+    }
+    return { data: data };
+};
+
+/**
+ * Method doAdditionalInformation - Used to post additional information to an order.
+ *
+ * @remarks
+ * * Calls /rest/storefront/order/additional_information
+ * * Method should be used to post the addition informantion of an order.
+ *
+ * @param { AdditionalInformationParams } params
+ * orderContactWish: string | null,
+ * orderCustomerSign: string | null,
+ * shippingPrivacyHintAccepted: boolean,
+ * templateType: string
+ *
+ * @returns
+ * An empty object.
+ *
+ * @example
+ * ``` ts
+ * await useSdk().plentysystems.doAdditionalInformation({
+ *   orderContactWish: null,
+ *   orderCustomerSign: null,
+ *   shippingPrivacyHintAccepted: true,
+ *   templateType: 'checkout'
+ * });
+ * ```
+ */
+const doAdditionalInformation = async (context, params) => {
+    const url = new URL('/rest/storefront/order/additional_information', context.config.api.url);
+    await context.client.post(url.href, params);
+    return { data: null };
+};
+
+/**
+ * Method doPreparePayment - Used to prepare the payment.
+ *
+ * @remarks
+ * * Calls /rest/storefront/checkout/payment
+ * * Method should be used to prepare the payment.
+ *
+ * @param { PreparePaymentResult } params
+ * orderId: number,
+ * paymentId: number,
+ *
+ * @returns
+ * type: strig,
+ * value: null
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doPreparePayment();
+ * ```
+ */
+const doPreparePayment = async (context) => {
+    const url = new URL('/rest/storefront/checkout/payment', context.config.api.url);
+    const { data } = await context.client.post(url.href);
+    return { data: data.data };
+};
+
+/**
+ * Method doPlaceOrder - Used to place an order.
+ *
+ * @remarks
+ * * Calls /rest/storefront/orders
+ * * Method should be used to place an order.
+ *
+ * @returns Order
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doPlaceOrder();
+ * ```
+ */
+const doPlaceOrder = async (context) => {
+    const url = new URL('/rest/storefront/orders', context.config.api.url);
+    const { data: response } = await context.client.post(url.href);
+    return { data: response.data };
+};
+
+/**
+ * Method doExecutePayment - Used to execute the payment.
+ *
+ * @remarks
+ * * Calls /rest/storefront/checkout/payment/execute
+ * * Method should be used to execute the payment.
+ *
+ * @param { ExecutePaymentParams } params
+ * orderId: number,
+ * paymentId: number,
+ *
+ * @returns
+ * type: null,
+ * value: null
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doExecutePayment({
+ *   orderId: 1123,
+ *   paymentId: 123
+ * });
+ * ```
+ */
+const doExecutePayment = async (context, params) => {
+    const url = new URL('/rest/storefront/checkout/payment/execute', context.config.api.url);
+    const { data: response } = await context.client.post(url.href, {
+        orderId: params.orderId,
+        paymentMethodId: params.paymentId,
+    });
+    return { data: response.data };
+};
+
+/**
+ * Method doMakeOrderReturn - Used to execute the order return.
+ *
+ * @remarks
+ * * Calls /rest/storefront/returns
+ * * Method should be used to execute the order return.
+ *
+ * @param { MakeOrderReturnParams } params
+ * params: a string derived from the url of the order
+ *
+ * @returns Order
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doMakeOrderReturn({
+ *   orderId: 123456,
+ *   orderAccessKey: 'ABCDEFGH',
+ *   110: {
+ *     quantitiy: 2,
+ *     returnReasonId: 1,
+ *   }
+ * });
+ * ```
+ */
+const doMakeOrderReturn = async (context, params) => {
+    const url = new URL('/rest/storefront/returns', context.config.api.url);
+    const { data } = await context.client.post(url.href, params);
+    return { data: data };
+};
+
+/**
+ * Method getReviewAverage - Gets review stars for a product by itemId
+ *
+ * @remarks
+ * * Calls the /rest/storefront/feedbacks/feedback/helper/counts/${params.itemId}
+ * * This method is used to get review average (stars) from a product.
+ *
+ * @param { ReviewAverageParams } params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getReviewAverage({itemId: 109});
+ * ```
+ */
+const getReviewAverage = async (context, params) => {
+    const urlFeedbackStars = new URL(`/rest/storefront/feedbacks/feedback/helper/counts/${params.itemId}`, context.config.api.url);
+    urlFeedbackStars.searchParams.set('allowFeedbacksOnlyIfPurchased', 'false');
+    urlFeedbackStars.searchParams.set('numberOfFeedbacks', '100');
+    const { data } = await context.client.get(urlFeedbackStars.href);
+    return { data: data };
+};
+
+/**
+ * Method getOrderDocument - Used to get the document file.
+ *
+ * @remarks
+ * * Calls /rest/storefront/order/document/preview/${docReferenceId}/?orderId=${orderId}&accessKey=${accessKey}
+ * * Method should be used to get the document file in array buffer format.
+ *
+ * @param { OrderDocumentParams } params
+ * document: the order document.
+ * accessKey: order access key.
+ *
+ * @returns { Promise<{ data: number[] }> }
+ * The document file in an array buffer format.
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getOrderDocument({
+ *     document: {},
+ *     accessKey: '',
+ * });
+ * ```
+ */
+const getOrderDocument = async (context, params) => {
+    const docReferenceId = params.document.pivot.plenty_document_reference_document_id;
+    const orderId = params.document.pivot.plenty_document_reference_value;
+    const url = new URL(`/rest/storefront/order/document/preview/${docReferenceId}/?orderId=${orderId}&accessKey=${params.accessKey}`, context.config.api.url);
+    const { data } = await context.client.get(url.href, {
+        responseType: 'arraybuffer',
+    });
+    const uint8Array = new Uint8Array(data);
+    return { data: Array.from(uint8Array) };
+};
+
+/**
+ * Method getPayPalDataClientToken - get PayPal data client token
+ *
+ * @remarks
+ * * Calls the /rest/payment/payPal/client_token endpoint.
+ * * This method is used to get the PayPal client token and client id.
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getPayPalDataClientToken();
+ * ```
+ */
+const getPayPalDataClientToken = async (context) => {
+    const url = new URL('/rest/payment/payPal/client_token', context.config.api.url);
+    const { data } = await context.client.get(url.href);
+    return { data: data };
+};
+
+/**
+ * Method doCreatePayPalCreditCardTransaction - creates a PayPal credit card transaction.
+ *
+ * @remarks
+ * * Calls /rest/payment/payPal/smart_payment/create_order
+ * * This method creates a PayPal credit card transaction.
+ *
+ * @returns
+ * id: string = The ID of the PayPal credit card transaction.
+ * status: string = The status of the PayPal credit card transaction, e.g. CREATED
+ * links: PayPalLink[] = Links to the PayPal credit card transaction.
+ * payPalPayerId: string = The PayPal payer ID of the PayPal credit card transaction.
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doCreatePayPalCreditCardTransaction();
+ * ```
+ */
+const doCreatePayPalCreditCardTransaction = async (context) => {
+    const url = new URL('/rest/payment/payPal/smart_payment/create_order', context.config.api.url);
+    const { data } = await context.client.post(url.href, {
+        // eslint-disable-next-line camelcase
+        bn_code_override: 'paypal_pwa'
+    });
+    return { data: data };
+};
+
+/**
+ * Method doCapturePayPalOrder - (re-)captures a PayPal order.
+ *
+ * @remarks
+ * * Calls for capturing /rest/payment/payPal/smart_payment/{params.paypalOrderId}/{params.paypalPayerId}/capture
+ * * Calls for re-capturing /rest/payment/payPal/smart_payment/${params.paypalOrderId}/${params.paypalPayerId}/${params.plentyOrderId}/reinit_capture_order
+ * * This method is used to (re-)capture a PayPal order.
+ * * Response can have an error string, which is a human-readable error message.
+ *
+ * @param { PayPalCaptureOrderParams } params
+ * paypalOrderId: string - The PayPal order ID of the PayPal order.
+ * paypalPayerId: string - The PayPal payer ID of the PayPal order.
+ * plentyOrderId?: number - The order ID
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doCapturePayPalOrder({
+ *    paypalOrderId: '7PE78730EB4411431',
+ *    paypalPayerId: 'A676SPCN9SBDQ',
+ * });
+ * ```
+ */
+const doCapturePayPalOrder = async (context, params) => {
+    const path = params.plentyOrderId
+        ? `/rest/payment/payPal/smart_payment/${params.paypalOrderId}/${params.paypalPayerId}/${params.plentyOrderId}/reinit_capture_order`
+        : `/rest/payment/payPal/smart_payment/${params.paypalOrderId}/${params.paypalPayerId}/capture_order`;
+    const url = new URL(path, context.config.api.url);
+    const { data } = await context.client.post(url.href, {
+        // eslint-disable-next-line camelcase
+        bn_code_override: 'paypal_pwa'
+    });
+    return { data: data };
+};
+
+/**
+ * Method doCustomerContactMail - process customer contact request.
+ * ##  *! ROUTE IS NOT FUNCTIONAL*
+ * This is route is not functional because reCAPTCHA is not implemented yet.
+ *
+ * @remarks
+ * * Calls /rest/io/customer/contact/mail/
+ * * This method is used to send the contact request.
+ *
+ * @param { CustomerContactEmailParams } params
+ * name: string - The name of the sender.
+ * email: string - The email of the sender.
+ * message: string - The message.
+ *
+ * @example
+ * ``` ts
+ * const { data } = await sdk.boilerplate.doCustomerContactMail({
+ *   name: '',
+ *   email: '',
+ *   message: '',
+ * });
+ * ```
+ */
+const doCustomerContactMail = async (context, params) => {
+    const url = new URL('rest/storefront/contact/mail', context.config.api.url);
+    const { data } = await context.client.post(url.href, params);
+    return { data: data };
+};
+
+/**
+ * Method doAddCoupon - Used to add a coupon to the cart.
+ *
+ * @remarks
+ * * Calls /rest/storefront/coupons/
+ * * Method should be used to add a coupon to the cart.
+ *
+ * @param { DoAddCouponParams } params
+ * couponCode: string,
+ *
+ * @returns
+ * The cart or error.
+ *
+ * @example
+ * ``` ts
+ * const { data, error } = await sdk.boilerplate.doAddCoupon({
+ *   couponCode: ''
+ * });
+ * ```
+ */
+const doAddCoupon = async (context, params) => {
+    const url = new URL('/rest/storefront/coupons/', context.config.api.url);
+    const { data } = await context.client.post(url.href, params);
+    return { data: data };
+};
+
+/**
+ * Method deleteCoupon - Used to delete the coupon from the cart.
+ *
+ * @remarks
+ * * Calls /rest/storefront/coupons/
+ * * Method should be used to delete the coupon from the cart.
+ *
+ * @param { DoAddCouponParams } params
+ * couponCode: string,
+ *
+ * @returns
+ * The cart or error.
+ *
+ * @example
+ * ``` ts
+ * const { data } = await sdk.boilerplate.deleteCoupon({
+ *   couponCode: ''
+ * });
+ * ```
+ */
+const deleteCoupon = async (context, params) => {
+    const url = new URL(`/rest/storefront/coupons/${params.couponCode}/`, context.config.api.url);
+    const { data } = await context.client.delete(url.href);
+    return { data: data };
+};
+
+/**
+ * Method getInit - get current session and the category tree
+ *
+ * @remarks
+ * * calls /rest/storefront/init and returns user session and the category tree
+ *
+ * @returns
+ * Promise<{data: InitResult}>
+ *
+ * @example
+ * const { data, error } = await useAsyncData(() => sdk.plentysystems.getInit());
+ */
+const getInit = async (context) => {
+    const url = new URL('/rest/storefront/init', context.config.api.url);
+    url.searchParams.set('level', '5');
+    const { data: response } = await context.client.get(url.href);
+    const session = response.data.session;
+    const categories = response.data.categories;
+    const cartItems = session.cartItems;
+    const cart = { ...session.cart, items: getMappedCartItems(cartItems) };
+    return {
+        data: {
+            session: {
+                user: session.customer ||
+                    (session.guest
+                        ? { guestMail: session.guest }
+                        : null),
+                basket: cart,
+            },
+            categories
+        },
+    };
+};
+
+/**
+ * Method doUploadOrderPropertyFile - Uploads a file for an order property.
+ *
+ * @remarks
+ * * Calls /rest/io/order/property/file
+ * * This method is used to upload a file for an order property.
+ *
+ * @param { UploadFileForOrderPropertyParams } params
+ * base64: string;
+ * filename: string;
+ * type: string;
+ *
+ * @returns
+ * The name of the uploaded file
+ *
+ * @example
+ * ``` ts
+ * const { data, error } = await sdk.boilerplate.doUploadOrderPropertyFile({
+ *   base64: 'base64_file_string',
+ *   filename: 'filename.png',
+ *   type: 'image/png'
+ * });
+ * ```
+ */
+const doUploadOrderPropertyFile = async (context, params) => {
+    const url = new URL('/rest/storefront/order-property-file', context.config.api.url);
+    const byteCharacters = atob(params.base64);
+    const byteNumbers = new Array(byteCharacters.length);
+    for (let i = 0; i < byteCharacters.length; i++) {
+        byteNumbers[i] = byteCharacters.charCodeAt(i);
+    }
+    const byteArray = new Uint8Array(byteNumbers);
+    const blob = new Blob([byteArray], { type: params.filename });
+    const file = new File([blob], params.filename, { type: params.type });
+    const formData = new FormData();
+    formData.append('fileData', file);
+    const { data } = await context.client.post(url.href, formData, {
+        headers: {
+            'Content-Type': 'multipart/form-data'
+        }
+    });
+    return { data: data };
+};
+
+/**
+ * Method getReturnReasons - get return reasons
+ *
+ * @remarks
+ * calls /rest/storefront/return/reasons endpoint
+ *
+ * @returns
+ * Promise<{data: OrderReturnReason}>
+ *
+ * @example
+ * ``` ts
+ * const { data, error } = await useAsyncData(() => sdk.plentysystems.getReturnReasons());
+ * ```
+ */
+const getReturnReasons = async (context) => {
+    const url = new URL('/rest/storefront/return/reasons', context.config.api.url);
+    const { data } = await context.client.get(url.href);
+    return { data: data };
+};
+
+/**
+ * Method getAuthenticatedReview - Gets product reviews from current active user account.
+ *
+ * @remarks
+ * * Calls /rest/feedbacks/user/${itemId}/${variationId}
+ * * This method is used to get product reviews that are made by the currently active user account.
+ *
+ * @param { AuthenticatedReviewSearchParams } params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getAuthenticatedReview({ itemId: 1100, variationId: 1890 });
+ * ```
+ */
+const getAuthenticatedReview = async (context, params) => {
+    const itemId = params.itemId;
+    const variationId = params.variationId;
+    const url = new URL(`/rest/feedbacks/user/${itemId}/${variationId}`, context.config.api.url);
+    const { data } = await context.client.get(url.href);
+    return { data: data };
+};
+
+/**
+ * Method doReview - Create a new product review.
+ *
+ * @remarks
+ * * Calls /rest/feedbacks/feedback/create
+ * * This method is used to create a new product review.
+ *
+ * @param { CreateReviewParams } params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doReview({
+ *     ratingValue: 3,
+ *     authorName: 'John Doe',
+ *     title: 'Great product',
+ *     message: 'That's an awesome product',
+ *     type: 'review',
+ *     targetId: 1890,
+ *     honeypot: '',
+ *     titleMissing: false,
+ *     ratingMissing: false,
+ * });
+ * ```
+ */
+const doReview = async (context, params) => {
+    const url = new URL('/rest/feedbacks/feedback/create', context.config.api.url);
+    const { data } = await context.client.post(url.href, params);
+    return { data };
+};
+
+/**
+ * Method setReview - Used to save changes on a product review.
+ *
+ * @remarks
+ * * Calls '/rest/feedbacks/feedback/update/' + params.feedbackId
+ * * Method saves changes on a product review.
+ *
+ * @param { UpdateReviewParams } params
+ * feedbackId: id of the product review.
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.setReview({
+ *    message: params.message,
+ *    title: params.title,
+ *    ratingValue: params.ratingValue
+ * });
+ * ```
+ */
+const setReview = async (context, params) => {
+    const url = new URL('/rest/feedbacks/feedback/update/' + params.feedbackId, context.config.api.url);
+    const { data } = await context.client.put(url.href, {
+        message: params.message,
+        title: params.title,
+        ratingValue: params.ratingValue,
+        authorName: params.authorName,
+    });
+    return { data };
+};
+
+/**
+ * Method setConfiguration - Used to save changes on a system configuration.
+ *
+ * @remarks
+ * * Method saves changes on a system configuration.
+ *
+ * @param { UpdateConfigurationParams } params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.setConfiguration({
+ *  category: 'seo',
+ *     settings: [{
+ *         "key": "font",
+ *         "value": "arial2"
+ *     }]
+ *  });
+ * ```
+ */
+const setConfiguration = async (context, params) => {
+    const url = new URL('/rest/settings/', context.config.api.url);
+    const { data } = await context.client.put(url.href, params);
+    return { data };
+};
+
+/**
+ * Method deleteReview - Delete a product review.
+ *
+ * @remarks
+ * * Calls /rest/feedbacks/feedback/delete/${params.feedbackId}
+ * * This method is used to delete a product review.
+ *
+ * @param { DeleteReviewParams } params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.deleteReview({ feedbackId: 42 });
+ * ```
+ */
+const deleteReview = async (context, params) => {
+    const url = new URL(`/rest/feedbacks/feedback/delete/${params.feedbackId}`, context.config.api.url);
+    const { data: response } = await context.client.delete(url.href);
+    return { data: Boolean(response.data) };
+};
+
+/**
+ * Method getOrderPropertyFile - Get the order property file.
+ *
+ * @remarks
+ * * Calls /rest/storefront/order-property-file/{hash}/{fileName} endpoint.
+ * * Method should be used to get the document file in base64 encoded format.
+ *
+ * @param { OrderPropertyFileParams } params
+ * hash: file hash
+ * fileName: file name
+ *
+ * @returns { Promise<{ data: OrderPropertyFileResponse }> }
+ * The document file in base64 encoded format with type.
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getOrderPropertyFile({
+ *     hash: 'abcdefgh,
+ *     fileName: 'test.png',
+ * });
+ * ```
+ */
+const getOrderPropertyFile = async (context, params) => {
+    const url = new URL(`/rest/storefront/order-property-file/${params.hash}/${params.fileName}`, context.config.api.url);
+    const { data } = await context.client.get(url.href);
+    return { data: data };
+};
+
+/**
+ * Method doAddCartItems - Adds products to the cart.
+ *
+ * @remarks
+ * * Calls /rest/storefront/cart/items/
+ * * This method is used to add multiple products to the cart.
+ *
+ * @param { DoAddItemParams[] } params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doAddCartItems([{
+ *     productId: 1100,
+ *     quantity: 1
+ * }]);
+ * ```
+ */
+const doAddCartItems = async (context, params) => {
+    const url = new URL('/rest/storefront/cart/items/', context.config.api.url);
+    const items = params.map((item) => {
+        return {
+            variationId: item.productId,
+            quantity: item.quantity,
+            basketItemOrderParams: item.basketItemOrderParams,
+        };
+    });
+    const { data } = await context.client.post(url.href, {
+        basketItems: items,
+    });
+    return {
+        data: {
+            ...data.events.AfterBasketChanged.basket,
+            items: data.events.AfterBasketChanged.basketItems,
+        },
+    };
+};
+
+/**
+ * Method doOrderAgainInformation - Used to get the order with the current prices.
+ *
+ * @remarks
+ * * Calls /rest/storefront/orders/order-again-information
+ * * This method is used to get the order with the current prices.
+ *
+ * @param { GetOrderAgainInformationParams } params
+ *
+ * @returns { Data<GetOrderAgainInformationResponse> }
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doOrderAgainInformation({
+ *     orderId: "12345",
+ *     accessKey: "ABC123"
+ * });
+ * ```
+ */
+const doOrderAgainInformation = async (context, params) => {
+    const url = new URL('/rest/storefront/orders/order-again-information', context.config.api.url);
+    const { data } = await context.client.post(url.href, params);
+    return { data: data };
+};
+
+/**
+ * Method doMigrateGuestOrderToCustomer - Used to migrate a guest order to the logged-in customer.
+ *
+ * @remarks
+ * * Calls /rest/storefront/order/migrate-guest
+ * * Method should be used to migrate a guest order to the logged-in customer.
+ *
+ * @param { MakeOrderReturnParams } params
+ * orderId: number - The ID of the order to be migrated.
+ * accessKey: string - The access key of the order to be migrated.
+ * postcodes: string - The postcode of the order for validation.
+ * name: string - The lastname of the order for validation.
+ *
+ * @returns Order
+ *
+ * @example
+ * ``` ts
+ * const { data, error } = await useSdk().plentysystems.doMigrateGuestOrderToCustomer({
+ *   orderId: 123456,
+ *   orderAccessKey: 'ABCDEFGH',
+ *   postcode: '12345',
+ *   name: 'Doe'
+ * });
+ * ```
+ */
+const doMigrateGuestOrderToCustomer = async (context, params) => {
+    const url = new URL('/rest/storefront/order/migrate-guest', context.config.api.url);
+    const { data } = await context.client.post(url.href, params);
+    return { data: data };
+};
+
+/**
+ * Method getPayPalMerchantAndClientIds - get PayPal data merchant id and client id
+ *
+ * @remarks
+ * * Calls the /rest/paypal/merchant_and_client_ids endpoint.
+ * * This method is used to get the PayPal merchant id and client id.
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getPayPalMerchantAndClientIds();
+ * ```
+ */
+const getPayPalMerchantAndClientIds = async (context) => {
+    const url = new URL('/rest/paypal/merchant_and_client_ids', context.config.api.url);
+    const { data } = await context.client.get(url.href);
+    return { data: data };
+};
+
+/**
+ * Method doHandleAllowPaymentGooglePay - Used to allow payment for Google Pay.
+ *
+ * @remarks
+ * * Calls /rest/payment/payPal/googlePay/handle_allowed_payment_methods
+ * * Used to update the availability for Google Pay.
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doHandleAllowPaymentGooglePay({
+ *  allowedPaymentMethods: []
+ * });
+ * ```
+ * @param params PayPalGooglePayPaymentMethods
+ */
+const doHandleAllowPaymentGooglePay = async (context, params) => {
+    const url = new URL('/rest/payment/payPal/googlePay/handle_allowed_payment_methods', context.config.api.url);
+    const { data } = await context.client.post(url.href, params);
+    return { data: data };
+};
+
+/**
+ * Method doHandleAllowPaymentApplePay - Used to allow payment for Apple Pay.
+ *
+ * @remarks
+ * * Calls /rest/payment/payPal/applePay/handle_allowed
+ * * Used to update the availability for Apple Pay.
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doHandleAllowPaymentApplePay({
+ *  canMakePayments: true,
+ * });
+ * ```
+ * @param params PayPalAllowApplePayRequest
+ */
+const doHandleAllowPaymentApplePay = async (context, params) => {
+    const url = new URL('/rest/payment/payPal/applePay/handle_allowed', context.config.api.url);
+    const { data } = await context.client.post(url.href, params);
+    return { data: data };
+};
+
+/**
+ * Method getPayPalOrderDetails - get the details of an PayPal order.
+ *
+ * @remarks
+ * * Calls the /rest/payment/payPal/order_details/payPalPayerId/paypalOrderId endpoint.
+ * * This method is used to get the details of an PayPal order.
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.getPayPalOrderDetails({
+ *  payPalPayerId: 'payPalPayerId',
+ *  paypalOrderId: 'paypalOrderId',
+ * });
+ * ```
+ */
+const getPayPalOrderDetails = async (context, params) => {
+    const url = new URL(`/rest/payment/payPal/order_details/${params.payPalPayerId}/${params.paypalOrderId}`, context.config.api.url);
+    url.searchParams.set('bn_code_override', 'paypal_pwa');
+    const { data } = await context.client.get(url.href);
+    return { data: data };
+};
+
+/**
+ * Method doEmailConfirmation - Confirm newsletter email
+ *
+ * @remarks
+ * * Calls /rest/storefront/newsletter-opt-in
+ * * This method is used to confirm email address
+ *
+ * @param { NewsletterEmailConfirmationParams } params
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doEmailConfirmation({
+ *       newsletterEmailId: '10',
+ *       authString: 'dkadjkaJKSDASKJ#3290DAS'
+ * });
+ * ```
+ */
+const doEmailConfirmation = async (context, params) => {
+    const url = new URL('/rest/storefront/newsletter-opt-in', context.config.api.url);
+    const { data } = await context.client.post(url.href, {
+        newsletterEmailId: params.newsletterEmailId,
+        authString: params.authString,
+    });
+    return { data: Boolean(data.response) };
+};
+
+/**
+ * Method setCategoryTemplate - Used to update category template instance.
+ *
+ * @param params
+ * CategoryTemplateParams
+ *
+ * @returns
+ * CategoryTemplate
+ * @example
+ * ``` ts
+ * const { data } = await setCategoryTemplate(() => useSdk().plentysystems.setCategoryTemplate({
+ *    id: 1,
+ *    content: 'Test Related Data'
+ * }));
+ * ```
+ */
+const setCategoryTemplate = async (context, params) => {
+    const url = new URL(`rest/storefront/categories/template/${params.id}`, context.config.api.url);
+    const { data } = await context.client.put(url.href, {
+        content: params.content,
+    });
+    return { data: data };
+};
+
+/**
+ * Method doApplyConfiguration - Apply current configuration.
+ *
+ * @remarks
+ * * Calls /rest/storefront/deploy
+ * * This method is used to apply the current configuration.
+ *
+ * @param requireBuild - If true, the configuration is applied and the storefront is rebuilt.
+ *
+ * @returns
+ *
+ * @example
+ * ``` ts
+ * const { data } = await useSdk().plentysystems.doApplyConfiguration(true);
+ * ```
+ */
+const doApplyConfiguration = async (context, requireBuild = true) => {
+    const url = new URL('/rest/storefront/deploy/', context.config.api.url);
+    const { data } = await context.client.post(url.href, requireBuild);
+    return { data: data };
+};
+
+var api = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  getProduct: getProduct,
+  getCategoryTemplate: getCategoryTemplate,
+  getCategoryTree: getCategoryTree,
+  getLegalTexts: getLegalTexts,
+  doLogin: doLogin,
+  getSession: getSession,
+  getAddresses: getAddresses,
+  doSaveAddress: doSaveAddress,
+  setCheckoutAddress: setCheckoutAddress,
+  deleteAddress: deleteAddress,
+  getActiveShippingCountries: getActiveShippingCountries,
+  getAggregatedCountries: getAggregatedCountries,
+  getReview: getReview,
+  getCart: getCart,
+  doAddCartItem: doAddCartItem,
+  deleteCartItem: deleteCartItem,
+  setCartItemQuantity: setCartItemQuantity,
+  deleteAllCartItems: deleteAllCartItems,
+  deleteCart: deleteCart,
+  doSubscribeNewsletter: doSubscribeNewsletter,
+  deleteNewsletterSubscription: deleteNewsletterSubscription,
+  getSearch: getSearch,
+  getShippingProvider: getShippingProvider,
+  setShippingProvider: setShippingProvider,
+  getOrders: getOrders,
+  getPaymentProviders: getPaymentProviders,
+  setPaymentProvider: setPaymentProvider,
+  setMobilePaymentProviderList: setMobilePaymentProviderList,
+  getReturns: getReturns,
+  getWishlist: getWishlist,
+  doAddWishlistItem: doAddWishlistItem,
+  deleteWishlistItem: deleteWishlistItem,
+  doAcceptOffer: doAcceptOffer,
+  doCreatePayPalTransaction: doCreatePayPalTransaction,
+  doApprovePayPalTransaction: doApprovePayPalTransaction,
+  getExecutePayPalOrder: getExecutePayPalOrder,
+  getFacet: getFacet,
+  doLoginAsGuest: doLoginAsGuest,
+  doRegisterUser: doRegisterUser,
+  doRejectOffer: doRejectOffer,
+  doLogoutUser: doLogoutUser,
+  doChangeUserPassword: doChangeUserPassword,
+  getOffer: getOffer,
+  getOrder: getOrder,
+  doAdditionalInformation: doAdditionalInformation,
+  doPreparePayment: doPreparePayment,
+  doPlaceOrder: doPlaceOrder,
+  doExecutePayment: doExecutePayment,
+  doMakeOrderReturn: doMakeOrderReturn,
+  getReviewAverage: getReviewAverage,
+  getOrderDocument: getOrderDocument,
+  getPayPalDataClientToken: getPayPalDataClientToken,
+  doCreatePayPalCreditCardTransaction: doCreatePayPalCreditCardTransaction,
+  doCapturePayPalOrder: doCapturePayPalOrder,
+  doCustomerContactMail: doCustomerContactMail,
+  doAddCoupon: doAddCoupon,
+  deleteCoupon: deleteCoupon,
+  getInit: getInit,
+  doUploadOrderPropertyFile: doUploadOrderPropertyFile,
+  getReturnReasons: getReturnReasons,
+  getAuthenticatedReview: getAuthenticatedReview,
+  doReview: doReview,
+  setReview: setReview,
+  setConfiguration: setConfiguration,
+  deleteReview: deleteReview,
+  getOrderPropertyFile: getOrderPropertyFile,
+  doAddCartItems: doAddCartItems,
+  doOrderAgainInformation: doOrderAgainInformation,
+  doMigrateGuestOrderToCustomer: doMigrateGuestOrderToCustomer,
+  getPayPalMerchantAndClientIds: getPayPalMerchantAndClientIds,
+  doHandleAllowPaymentGooglePay: doHandleAllowPaymentGooglePay,
+  doHandleAllowPaymentApplePay: doHandleAllowPaymentApplePay,
+  getPayPalOrderDetails: getPayPalOrderDetails,
+  doEmailConfirmation: doEmailConfirmation,
+  setCategoryTemplate: setCategoryTemplate,
+  doApplyConfiguration: doApplyConfiguration
+});
+
+class HeaderSyncer {
+    constructor() {
+        this.responseHeaders = {};
+        this.requestHeaders = {};
+        this.headerWhitelist = ['x-csrf-token', 'set-cookie', 'cookie', 'x-config-id', 'x-pwa-edit-hash'];
+        this.setCookieHeaderBlacklist = ['XSRF-TOKEN'];
+    }
+    clearHeaders() {
+        this.responseHeaders = {};
+        this.requestHeaders = {};
+    }
+    storeResponseHeaders(headers) {
+        this.clearHeaders();
+        this.responseHeaders = headers;
+    }
+    storeRequestHeaders(headers) {
+        this.requestHeaders = headers;
+    }
+    addSecurityHeaders(request, config) {
+        request.headers['x-security-token'] = config.api?.securityToken ?? '';
+    }
+    changeHeaderValueKey(value, oldKey, newKey) {
+        if (Array.isArray(value)) {
+            value.forEach((cookie, key) => {
+                if (cookie.startsWith(newKey + '=')) {
+                    value.splice(key, 1);
+                }
+                if (cookie.startsWith(oldKey + '=')) {
+                    value[key] = cookie.replace(oldKey + '=', newKey + '=');
+                }
+            });
+        }
+        else {
+            const newCookie = value.toString().split(';')
+                .map((cookie) => {
+                if (cookie.trim().startsWith(newKey + '=')) {
+                    return '';
+                }
+                if (cookie.trim().startsWith(oldKey + '=')) {
+                    return cookie.trim().replace(oldKey + '=', newKey + '=');
+                }
+                return cookie.trim();
+            });
+            value = newCookie.filter((str) => str.length > 0).join('; ');
+        }
+        return value;
+    }
+    addRequestHeaders(request) {
+        Object.entries(this.requestHeaders).forEach(([key, value]) => {
+            if (this.headerWhitelist.includes(key)) {
+                if (key === 'cookie') {
+                    value = this.changeHeaderValueKey(value, HeaderSyncer.PwaSessionIdCookie, HeaderSyncer.PlentyIdCookie);
+                }
+                request.headers[key] = value;
+            }
+        });
+    }
+    addResponseHeaders(response) {
+        Object.entries(this.responseHeaders).forEach(([key, value]) => {
+            if (this.headerWhitelist.includes(key)) {
+                if (key === 'set-cookie') {
+                    if (Array.isArray(value)) {
+                        value = value.map((setCookieHeader) => {
+                            return setCookieHeader.replace(/domain=[^;]+;/, '');
+                        }).filter((setCookieHeader) => {
+                            return !this.setCookieHeaderBlacklist.some((blacklistedHeader) => setCookieHeader.includes(blacklistedHeader));
+                        });
+                    }
+                    else {
+                        value = value?.toString().replace(/domain=[^;]+;/, '');
+                    }
+                    value = this.changeHeaderValueKey(value, HeaderSyncer.PlentyIdCookie, HeaderSyncer.PwaSessionIdCookie);
+                    if (value) {
+                        response.setHeader(key, value);
+                    }
+                }
+                else if (value) {
+                    response.setHeader(key, value.toString());
+                }
+            }
+        });
+        response.set('Access-Control-Expose-Headers', 'x-csrf-token');
+        this.clearHeaders();
+        return response;
+    }
+}
+HeaderSyncer.PlentyIdCookie = 'plentyID';
+HeaderSyncer.PwaSessionIdCookie = 'pwa-session-id';
+
+class ReferrerSyncer {
+    constructor() {
+        this.requestReferrerID = null;
+    }
+    storeRequestReferrerHeader(headers) {
+        this.requestReferrerID = headers[ReferrerSyncer.HeaderReferrerKey] ?? null;
+    }
+    addReferrerToUrl(request) {
+        if (this.requestReferrerID) {
+            const url = new URL(request.url);
+            url.searchParams.set(ReferrerSyncer.APIReferrerKey, this.requestReferrerID);
+            request.url = url.toString();
+        }
+        this.requestReferrerID = null;
+    }
+}
+ReferrerSyncer.HeaderReferrerKey = 'referrerid';
+ReferrerSyncer.APIReferrerKey = 'ReferrerID';
+
+class NoCacheSyncer {
+    constructor() {
+        this.noCacheValue = null;
+    }
+    storeNoCacheValue(headers) {
+        this.noCacheValue = headers[NoCacheSyncer.HeaderNoCacheKey] ?? null;
+    }
+    addNoCacheToUrl(request) {
+        if (this.noCacheValue) {
+            const url = new URL(request.url);
+            url.searchParams.set(NoCacheSyncer.APINoCacheKey, this.noCacheValue);
+            request.url = url.toString();
+        }
+        this.noCacheValue = null;
+    }
+}
+NoCacheSyncer.HeaderNoCacheKey = 'nocache';
+NoCacheSyncer.APINoCacheKey = 'noCache';
+
+const headerSyncer = new HeaderSyncer();
+const referrerSyncer = new ReferrerSyncer();
+const noCacheSyncer = new NoCacheSyncer();
+const buildClient = (config) => {
+    const client = axios__default["default"].create({
+        withCredentials: true,
+    });
+    client.interceptors.request.use((request) => {
+        headerSyncer.addSecurityHeaders(request, config);
+        headerSyncer.addRequestHeaders(request);
+        referrerSyncer.addReferrerToUrl(request);
+        noCacheSyncer.addNoCacheToUrl(request);
+        if (config.api.debug)
+            logRequest(request);
+        return request;
+    });
+    client.interceptors.response.use((response) => {
+        headerSyncer.storeResponseHeaders(response.headers);
+        if (config.api.debug)
+            logResponse(response);
+        return response;
+    });
+    return client;
+};
+const onCreate = (config) => {
+    const client = buildClient(config);
+    return {
+        config,
+        client,
+    };
+};
+const middlewareExtension = {
+    name: 'middleware-extension',
+    hooks: (req, res) => ({
+        beforeCreate: ({ configuration }) => {
+            headerSyncer.storeRequestHeaders(req.headers);
+            referrerSyncer.storeRequestReferrerHeader(req.headers);
+            noCacheSyncer.storeNoCacheValue(req.headers);
+            return configuration;
+        },
+        afterCall: ({ response }) => {
+            headerSyncer.addResponseHeaders(res);
+            return response;
+        },
+    }),
+};
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignorer
+const { createApiClient } = middleware.apiClientFactory({
+    onCreate,
+    api,
+    extensions: [middlewareExtension],
+});
+
+exports.createApiClient = createApiClient;
+//# sourceMappingURL=index.js.map