@scayle/storefront-core 7.22.1

package/dist/helpers/advancedAttributeHelpers.mjs

@@ -0,0 +1,21 @@
+import { flattenDeep } from "./arrayHelpers.mjs";
+import { flattenObject } from "./objectHelpers.mjs";
+export const flattenFieldSet = (fieldSet) => {
+  return fieldSet.map(flattenObject);
+};
+export const getFlattenedMaterialComposition = (materialCompositions) => {
+  return materialCompositions.map((materialComposition) => ({
+    ...flattenDeep(flattenFieldSet(materialComposition.fieldSet))[0],
+    values: flattenDeep(
+      materialComposition.groupSet.map((g) => flattenFieldSet(g.fieldSet))
+    )
+  }));
+};
+export const getFlattenedVariantCrosssellings = (variantCrosssellings) => {
+  return variantCrosssellings.map((variantCrossselling) => ({
+    ...flattenDeep(flattenFieldSet(variantCrossselling.fieldSet))[0],
+    values: flattenDeep(
+      variantCrossselling.groupSet.map((g) => flattenFieldSet(g.fieldSet))
+    )
+  }));
+};

package/dist/helpers/arrayHelpers.cjs

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.flattenDeep = void 0;
+const flattenDeep = array => {
+  return array.flat(Infinity);
+};
+exports.flattenDeep = flattenDeep;

package/dist/helpers/arrayHelpers.d.ts

@@ -0,0 +1 @@
+export declare const flattenDeep: <T extends unknown[]>(array: T) => (T extends readonly (infer InnerArr)[] ? InnerArr extends readonly (infer InnerArr)[] ? InnerArr extends readonly (infer InnerArr)[] ? InnerArr extends readonly (infer InnerArr)[] ? InnerArr extends readonly (infer InnerArr)[] ? InnerArr extends readonly (infer InnerArr)[] ? InnerArr extends readonly (infer InnerArr)[] ? InnerArr extends readonly (infer InnerArr)[] ? InnerArr extends readonly (infer InnerArr)[] ? InnerArr extends readonly (infer InnerArr)[] ? InnerArr extends readonly (infer InnerArr)[] ? any : InnerArr : InnerArr : InnerArr : InnerArr : InnerArr : InnerArr : InnerArr : InnerArr : InnerArr : InnerArr : T)[];

package/dist/helpers/arrayHelpers.mjs

@@ -0,0 +1,3 @@
+export const flattenDeep = (array) => {
+  return array.flat(Infinity);
+};

package/dist/helpers/attributeHelpers.cjs

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getManyAttributeValueTuples = exports.getFirstAttributeValue = exports.getAttributeValueTuples = exports.getAttributeValue = void 0;
+var _backbone = require("@aboutyou/backbone");
+const getFirstAttributeValue = (attributes, attributeName) => {
+  return (0, _backbone.getFirstAttributeValue)(attributes, attributeName);
+};
+exports.getFirstAttributeValue = getFirstAttributeValue;
+const getAttributeValue = (attributes, attributeName) => {
+  const values = getFirstAttributeValue(attributes, attributeName);
+  return values?.value ?? values?.label;
+};
+exports.getAttributeValue = getAttributeValue;
+const getAttributeValueTuples = (attributes, attributeName) => {
+  return (0, _backbone.getAttributeValues)(attributes, attributeName);
+};
+exports.getAttributeValueTuples = getAttributeValueTuples;
+const getManyAttributeValueTuples = (attributes, attributeNames) => {
+  return attributeNames.map(key => getFirstAttributeValue(attributes, key)).filter(entry => !!entry);
+};
+exports.getManyAttributeValueTuples = getManyAttributeValueTuples;

package/dist/helpers/attributeHelpers.d.ts

@@ -0,0 +1,5 @@
+import type { Attributes } from '@aboutyou/backbone/types/BapiProduct';
+export declare const getFirstAttributeValue: (attributes: Attributes | undefined, attributeName: string) => import("@aboutyou/backbone").Value | undefined;
+export declare const getAttributeValue: (attributes: Attributes | undefined, attributeName: string) => string | undefined;
+export declare const getAttributeValueTuples: (attributes: Attributes | undefined, attributeName: string) => import("@aboutyou/backbone").Value[];
+export declare const getManyAttributeValueTuples: (attributes: Attributes | undefined, attributeNames: string[]) => (import("@aboutyou/backbone").Value | undefined)[];

package/dist/helpers/attributeHelpers.mjs

@@ -0,0 +1,17 @@
+import {
+  getAttributeValues as _getAttributeValues,
+  getFirstAttributeValue as _getFirstAttributeValue
+} from "@aboutyou/backbone";
+export const getFirstAttributeValue = (attributes, attributeName) => {
+  return _getFirstAttributeValue(attributes, attributeName);
+};
+export const getAttributeValue = (attributes, attributeName) => {
+  const values = getFirstAttributeValue(attributes, attributeName);
+  return values?.value ?? values?.label;
+};
+export const getAttributeValueTuples = (attributes, attributeName) => {
+  return _getAttributeValues(attributes, attributeName);
+};
+export const getManyAttributeValueTuples = (attributes, attributeNames) => {
+  return attributeNames.map((key) => getFirstAttributeValue(attributes, key)).filter((entry) => !!entry);
+};

package/dist/helpers/autobind.cjs

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.autobind = autobind;
+const getAllProperties = obj => {
+  const properties = /* @__PURE__ */new Set();
+  if (!obj) {
+    return properties;
+  }
+  do {
+    for (const key of Reflect.ownKeys(obj)) {
+      properties.add([obj, key]);
+    }
+  } while ((obj = Reflect.getPrototypeOf(obj)) && obj !== Object.prototype);
+  return properties;
+};
+function autobind(self, {
+  include,
+  exclude
+} = {}) {
+  const filter = key => {
+    const match = pattern => typeof pattern === "string" ? key === pattern : pattern.test(key);
+    if (include) {
+      return include.some(match);
+    }
+    if (exclude) {
+      return !exclude.some(match);
+    }
+    return true;
+  };
+  for (const it of getAllProperties(self.constructor.prototype)) {
+    const [object, key] = it;
+    if (key === "constructor" || !filter(key)) {
+      continue;
+    }
+    const descriptor = Reflect.getOwnPropertyDescriptor(object, key);
+    if (descriptor && typeof descriptor.value === "function") {
+      self[key] = self[key].bind(self);
+    }
+  }
+  return self;
+}

package/dist/helpers/autobind.d.ts

@@ -0,0 +1,39 @@
+type Options = Partial<{
+    readonly include: ReadonlyArray<string | RegExp>;
+    readonly exclude: ReadonlyArray<string | RegExp>;
+}>;
+/**
+ * Automatically bind methods to their class instance.
+ * @param self - An object with methods to bind.
+ * @example
+  ```
+  import { autobind } from '@scayle/storefront-core'
+
+  class Unicorn {
+    constructor(name) {
+      this.name = name;
+      autobind(this);
+    }
+
+    message() {
+      return `${this.name} is awesome!`;
+    }
+  }
+
+  const unicorn = new Unicorn('Rainbow');
+
+  // Grab the method off the class instance
+  const message = unicorn.message;
+
+  // Still bound to the class instance
+  message();
+  // => 'Rainbow is awesome!'
+
+  // Without `autobind(this)`, the above would have resulted in
+
+  message();
+  //=> Error: Cannot read property 'name' of undefined
+  ```
+*/
+export declare function autobind<SelfType extends Record<string, any>>(self: SelfType, { include, exclude }?: Options): SelfType;
+export {};

package/dist/helpers/autobind.mjs

@@ -0,0 +1,35 @@
+const getAllProperties = (obj) => {
+  const properties = /* @__PURE__ */ new Set();
+  if (!obj) {
+    return properties;
+  }
+  do {
+    for (const key of Reflect.ownKeys(obj)) {
+      properties.add([obj, key]);
+    }
+  } while ((obj = Reflect.getPrototypeOf(obj)) && obj !== Object.prototype);
+  return properties;
+};
+export function autobind(self, { include, exclude } = {}) {
+  const filter = (key) => {
+    const match = (pattern) => typeof pattern === "string" ? key === pattern : pattern.test(key);
+    if (include) {
+      return include.some(match);
+    }
+    if (exclude) {
+      return !exclude.some(match);
+    }
+    return true;
+  };
+  for (const it of getAllProperties(self.constructor.prototype)) {
+    const [object, key] = it;
+    if (key === "constructor" || !filter(key)) {
+      continue;
+    }
+    const descriptor = Reflect.getOwnPropertyDescriptor(object, key);
+    if (descriptor && typeof descriptor.value === "function") {
+      self[key] = self[key].bind(self);
+    }
+  }
+  return self;
+}

package/dist/helpers/basketHelpers.cjs

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getShippingDates = void 0;
+const getShippingDates = packages => {
+  const min = packages.map(p => p.deliveryDate.min).sort();
+  const max = packages.map(p => p.deliveryDate.max).sort();
+  return [min?.[0] || null, max?.[max.length - 1] || null];
+};
+exports.getShippingDates = getShippingDates;

package/dist/helpers/basketHelpers.d.ts

@@ -0,0 +1,2 @@
+import type { BasketPackageInformation } from '@aboutyou/backbone/endpoints/basket/getBasket';
+export declare const getShippingDates: (packages: BasketPackageInformation[]) => (string | null)[];

package/dist/helpers/basketHelpers.mjs

@@ -0,0 +1,5 @@
+export const getShippingDates = (packages) => {
+  const min = packages.map((p) => p.deliveryDate.min).sort();
+  const max = packages.map((p) => p.deliveryDate.max).sort();
+  return [min?.[0] || null, max?.[max.length - 1] || null];
+};

package/dist/helpers/categoryHelper.cjs

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBreadcrumbsFromProductCategories = exports.getBreadcrumbsFromPath = exports.getBreadcrumbsFromCategory = exports.getBreadcrumbs = exports.getBackurlFromBreadcrumbs = void 0;
+var _sanitizationHelpers = require("./sanitizationHelpers.cjs");
+const getBreadcrumbsFromProductCategories = categories => {
+  return categories?.map(category => ({
+    value: "categoryName" in category ? category.categoryName : category.name,
+    to: "categoryName" in category ? category.categoryUrl : category.slug
+  })) || [];
+};
+exports.getBreadcrumbsFromProductCategories = getBreadcrumbsFromProductCategories;
+const getBreadcrumbsFromCategory = (category, activeNode) => {
+  if (!category) {
+    return [];
+  }
+  const breadcrumbItems = [];
+  const generateBreadcrumbs = category2 => {
+    if (category2.children?.length || activeNode?.id === category2.id) {
+      breadcrumbItems.push({
+        value: category2.name,
+        to: category2.path
+      });
+      category2?.children?.forEach(child => generateBreadcrumbs(child));
+    }
+  };
+  generateBreadcrumbs(category);
+  return breadcrumbItems;
+};
+exports.getBreadcrumbsFromCategory = getBreadcrumbsFromCategory;
+const getBreadcrumbsFromPath = (path = "", shopLocale = "") => {
+  if (shopLocale) {
+    path = (0, _sanitizationHelpers.stripShopLocaleFromPath)(shopLocale, path);
+  }
+  const breadcrumbItems = [];
+  path.split("/").forEach((segment, index) => {
+    if (!segment) {
+      breadcrumbItems.push({
+        to: "/",
+        value: "Home"
+      });
+    } else {
+      breadcrumbItems.push({
+        to: breadcrumbItems[index - 1].to === "/" ? `/${segment}` : `${breadcrumbItems[index - 1].to}/${segment}`,
+        value: segment
+      });
+    }
+  });
+  return breadcrumbItems;
+};
+exports.getBreadcrumbsFromPath = getBreadcrumbsFromPath;
+const getBreadcrumbs = (categories, activeNode) => {
+  return Array.isArray(categories) ? getBreadcrumbsFromProductCategories(categories) : getBreadcrumbsFromCategory(categories, activeNode);
+};
+exports.getBreadcrumbs = getBreadcrumbs;
+const getBackurlFromBreadcrumbs = breadcrumbs => {
+  return breadcrumbs?.[breadcrumbs?.length - 1].to ?? "/";
+};
+exports.getBackurlFromBreadcrumbs = getBackurlFromBreadcrumbs;

package/dist/helpers/categoryHelper.d.ts

@@ -0,0 +1,7 @@
+import type { Category, ProductCategory } from '../types/bapi/category';
+import { BreadcrumbItem } from '../types/breadcrumb';
+export declare const getBreadcrumbsFromProductCategories: (categories: ProductCategory[] | Category[]) => BreadcrumbItem[];
+export declare const getBreadcrumbsFromCategory: (category: Category, activeNode?: Category) => BreadcrumbItem[];
+export declare const getBreadcrumbsFromPath: (path?: string, shopLocale?: string) => BreadcrumbItem[];
+export declare const getBreadcrumbs: (categories: ProductCategory[] | Category, activeNode?: Category) => BreadcrumbItem[];
+export declare const getBackurlFromBreadcrumbs: (breadcrumbs?: BreadcrumbItem[]) => string;

package/dist/helpers/categoryHelper.mjs

@@ -0,0 +1,44 @@
+import { stripShopLocaleFromPath } from "./sanitizationHelpers.mjs";
+export const getBreadcrumbsFromProductCategories = (categories) => {
+  return categories?.map((category) => ({
+    value: "categoryName" in category ? category.categoryName : category.name,
+    to: "categoryName" in category ? category.categoryUrl : category.slug
+  })) || [];
+};
+export const getBreadcrumbsFromCategory = (category, activeNode) => {
+  if (!category) {
+    return [];
+  }
+  const breadcrumbItems = [];
+  const generateBreadcrumbs = (category2) => {
+    if (category2.children?.length || activeNode?.id === category2.id) {
+      breadcrumbItems.push({ value: category2.name, to: category2.path });
+      category2?.children?.forEach((child) => generateBreadcrumbs(child));
+    }
+  };
+  generateBreadcrumbs(category);
+  return breadcrumbItems;
+};
+export const getBreadcrumbsFromPath = (path = "", shopLocale = "") => {
+  if (shopLocale) {
+    path = stripShopLocaleFromPath(shopLocale, path);
+  }
+  const breadcrumbItems = [];
+  path.split("/").forEach((segment, index) => {
+    if (!segment) {
+      breadcrumbItems.push({ to: "/", value: "Home" });
+    } else {
+      breadcrumbItems.push({
+        to: breadcrumbItems[index - 1].to === "/" ? `/${segment}` : `${breadcrumbItems[index - 1].to}/${segment}`,
+        value: segment
+      });
+    }
+  });
+  return breadcrumbItems;
+};
+export const getBreadcrumbs = (categories, activeNode) => {
+  return Array.isArray(categories) ? getBreadcrumbsFromProductCategories(categories) : getBreadcrumbsFromCategory(categories, activeNode);
+};
+export const getBackurlFromBreadcrumbs = (breadcrumbs) => {
+  return breadcrumbs?.[breadcrumbs?.length - 1].to ?? "/";
+};

package/dist/helpers/filterHelper.cjs

@@ -0,0 +1,156 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformToWhereCondition = exports.transformStateToFilters = exports.transformSortToFilter = exports.transformMinAndMaxPriceToFilter = exports.serializeFilters = exports.mergeFilters = exports.isFilterActive = exports.groupFiltersByKey = exports.groupFilterableValuesByKey = exports.getGroupedFilterableValues = exports.getFilterablePriceValue = exports.getActiveFilters = exports.deserializeFilters = void 0;
+var _backbone = require("@aboutyou/backbone");
+var _radash = require("radash");
+var _sortingHelper = require("./sortingHelper.cjs");
+const transformToWhereCondition = conditions => {
+  const where = {
+    attributes: []
+  };
+  Object.keys(conditions).forEach(key => {
+    const value = conditions[key];
+    if (["sort", "term"].includes(key)) {
+      return;
+    }
+    if (key === "minPrice" || key === "maxPrice") {
+      where[key] = value;
+      return;
+    }
+    const condition = ["true", "false"].includes(value) ? {
+      key,
+      type: "boolean",
+      value: value === "true"
+    } : {
+      key,
+      type: "attributes",
+      values: Array.isArray(conditions[key]) ? conditions[key] : [conditions[key]]
+    };
+    where.attributes.push(condition);
+  });
+  return where;
+};
+exports.transformToWhereCondition = transformToWhereCondition;
+const groupFilterableValuesByKey = (filters, filterableKeys) => {
+  const enabledFilters = filterableKeys ? filters.filter(filter => filterableKeys.includes(filter.slug)) : filters;
+  const availableFilters = [];
+  enabledFilters.forEach(filter => {
+    ;
+    filter.values.forEach(value => {
+      if (filter.type === "boolean" && value.name === false) {
+        return;
+      }
+      const filterValue = _getFilterValueByType(value, filter.type);
+      availableFilters.push({
+        key: filter.slug,
+        displayName: filter.type === "boolean" ? filter.name : value.name,
+        count: value.productCount,
+        value: filterValue,
+        whereCondition: {
+          [filter.slug]: filterValue
+        }
+      });
+    });
+  });
+  return availableFilters.sort((a, b) => a.displayName < b.displayName ? -1 : 1);
+};
+exports.groupFilterableValuesByKey = groupFilterableValuesByKey;
+const transformStateToFilters = state => {
+  return Object.values(state).reduce((objectToReturn, filter) => Object.assign(objectToReturn, generateFilterKeyAndValue(filter)), {});
+};
+exports.transformStateToFilters = transformStateToFilters;
+const generateFilterKeyAndValue = filter => {
+  return filter.reduce((objectToReturn, f) => Object.assign(objectToReturn, objectToReturn[f.key] ? objectToReturn[f.key].push(f.value) : {
+    [f.key]: [f.value]
+  }), {});
+};
+const mergeFilters = filters => {
+  const mergedFilter = {};
+  filters.forEach(item => {
+    if (!mergedFilter[item.key]) {
+      mergedFilter[item.key] = item.value;
+    } else {
+      mergedFilter[item.key] = [mergedFilter[item.key], item.value].flat();
+    }
+  });
+  return mergedFilter;
+};
+exports.mergeFilters = mergeFilters;
+const getActiveFilters = (filters, activeFilters) => {
+  return [].concat(...Object.values(filters)).filter(item => isFilterActive(activeFilters, item)) || [];
+};
+exports.getActiveFilters = getActiveFilters;
+const groupFiltersByKey = filters => {
+  return Object.entries((0, _radash.group)(filters, it => it.key));
+};
+exports.groupFiltersByKey = groupFiltersByKey;
+const transformMinAndMaxPriceToFilter = prices => {
+  const [min = 0, max = 1e5] = prices;
+  return {
+    minPrice: min,
+    maxPrice: max
+  };
+};
+exports.transformMinAndMaxPriceToFilter = transformMinAndMaxPriceToFilter;
+const transformSortToFilter = sort => {
+  return (0, _sortingHelper.getSortByValue)(sort);
+};
+exports.transformSortToFilter = transformSortToFilter;
+const getGroupedFilterableValues = (keys, filterableValues) => {
+  return keys.reduce((acc, key) => {
+    acc[key] = groupFilterableValuesByKey(filterableValues, [key]);
+    return acc;
+  }, {});
+};
+exports.getGroupedFilterableValues = getGroupedFilterableValues;
+const isFilterActive = (filters, filterToCheck) => {
+  const key = filterToCheck.key;
+  return filters[key] && (filters[key].toString() === filterToCheck.value.toString() || Array.isArray(filters[key]) && filters[key].includes(filterToCheck.value));
+};
+exports.isFilterActive = isFilterActive;
+const getFilterablePriceValue = (filterableValues, key = "min") => {
+  const prices = filterableValues.prices[0];
+  if (!prices) {
+    return key === "min" ? 0 : 1e4;
+  }
+  return prices.value[key];
+};
+exports.getFilterablePriceValue = getFilterablePriceValue;
+const _getFilterValueByType = (value, type) => {
+  switch (type) {
+    case _backbone.FilterTypes.BOOLEAN:
+      return value.name;
+    case _backbone.FilterTypes.RANGE:
+      return {
+        min: value.min,
+        max: value.max
+      };
+    default:
+      return value.id;
+  }
+};
+const serializeFilters = filter => {
+  if ((0, _radash.isEmpty)(filter)) {
+    return void 0;
+  }
+  return Object.assign({}, ...Object.entries(filter).map(([filterName, filterValue]) => ({
+    [filterName]: Array.isArray(filterValue) ? filterValue.join(",") : String(filterValue)
+  })));
+};
+exports.serializeFilters = serializeFilters;
+const deserializeFilters = serializedFilter => {
+  const toNumberIfNumeric = value => {
+    const number = +value;
+    if (!isNaN(number)) {
+      return number;
+    }
+    return value;
+  };
+  return Object.assign({}, ...Object.entries(serializedFilter).map(([filterName, filterValue]) => ({
+    [filterName]: typeof filterValue === "string" && filterValue.includes(",") ? filterValue.split(",").map(toNumberIfNumeric) : toNumberIfNumeric(filterValue)
+  })));
+};
+exports.deserializeFilters = deserializeFilters;

package/dist/helpers/filterHelper.d.ts

@@ -0,0 +1,82 @@
+import type { ProductSearchQuery } from '@aboutyou/backbone/types/ProductSearchQuery';
+import type { CentAmount } from '@aboutyou/backbone/types/BapiProduct';
+import type { ProductFilter } from '../types';
+export type TransformedFilter = {
+    key: string;
+    displayName: string;
+    count: number;
+    value: string | number;
+    whereCondition: Record<string, any>;
+};
+export declare const transformToWhereCondition: (conditions: Record<string, any>) => {
+    minPrice?: ProductSearchQuery['minPrice'];
+    maxPrice?: ProductSearchQuery['maxPrice'];
+    attributes: ProductSearchQuery['attributes'];
+};
+/**
+ * Compute an array of filters that can be used to render the quick filters, for example.
+ *
+ * This method transforms attribute filters with multiple possible values into a flattened
+ * list of filters with one filter entry per possible attribute value
+ *
+ * By providing filterableKeys you can limit the generated list of filters to specific
+ * keys you would like to filter by.
+ *
+ * @param filters
+ * @param filterableKeys
+ */
+export declare const groupFilterableValuesByKey: (filters: ProductFilter[], filterableKeys?: Array<string>) => Array<TransformedFilter>;
+export declare const transformStateToFilters: (state: {
+    [key: string]: TransformedFilter[];
+}) => any;
+export declare const mergeFilters: (filters: TransformedFilter[]) => Record<string, any>;
+export declare const getActiveFilters: (filters: Record<string, any>, activeFilters: Record<string, any>) => TransformedFilter[];
+export declare const groupFiltersByKey: (filters: TransformedFilter[]) => any[];
+export declare const transformMinAndMaxPriceToFilter: (prices: (CentAmount | undefined)[]) => any;
+export declare const transformSortToFilter: (sort: string) => {
+    by: import("@aboutyou/backbone").APISortOption;
+    direction: import("@aboutyou/backbone").APISortOrder;
+    name: "topseller";
+    query: "topseller";
+} | {
+    by: import("@aboutyou/backbone").APISortOption;
+    name: "date_newest";
+    query: "date-newest";
+} | {
+    by: import("@aboutyou/backbone").APISortOption;
+    direction: import("@aboutyou/backbone").APISortOrder;
+    name: "price_desc";
+    query: "price-desc";
+} | {
+    by: import("@aboutyou/backbone").APISortOption;
+    direction: import("@aboutyou/backbone").APISortOrder;
+    name: "price_asc";
+    query: "price-asc";
+} | {
+    by: import("@aboutyou/backbone").APISortOption;
+    direction: import("@aboutyou/backbone").APISortOrder;
+    name: "reduction_desc";
+    query: "reduction-desc";
+} | {
+    by: import("@aboutyou/backbone").APISortOption;
+    direction: import("@aboutyou/backbone").APISortOrder;
+    name: "reduction_asc";
+    query: "reduction-asc";
+};
+export declare const getGroupedFilterableValues: (keys: Array<string>, filterableValues: ProductFilter[]) => Record<string, any>;
+export declare const isFilterActive: (filters: Record<string, any>, filterToCheck: TransformedFilter) => any;
+export declare const getFilterablePriceValue: (filterableValues: Record<string, any>, key?: 'min' | 'max') => any;
+export type SerializedFilter = Record<string, string>;
+export type Filter = Record<string, string | number | (string | number | null)[]>;
+/**
+ * Converts filter values, within a filter object, into their string representation.
+ *
+ * @param filter
+ */
+export declare const serializeFilters: (filter: Filter) => SerializedFilter;
+/**
+ * Converts filter values back into their original data type.
+ *
+ * @param filters
+ */
+export declare const deserializeFilters: (serializedFilter: SerializedFilter) => Filter;