@plentymarkets/shop-api 0.121.0 → 0.122.1

package/server/hooks/__tests__/__fixtures__/RequestHeaderFixture.d.ts

@@ -0,0 +1,39 @@
+export declare const ResponseHeadersFixture: {
+    'content-type': string;
+    'cache-control': string;
+    date: string;
+    'x-csrf-token': string;
+    'x-request-id': string;
+    'x-session-expiration': string;
+    'set-cookie': string[];
+    'strict-transport-security': string;
+    vary: string;
+    connection: string;
+    'transfer-encoding': string;
+};
+export declare const RequestHeadersFixture: {
+    host: string;
+    connection: string;
+    'content-length': string;
+    pragma: string;
+    'cache-control': string;
+    'sec-ch-ua-platform': string;
+    'X-Config-Id': string;
+    'sec-ch-ua': string;
+    'sec-ch-ua-mobile': string;
+    referrerid: string;
+    noCache: string;
+    locale: string;
+    'user-agent': string;
+    accept: string;
+    'content-type': string;
+    origin: string;
+    'sec-fetch-site': string;
+    'sec-fetch-mode': string;
+    'sec-fetch-dest': string;
+    referer: string;
+    'accept-encoding': string;
+    'accept-language': string;
+    cookie: string;
+};
+//# sourceMappingURL=RequestHeaderFixture.d.ts.map

package/server/hooks/__tests__/__fixtures__/RequestHeaderFixture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequestHeaderFixture.d.ts","sourceRoot":"","sources":["../../../../src/hooks/__tests__/__fixtures__/RequestHeaderFixture.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;CAclC,CAAA;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;CAyBjC,CAAA"}

package/server/hooks/afterCall.d.ts

@@ -0,0 +1,5 @@
+import { AlokaiResponse } from '@vue-storefront/middleware';
+import { MiddlewareConfig } from 'src/types';
+import type { Response } from 'express';
+export declare const afterCallWrapper: (response: Response, alokaiResponse: AlokaiResponse, config: MiddlewareConfig) => Response;
+//# sourceMappingURL=afterCall.d.ts.map

package/server/hooks/afterCall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"afterCall.d.ts","sourceRoot":"","sources":["../../src/hooks/afterCall.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGxC,eAAO,MAAM,gBAAgB,GAAI,UAAU,QAAQ,EAAE,gBAAgB,cAAc,EAAE,QAAQ,gBAAgB,KAAG,QAK/G,CAAC"}

package/server/hooks/beforeCreate.d.ts

@@ -0,0 +1,4 @@
+import { AlokaiRequest } from '@vue-storefront/middleware';
+import { MiddlewareConfig } from 'src/types';
+export declare const beforeCreateWrapper: (request: AlokaiRequest, config: MiddlewareConfig) => MiddlewareConfig;
+//# sourceMappingURL=beforeCreate.d.ts.map

package/server/hooks/beforeCreate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"beforeCreate.d.ts","sourceRoot":"","sources":["../../src/hooks/beforeCreate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAG7C,eAAO,MAAM,mBAAmB,GAAI,SAAS,aAAa,EAAE,QAAQ,gBAAgB,KAAG,gBAGtF,CAAC"}

package/server/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './afterCall';
+export * from './beforeCreate';
+export * from './onRequest';
+export * from './onResponse';
+//# sourceMappingURL=index.d.ts.map

package/server/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC"}

package/server/hooks/onRequest.d.ts

@@ -0,0 +1,4 @@
+import { InternalAxiosRequestConfig } from 'axios';
+import { MiddlewareConfig } from 'src/types';
+export declare const onRequestWrapper: (request: InternalAxiosRequestConfig, config: MiddlewareConfig) => InternalAxiosRequestConfig;
+//# sourceMappingURL=onRequest.d.ts.map

package/server/hooks/onRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onRequest.d.ts","sourceRoot":"","sources":["../../src/hooks/onRequest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,OAAO,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAI7C,eAAO,MAAM,gBAAgB,GAAI,SAAS,0BAA0B,EAAE,QAAQ,gBAAgB,KAAG,0BAsChG,CAAC"}

package/server/hooks/onResponse.d.ts

@@ -0,0 +1,3 @@
+import { MiddlewareConfig, PlentyResponse } from 'src/types';
+export declare const onResponseWrapper: (response: PlentyResponse, config: MiddlewareConfig) => PlentyResponse;
+//# sourceMappingURL=onResponse.d.ts.map

package/server/hooks/onResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onResponse.d.ts","sourceRoot":"","sources":["../../src/hooks/onResponse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAI7D,eAAO,MAAM,iBAAiB,GAAI,UAAU,cAAc,EAAE,QAAQ,gBAAgB,KAAG,cAKtF,CAAC"}

package/server/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.server.d.ts","sourceRoot":"","sources":["../src/index.server.ts"],"names":[],"mappings":"AA4EA,QAAA,MAAQ,eAAe,sEAIrB,CAAC;AAEH,OAAO,EAAE,eAAe,EAAE,CAAC"}
+{"version":3,"file":"index.server.d.ts","sourceRoot":"","sources":["../src/index.server.ts"],"names":[],"mappings":"AA0CA,QAAA,MAAQ,eAAe,sEAIrB,CAAC;AAEH,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/server/index.js

@@ -3132,6 +3132,50 @@ const doHandlePayPalAddress = async (context, params) => {
     return { data: response };
 };
 
+/**
+ * Method getStorageMetadata - Fetches metadata for a storage item by its key.
+ *
+ * @param context
+ * @param params
+ * StorageMetadataData
+ *
+ * @returns
+ * StorageMetadataData
+ * @example
+ * ``` ts
+ * const { data } = await getStorageMetadata(() => useSdk().plentysystems.getStorageMetadata(params));
+ * ```
+ */
+const getStorageMetadata = async (context, params) => {
+    const url = new URL('rest/storefront/storage/metadata', context.config.api.url);
+    url.searchParams.set('key', params.key);
+    const { data } = await context.client.get(url.href);
+    return { data: data.data };
+};
+
+/**
+ * Method getStorageItems - Fetch storage items.
+ *
+ * @param context
+ * @param params
+ * StorageItemsParams
+ *
+ * @returns
+ * StorageObject[]
+ * @example
+ * ``` ts
+ * const { data } = await getStorageItems(() => useSdk().plentysystems.getStorageItems(params));
+ * ```
+ */
+const getStorageItems = async (context, params) => {
+    const url = new URL('rest/storefront/storage', context.config.api.url);
+    if (params.fileTypes) {
+        url.searchParams.set('fileTypes', params.fileTypes);
+    }
+    const { data } = await context.client.get(url.href);
+    return { data: data.data.objects };
+};
+
 var api = /*#__PURE__*/Object.freeze({
   __proto__: null,
   getProduct: getProduct,
@@ -3235,6 +3279,8 @@ var api = /*#__PURE__*/Object.freeze({
   getPackstations: getPackstations,
   doHandlePayPalPaymentFundingSources: doHandlePayPalPaymentFundingSources,
   getTranslations: getTranslations,
+  getStorageMetadata: getStorageMetadata,
+  getStorageItems: getStorageItems,
   doCreatePayPalOrder: doCreatePayPalOrder,
   doCreatePlentyPaymentFromPayPalOrder: doCreatePlentyPaymentFromPayPalOrder,
   getPayPalOrder: getPayPalOrder,
@@ -3243,206 +3289,157 @@ var api = /*#__PURE__*/Object.freeze({
   doHandlePayPalAddress: doHandlePayPalAddress
 });
 
-class HeaderSyncer {
-    constructor() {
-        this.responseHeaders = {};
-        this.requestHeaders = {};
-        this.headerWhitelist = ['x-csrf-token', 'set-cookie', 'cookie', 'x-config-id', 'x-pwa-edit-hash', 'locale'];
-        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 ?? '';
+const PlentyIdCookie = 'plentyID';
+const PwaSessionIdCookie = 'pwa-session-id';
+const FORWARD_HEADERS_KEYS = ['x-csrf-token', 'set-cookie', 'cookie', 'x-config-id', 'x-pwa-edit-hash', 'locale'];
+const changeHeaderValueKey = (value, oldKey, newKey) => {
+    if (!value) {
+        return '';
+    }
+    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 + '=');
+            }
+        });
     }
-    changeHeaderValueKey(value, oldKey, newKey) {
-        if (!value) {
-            return '';
-        }
-        if (Array.isArray(value)) {
-            value.forEach((cookie, key) => {
-                if (cookie.startsWith(newKey + '=')) {
-                    value.splice(key, 1);
+    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;
+};
+const lowerCaseAllHeaders = (headers) => {
+    return headers ? Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value])) : {};
+};
+const handleSessionCookie = (value) => {
+    return changeHeaderValueKey(value, PwaSessionIdCookie, PlentyIdCookie);
+};
+const handleSetCookie = (config, response) => {
+    const setCookieHeaderBlacklist = ['XSRF-TOKEN'];
+    if (!config._apiResponseHeaders)
+        return;
+    Object.entries(config._apiResponseHeaders).forEach(([key, value]) => {
+        if (FORWARD_HEADERS_KEYS.includes(key)) {
+            if (key === 'set-cookie') {
+                if (Array.isArray(value)) {
+                    value = value.map((setCookieHeader) => {
+                        return setCookieHeader.replace(/domain=[^;]+;/, '');
+                    }).filter((setCookieHeader) => {
+                        return !setCookieHeaderBlacklist.some((blacklistedHeader) => setCookieHeader.includes(blacklistedHeader));
+                    });
                 }
-                if (cookie.startsWith(oldKey + '=')) {
-                    value[key] = cookie.replace(oldKey + '=', newKey + '=');
+                else {
+                    value = value?.toString().replace(/domain=[^;]+;/, '');
                 }
-            });
-        }
-        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 + '=');
+                value = changeHeaderValueKey(value ?? '', PlentyIdCookie, PwaSessionIdCookie);
+                if (value) {
+                    response.setHeader(key, value.toString());
                 }
-                return cookie.trim();
-            });
-            value = newCookie.filter((str) => str.length > 0).join('; ');
+            }
+            else if (value) {
+                response.setHeader(key, value.toString());
+            }
         }
-        return value;
+    });
+};
+const addApiEventsToResponse = (config, response) => {
+    if (config._apiEvents && Object.keys(config._apiEvents).length > 0) {
+        if (response?.data && typeof response.data === 'object')
+            response.data.apiEvents = config._apiEvents;
     }
-    addRequestHeaders(request) {
-        Object.entries(this.requestHeaders).forEach(([key, value]) => {
-            if (this.headerWhitelist.includes(key)) {
-                if (key === 'cookie' && value) {
-                    value = this.changeHeaderValueKey(value, HeaderSyncer.PwaSessionIdCookie, HeaderSyncer.PlentyIdCookie);
+    return response;
+};
+
+const afterCallWrapper = (response, alokaiResponse, config) => {
+    handleSetCookie(config, alokaiResponse);
+    addApiEventsToResponse(config, response);
+    alokaiResponse.set('Access-Control-Expose-Headers', 'x-csrf-token');
+    return response;
+};
+
+const beforeCreateWrapper = (request, config) => {
+    config._middlewareRequestHeaders = lowerCaseAllHeaders(request.headers);
+    return config;
+};
+
+const onRequestWrapper = (request, config) => {
+    if (config._middlewareRequestHeaders) {
+        FORWARD_HEADERS_KEYS.forEach((key) => {
+            if (config._middlewareRequestHeaders && config._middlewareRequestHeaders[key]) {
+                if (key === 'cookie') {
+                    request.headers.cookie = handleSessionCookie(config._middlewareRequestHeaders[key]);
+                }
+                else {
+                    request.headers[key] = config._middlewareRequestHeaders[key];
                 }
-                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());
+    request.headers['x-security-token'] = config.api?.securityToken ?? '';
+    if (request.url) {
+        const url = new URL(request.url);
+        // { ReferrerID: 'referrerid }
+        // will set ReferrerID as url query parameter and use lowercase referrerid to get the value from the actual request headers
+        const queryParams = config.api?.queryParams || {
+            noCache: 'nocache',
+            ReferrerID: 'referrerid'
+        };
+        Object.entries(queryParams).forEach(([key, value]) => {
+            if (value) {
+                const headerValue = config._middlewareRequestHeaders?.[value];
+                if (headerValue) {
+                    url.searchParams.set(key, headerValue);
                 }
             }
         });
-        response.set('Access-Control-Expose-Headers', 'x-csrf-token');
-        this.clearHeaders();
-        return response;
+        request.url = url.toString();
     }
-}
-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 && request.url) {
-            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 && request.url) {
-            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';
+    if (config.api?.debug)
+        logRequest(request);
+    return request;
+};
 
-class ApiEventsSyncer {
-    constructor() {
-        this.eventStore = new Map();
-    }
-    storeApiEvents(events) {
-        this.eventStore.set('apiEvents', events);
-    }
-    getApiEvents() {
-        const events = this.eventStore.get('apiEvents');
-        return events && Object.keys(events).length > 0 ? events : null;
-    }
-    clearApiEvents() {
-        this.eventStore.delete('apiEvents');
-    }
-    addApiEventsToResponse(response) {
-        const apiEvents = this.getApiEvents();
-        if (apiEvents && response?.data && typeof response.data === 'object')
-            response.data.apiEvents = apiEvents;
-        this.clearApiEvents();
-        return response;
-    }
-}
+const onResponseWrapper = (response, config) => {
+    config._apiResponseHeaders = response.headers;
+    config._apiEvents = response.data?.events || undefined;
+    if (config.api?.debug)
+        logResponse(response);
+    return response;
+};
 
-const apiEventsSyncer = new ApiEventsSyncer();
-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 (response.data?.events)
-            apiEventsSyncer.storeApiEvents(response.data.events);
-        if (config.api.debug)
-            logResponse(response);
-        return response;
-    });
+    client.interceptors.request.use((request) => onRequestWrapper(request, config));
+    client.interceptors.response.use((response) => onResponseWrapper(response, config));
     return client;
 };
 const onCreate = (config) => {
     const client = buildClient(config);
-    return {
-        config,
-        client,
-    };
+    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;
+            return beforeCreateWrapper(req, configuration);
         },
-        afterCall: ({ response }) => {
-            headerSyncer.addResponseHeaders(res);
-            apiEventsSyncer.addApiEventsToResponse(response);
-            return response;
+        afterCall: ({ configuration, response }) => {
+            return afterCallWrapper(response, res, configuration);
         },
     }),
 };

package/server/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/server/types/api/storage.d.ts

@@ -0,0 +1,34 @@
+export interface StorageMetadataParams {
+    key: string;
+}
+export interface StorageMetadataData {
+    width: string;
+    height: string;
+}
+export interface StorageMetadataResponse {
+    events: [];
+    data: StorageMetadataData;
+}
+export interface StorageItemsParams {
+    fileTypes?: string;
+}
+export interface StorageObject {
+    key: string;
+    lastModified: string;
+    eTag: string;
+    size: string;
+    storageClass: string;
+    publicUrl: string;
+    previewUrl?: string;
+}
+export interface StorageItemData {
+    isTruncated: boolean;
+    nextContinuationToken: string;
+    commonPrefixes: string[];
+    objects: StorageObject[];
+}
+export interface StorageItemsResponse {
+    events: [];
+    data: StorageItemData;
+}
+//# sourceMappingURL=storage.d.ts.map

package/server/types/api/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../src/types/api/storage.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,EAAE,CAAC;IACX,IAAI,EAAE,mBAAmB,CAAC;CAC3B;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,OAAO,CAAC;IACrB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,OAAO,EAAE,aAAa,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,EAAE,CAAC;IACX,IAAI,EAAE,eAAe,CAAC;CACvB"}

package/server/types/config/index.d.ts

@@ -1,11 +1,22 @@
+import { PlentyEvents } from '../api';
 /**
  * Settings to be provided in the `middleware.config.js` file.
  */
 export interface MiddlewareConfig {
     api: {
         url: string;
-        securityToken: string;
+        securityToken: string | undefined;
         debug?: boolean;
+        queryParams?: {
+            [key: string]: string | null | undefined;
+        };
     };
+    _middlewareRequestHeaders?: {
+        [key: string]: string | undefined;
+    };
+    _apiResponseHeaders?: {
+        [key: string]: string | string[] | undefined;
+    };
+    _apiEvents?: PlentyEvents | undefined;
 }
 //# sourceMappingURL=index.d.ts.map

package/server/types/config/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/config/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE;QACH,GAAG,EAAE,MAAM,CAAC;QACZ,aAAa,EAAE,MAAM,CAAC;QACtB,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB,CAAC;CACH"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE;QACH,GAAG,EAAE,MAAM,CAAC;QACZ,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;QAClC,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,WAAW,CAAC,EAAG;YACb,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;SAC1C,CAAA;KACF,CAAC;IACF,yBAAyB,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;IAClE,mBAAmB,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAG,GAAG,SAAS,CAAA;KAAE,CAAC;IACxE,UAAU,CAAC,EAAE,YAAY,GAAG,SAAS,CAAC;CACvC"}

package/lib/helpers/api-events-syncer.d.ts

@@ -1,10 +0,0 @@
-import { AfterCallArgs } from '@vue-storefront/middleware';
-import { PlentyEvents } from 'src/types';
-export declare class ApiEventsSyncer {
-    private eventStore;
-    storeApiEvents(events: PlentyEvents): void;
-    getApiEvents(): PlentyEvents | null;
-    clearApiEvents(): void;
-    addApiEventsToResponse(response: AfterCallArgs): Response;
-}
-//# sourceMappingURL=api-events-syncer.d.ts.map

package/lib/helpers/api-events-syncer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api-events-syncer.d.ts","sourceRoot":"","sources":["../../src/helpers/api-events-syncer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC,qBAAa,eAAe;IAC1B,OAAO,CAAC,UAAU,CAAmC;IAErD,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAI1C,YAAY,IAAI,YAAY,GAAG,IAAI;IAMnC,cAAc,IAAI,IAAI;IAItB,sBAAsB,CAAC,QAAQ,EAAE,aAAa,GAAG,QAAQ;CAO1D"}

package/lib/helpers/header-syncer.d.ts

@@ -1,24 +0,0 @@
-import { AxiosHeaderValue, AxiosResponseHeaders, InternalAxiosRequestConfig, RawAxiosResponseHeaders } from 'axios';
-import { MiddlewareConfig } from '../types';
-import type { Response } from 'express';
-export declare class HeaderSyncer {
-    static PlentyIdCookie: string;
-    static PwaSessionIdCookie: string;
-    constructor();
-    responseHeaders: {
-        [key: string]: AxiosHeaderValue | undefined;
-    };
-    requestHeaders: {
-        [key: string]: AxiosHeaderValue | undefined;
-    };
-    headerWhitelist: string[];
-    setCookieHeaderBlacklist: string[];
-    clearHeaders(): void;
-    storeResponseHeaders(headers: RawAxiosResponseHeaders | AxiosResponseHeaders): void;
-    storeRequestHeaders(headers: RawAxiosResponseHeaders | AxiosResponseHeaders): void;
-    addSecurityHeaders(request: InternalAxiosRequestConfig, config: MiddlewareConfig): void;
-    changeHeaderValueKey(value: AxiosHeaderValue, oldKey: string, newKey: string): string | string[];
-    addRequestHeaders(request: InternalAxiosRequestConfig): void;
-    addResponseHeaders(response: Response): Response;
-}
-//# sourceMappingURL=header-syncer.d.ts.map

package/lib/helpers/header-syncer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"header-syncer.d.ts","sourceRoot":"","sources":["../../src/helpers/header-syncer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,0BAA0B,EAAE,uBAAuB,EAAE,MAAM,OAAO,CAAC;AACpH,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,qBAAa,YAAY;IAEvB,MAAM,CAAC,cAAc,SAAc;IACnC,MAAM,CAAC,kBAAkB,SAAoB;;IAI7C,eAAe,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAAA;KAAC,CAAM;IACpE,cAAc,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAAA;KAAC,CAAM;IACnE,eAAe,WAAwF;IACvG,wBAAwB,WAAkB;IAE1C,YAAY,IAAI,IAAI;IAKpB,oBAAoB,CAAC,OAAO,EAAE,uBAAuB,GAAG,oBAAoB,GAAG,IAAI;IAKnF,mBAAmB,CAAC,OAAO,EAAE,uBAAuB,GAAG,oBAAoB,GAAG,IAAI;IAIlF,kBAAkB,CAAC,OAAO,EAAE,0BAA0B,EAAE,MAAM,EAAE,gBAAgB,GAAG,IAAI;IAIvF,oBAAoB,CAAC,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE;IAiChG,iBAAiB,CAAC,OAAO,EAAE,0BAA0B,GAAG,IAAI;IAW5D,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ;CA8BjD"}

package/lib/helpers/noCacheSyncer.d.ts

@@ -1,10 +0,0 @@
-import { AxiosResponseHeaders, InternalAxiosRequestConfig, RawAxiosResponseHeaders } from 'axios';
-export declare class NoCacheSyncer {
-    static HeaderNoCacheKey: string;
-    static APINoCacheKey: string;
-    constructor();
-    private noCacheValue;
-    storeNoCacheValue(headers: RawAxiosResponseHeaders | AxiosResponseHeaders): void;
-    addNoCacheToUrl(request: InternalAxiosRequestConfig): void;
-}
-//# sourceMappingURL=noCacheSyncer.d.ts.map

package/lib/helpers/noCacheSyncer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"noCacheSyncer.d.ts","sourceRoot":"","sources":["../../src/helpers/noCacheSyncer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC1B,uBAAuB,EACxB,MAAM,OAAO,CAAC;AAEf,qBAAa,aAAa;IACxB,MAAM,CAAC,gBAAgB,SAAa;IACpC,MAAM,CAAC,aAAa,SAAa;;IAIjC,OAAO,CAAC,YAAY,CAAuB;IAE3C,iBAAiB,CACf,OAAO,EAAE,uBAAuB,GAAG,oBAAoB,GACtD,IAAI;IAIP,eAAe,CAAC,OAAO,EAAE,0BAA0B,GAAG,IAAI;CAc3D"}

package/lib/helpers/referrerSyncer.d.ts

@@ -1,10 +0,0 @@
-import { AxiosResponseHeaders, InternalAxiosRequestConfig, RawAxiosResponseHeaders } from 'axios';
-export declare class ReferrerSyncer {
-    static HeaderReferrerKey: string;
-    static APIReferrerKey: string;
-    constructor();
-    private requestReferrerID;
-    storeRequestReferrerHeader(headers: RawAxiosResponseHeaders | AxiosResponseHeaders): void;
-    addReferrerToUrl(request: InternalAxiosRequestConfig): void;
-}
-//# sourceMappingURL=referrerSyncer.d.ts.map