@wix/headless-stores 0.0.57 → 0.0.58

package/dist/services/products-list-search-service.js

@@ -1,9 +1,8 @@
 import { defineService, implementService } from '@wix/services-definitions';
 import { SignalsServiceDefinition } from '@wix/services-definitions/core-services/signals';
-import { DEFAULT_QUERY_LIMIT, ProductsListServiceDefinition, } from './products-list-service.js';
+import { DEFAULT_QUERY_LIMIT } from './products-list-service.js';
 import { productsV3, customizationsV3 } from '@wix/stores';
 import { loadCategoriesListServiceConfig } from './categories-list-service.js';
-const PRICE_FILTER_DEBOUNCE_TIME = 300;
 import { SortType } from './../enums/sort-enums.js';
 export { SortType } from './../enums/sort-enums.js';
 /**
@@ -61,6 +60,7 @@ export function convertUrlSortToSortType(urlSort) {
 /**
  * Update URL with current search state (sort, filters, pagination)
  */
+//@ts-expect-error
 function updateUrlWithSearchState(searchState) {
     if (typeof window === 'undefined')
         return;
@@ -190,13 +190,9 @@ function updateUrlWithSearchState(searchState) {
  * const filterState = initialSearchState.productOptions; // { colorId: ['red-id', 'blue-id'] }
  * ```
  */
-export async function parseUrlToSearchOptions(url, categoriesList, defaultSearchOptions) {
+export async function parseUrlToSearchOptions(url, categoriesList, customizations, defaultSearchOptions) {
     const urlObj = new URL(url);
     const searchParams = urlObj.searchParams;
-    // Get customizations for product option parsing
-    const { items: customizations = [] } = await customizationsV3
-        .queryCustomizations()
-        .find();
     // Build search options
     const searchOptions = {
         cursorPaging: {
@@ -325,6 +321,12 @@ export async function parseUrlToSearchOptions(url, categoriesList, defaultSearch
             }
         }
     }
+    const inventoryStatus = searchParams.get('inventoryStatus');
+    if (inventoryStatus) {
+        filter['inventory.availabilityStatus'] = {
+            $in: inventoryStatus.split(','),
+        };
+    }
     // Parse product options from URL parameters
     const reservedParams = [
         'minPrice',
@@ -358,15 +360,15 @@ export async function parseUrlToSearchOptions(url, categoriesList, defaultSearch
             }
             if (choiceIds.length > 0) {
                 productOptionsById[option._id] = choiceIds;
-                // Add product option filter to search options
-                filter[`options.choicesSettings.choices.choiceId`] = {
-                    $hasSome: choiceIds,
-                };
             }
         }
     }
     if (Object.keys(productOptionsById).length > 0) {
         initialSearchState.productOptions = productOptionsById;
+        // Add product option filter to search options
+        filter[`options.choicesSettings.choices.choiceId`] = {
+            $hasSome: Object.values(productOptionsById).flat(),
+        };
     }
     // Add filter to search options if any filters were set
     if (Object.keys(filter).length > 0) {
@@ -459,442 +461,47 @@ export async function loadProductsListSearchServiceConfig(input) {
     if (typeof input === 'string') {
         // URL input - parse it
         const categoriesListConfig = await loadCategoriesListServiceConfig();
-        const { initialSearchState: parsedState } = await parseUrlToSearchOptions(input, categoriesListConfig.categories);
+        const { items: customizations = [] } = await customizationsV3
+            .queryCustomizations()
+            .find();
+        const { initialSearchState: parsedState } = await parseUrlToSearchOptions(input, categoriesListConfig.categories, customizations);
         initialSearchState = parsedState;
     }
     else {
         // Parsed URL result - use initialSearchState directly (no duplicate work)
         initialSearchState = input.initialSearchState;
     }
-    const { items: customizations = [] } = await customizationsV3
-        .queryCustomizations()
-        .find();
     return {
-        customizations,
         initialSearchState,
     };
 }
 /**
  * Implementation of the Products List Search service
  */
-export const ProductsListSearchService = implementService.withConfig()(ProductsListSearchServiceDefinition, ({ getService, config }) => {
+export const ProductsListSearchService = implementService.withConfig()(ProductsListSearchServiceDefinition, ({ getService }) => {
     let firstRun = true;
     const signalsService = getService(SignalsServiceDefinition);
-    const productsListService = getService(ProductsListServiceDefinition);
-    const { customizations, initialSearchState } = config;
-    const aggregationData = productsListService.aggregations.get()?.results;
-    const currentSearchOptions = productsListService.searchOptions.get();
-    // Sort signals
-    const selectedSortOptionSignal = signalsService.signal(initialSearchState?.sort || SortType.NAME_ASC);
-    // Pagination signals
-    const currentLimitSignal = signalsService.signal(initialSearchState?.limit || getCurrentLimit(currentSearchOptions));
-    const currentCursorSignal = signalsService.signal(initialSearchState?.cursor || getCurrentCursor(currentSearchOptions));
-    // Filter signals
-    const catalogPriceRange = getCatalogPriceRange(aggregationData || []);
-    const userFilterMinPriceSignal = signalsService.signal(initialSearchState?.priceRange?.min ?? catalogPriceRange.minPrice);
-    const userFilterMaxPriceSignal = signalsService.signal(initialSearchState?.priceRange?.max ?? catalogPriceRange.maxPrice);
-    const catalogMinPriceSignal = signalsService.signal(catalogPriceRange.minPrice);
-    const catalogMaxPriceSignal = signalsService.signal(catalogPriceRange.maxPrice);
-    const availableInventoryStatusesSignal = signalsService.signal([
-        InventoryStatusType.IN_STOCK,
-        InventoryStatusType.OUT_OF_STOCK,
-        InventoryStatusType.PARTIALLY_OUT_OF_STOCK,
-    ]);
-    const selectedInventoryStatusesSignal = signalsService.signal(initialSearchState?.inventoryStatuses || []);
-    const availableProductOptionsSignal = signalsService.signal(getAvailableProductOptions(aggregationData, customizations));
-    const selectedProductOptionsSignal = signalsService.signal(initialSearchState?.productOptions || {});
-    const selectedCategorySignal = signalsService.signal(initialSearchState?.category || null);
-    const selectedVisibleSignal = signalsService.signal(initialSearchState?.visible ?? null);
-    const selectedProductTypeSignal = signalsService.signal(initialSearchState?.productType || null);
-    // Computed signal to check if any filters are applied
-    const isFilteredSignal = signalsService.computed(() => {
-        const catalogPriceRange = getCatalogPriceRange(productsListService.aggregations.get()?.results || []);
-        const minPrice = userFilterMinPriceSignal.get();
-        const maxPrice = userFilterMaxPriceSignal.get();
-        const selectedInventoryStatuses = selectedInventoryStatusesSignal.get();
-        const selectedProductOptions = selectedProductOptionsSignal.get();
-        const selectedVisible = selectedVisibleSignal.get();
-        const selectedProductType = selectedProductTypeSignal.get();
-        // Check if any filters are different from default values
-        const hasPriceFilter = minPrice > catalogPriceRange.minPrice ||
-            maxPrice < catalogPriceRange.maxPrice;
-        const hasInventoryFilter = selectedInventoryStatuses.length > 0;
-        const hasProductOptionsFilter = Object.keys(selectedProductOptions).length > 0;
-        const hasVisibilityFilter = selectedVisible !== null;
-        const hasProductTypeFilter = selectedProductType !== null;
-        return (hasPriceFilter ||
-            hasInventoryFilter ||
-            hasProductOptionsFilter ||
-            hasVisibilityFilter ||
-            hasProductTypeFilter);
-    });
-    // Computed signals for pagination
-    const hasNextPageSignal = signalsService.computed(() => {
-        const pagingMetadata = productsListService.pagingMetadata.get();
-        return pagingMetadata?.hasNext || false;
-    });
-    const hasPrevPageSignal = signalsService.computed(() => {
-        const pagingMetadata = productsListService.pagingMetadata.get();
-        return typeof pagingMetadata.cursors?.prev !== 'undefined';
-    });
-    // Debounce timeout IDs for price filters
-    let minPriceTimeoutId = null;
-    let maxPriceTimeoutId = null;
     if (typeof window !== 'undefined') {
         // Watch for changes in any search parameters and update search options
         signalsService.effect(() => {
             // Read all signals to establish dependencies
-            const sort = selectedSortOptionSignal.get();
-            const limit = currentLimitSignal.get();
-            const cursor = currentCursorSignal.get();
-            const minPrice = userFilterMinPriceSignal.get();
-            const maxPrice = userFilterMaxPriceSignal.get();
-            const selectedInventoryStatuses = selectedInventoryStatusesSignal.get();
-            const selectedProductOptions = selectedProductOptionsSignal.get();
-            const selectedCategory = selectedCategorySignal.get();
-            const selectedVisible = selectedVisibleSignal.get();
-            const selectedProductType = selectedProductTypeSignal.get();
             if (firstRun) {
                 firstRun = false;
                 return;
             }
-            // Build complete new search options
-            const newSearchOptions = {
-                ...productsListService.searchOptions.peek(),
-            };
-            // Update pagination
-            if (limit > 0) {
-                newSearchOptions.cursorPaging = {
-                    limit,
-                    ...(cursor && { cursor }),
-                };
-            }
-            else {
-                delete newSearchOptions.cursorPaging;
-            }
-            // Update sort
-            switch (sort) {
-                case SortType.NAME_ASC:
-                    newSearchOptions.sort = [
-                        { fieldName: 'name', order: productsV3.SortDirection.ASC },
-                    ];
-                    break;
-                case SortType.NAME_DESC:
-                    newSearchOptions.sort = [
-                        { fieldName: 'name', order: productsV3.SortDirection.DESC },
-                    ];
-                    break;
-                case SortType.PRICE_ASC:
-                    newSearchOptions.sort = [
-                        {
-                            fieldName: 'actualPriceRange.minValue.amount',
-                            order: productsV3.SortDirection.ASC,
-                        },
-                    ];
-                    break;
-                case SortType.PRICE_DESC:
-                    newSearchOptions.sort = [
-                        {
-                            fieldName: 'actualPriceRange.minValue.amount',
-                            order: productsV3.SortDirection.DESC,
-                        },
-                    ];
-                    break;
-                case SortType.RECOMMENDED:
-                    newSearchOptions.sort = [
-                        {
-                            fieldName: 'name',
-                            order: productsV3.SortDirection.DESC,
-                        },
-                    ];
-                    break;
-            }
-            // Update filters
-            if (!newSearchOptions.filter) {
-                newSearchOptions.filter = {};
-            }
-            else {
-                newSearchOptions.filter = { ...newSearchOptions.filter };
-            }
-            // Remove existing filters
-            delete newSearchOptions.filter['actualPriceRange.minValue.amount'];
-            delete newSearchOptions.filter['actualPriceRange.maxValue.amount'];
-            delete newSearchOptions.filter['inventory.availabilityStatus'];
-            delete newSearchOptions.filter['allCategoriesInfo.categories'];
-            delete newSearchOptions.filter['visible'];
-            delete newSearchOptions.filter['productType'];
-            // Remove existing product option filters
-            Object.keys(newSearchOptions.filter).forEach((key) => {
-                if (key.startsWith('options.')) {
-                    delete newSearchOptions.filter[key];
-                }
-            });
-            // Add new filters
-            if (minPrice > 0) {
-                newSearchOptions.filter['actualPriceRange.minValue.amount'] = { $gte: minPrice };
-            }
-            if (maxPrice > 0) {
-                newSearchOptions.filter['actualPriceRange.maxValue.amount'] = { $lte: maxPrice };
-            }
-            if (selectedInventoryStatuses.length > 0) {
-                if (selectedInventoryStatuses.length === 1) {
-                    newSearchOptions.filter['inventory.availabilityStatus'] =
-                        selectedInventoryStatuses[0];
-                }
-                else {
-                    newSearchOptions.filter['inventory.availabilityStatus'] =
-                        { $in: selectedInventoryStatuses };
-                }
-            }
-            if (selectedProductOptions &&
-                Object.keys(selectedProductOptions).length > 0) {
-                const allChoiceIds = [];
-                for (const choiceIds of Object.values(selectedProductOptions)) {
-                    allChoiceIds.push(...choiceIds);
-                }
-                if (allChoiceIds.length > 0) {
-                    newSearchOptions.filter['options.choicesSettings.choices.choiceId'] = { $hasSome: allChoiceIds };
-                }
-            }
-            if (selectedCategory) {
-                newSearchOptions.filter['allCategoriesInfo.categories'] = {
-                    $matchItems: [{ _id: { $in: [selectedCategory._id] } }],
-                };
-            }
-            if (selectedVisible !== null) {
-                newSearchOptions.filter['visible'] = selectedVisible;
-            }
-            if (selectedProductType) {
-                newSearchOptions.filter['productType'] =
-                    selectedProductType;
-            }
-            // Update the products list service
-            productsListService.setSearchOptions(newSearchOptions);
-            // Update URL with current search state
-            const catalogBounds = {
-                minPrice: catalogMinPriceSignal.get(),
-                maxPrice: catalogMaxPriceSignal.get(),
-            };
-            const currentFilters = {
-                priceRange: { min: minPrice, max: maxPrice },
-                inventoryStatuses: selectedInventoryStatuses,
-                productOptions: selectedProductOptions,
-                ...(selectedVisible !== null && { visible: selectedVisible }),
-                ...(selectedProductType && { productType: selectedProductType }),
-            };
-            updateUrlWithSearchState({
-                sort,
-                filters: currentFilters,
-                customizations,
-                catalogBounds,
-                categorySlug: selectedCategory?.slug || undefined,
-            });
+            // TODO fix it blat
+            // const currentFilters = {
+            //   ...(selectedVisible !== null && { visible: selectedVisible }),
+            //   ...(selectedProductType && { productType: selectedProductType }),
+            // };
+            // updateUrlWithSearchState({
+            //   sort,
+            //   filters: currentFilters,
+            //   customizations,
+            //   catalogBounds,
+            //   categorySlug: selectedCategory?.slug || undefined,
+            // });
         });
     }
-    return {
-        // Sort functionality
-        selectedSortOption: selectedSortOptionSignal,
-        sortOptions: Object.values(SortType),
-        setSelectedSortOption: (sort) => selectedSortOptionSignal.set(sort),
-        // Pagination functionality
-        currentLimit: currentLimitSignal,
-        currentCursor: currentCursorSignal,
-        hasNextPage: hasNextPageSignal,
-        hasPrevPage: hasPrevPageSignal,
-        setLimit: (limit) => {
-            currentLimitSignal.set(limit);
-            currentCursorSignal.set(null); // Reset pagination when changing page size
-        },
-        loadMore: (count) => {
-            const limit = currentLimitSignal.get();
-            currentLimitSignal.set(limit + count);
-        },
-        nextPage: () => {
-            const pagingMetadata = productsListService.pagingMetadata.get();
-            const nextCursor = pagingMetadata?.cursors?.next;
-            if (nextCursor) {
-                currentCursorSignal.set(nextCursor);
-            }
-        },
-        prevPage: () => {
-            const pagingMetadata = productsListService.pagingMetadata.get();
-            const previousCursor = pagingMetadata?.cursors?.prev;
-            if (previousCursor) {
-                currentCursorSignal.set(previousCursor);
-            }
-        },
-        navigateToFirstPage: () => {
-            currentCursorSignal.set(null);
-        },
-        // Filter functionality
-        selectedMinPrice: userFilterMinPriceSignal,
-        selectedMaxPrice: userFilterMaxPriceSignal,
-        availableMinPrice: catalogMinPriceSignal,
-        availableMaxPrice: catalogMaxPriceSignal,
-        availableInventoryStatuses: availableInventoryStatusesSignal,
-        selectedInventoryStatuses: selectedInventoryStatusesSignal,
-        availableProductOptions: availableProductOptionsSignal,
-        selectedProductOptions: selectedProductOptionsSignal,
-        selectedCategory: selectedCategorySignal,
-        setSelectedMinPrice: (minPrice) => {
-            if (minPriceTimeoutId) {
-                clearTimeout(minPriceTimeoutId);
-            }
-            minPriceTimeoutId = setTimeout(() => {
-                userFilterMinPriceSignal.set(minPrice);
-                minPriceTimeoutId = null;
-            }, PRICE_FILTER_DEBOUNCE_TIME);
-        },
-        setSelectedMaxPrice: (maxPrice) => {
-            if (maxPriceTimeoutId) {
-                clearTimeout(maxPriceTimeoutId);
-            }
-            maxPriceTimeoutId = setTimeout(() => {
-                userFilterMaxPriceSignal.set(maxPrice);
-                maxPriceTimeoutId = null;
-            }, PRICE_FILTER_DEBOUNCE_TIME);
-        },
-        toggleInventoryStatus: (status) => {
-            const current = selectedInventoryStatusesSignal.get();
-            const isSelected = current.includes(status);
-            if (isSelected) {
-                selectedInventoryStatusesSignal.set(current.filter((s) => s !== status));
-            }
-            else {
-                selectedInventoryStatusesSignal.set([...current, status]);
-            }
-        },
-        toggleProductOption: (optionId, choiceId) => {
-            const current = selectedProductOptionsSignal.get();
-            const currentChoices = current[optionId] || [];
-            const isSelected = currentChoices.includes(choiceId);
-            if (isSelected) {
-                const newChoices = currentChoices.filter((id) => id !== choiceId);
-                if (newChoices.length === 0) {
-                    const newOptions = { ...current };
-                    delete newOptions[optionId];
-                    selectedProductOptionsSignal.set(newOptions);
-                }
-                else {
-                    selectedProductOptionsSignal.set({
-                        ...current,
-                        [optionId]: newChoices,
-                    });
-                }
-            }
-            else {
-                selectedProductOptionsSignal.set({
-                    ...current,
-                    [optionId]: [...currentChoices, choiceId],
-                });
-            }
-        },
-        setSelectedCategory: (category) => {
-            selectedCategorySignal.set(category);
-        },
-        setSelectedVisible: (visible) => {
-            selectedVisibleSignal.set(visible);
-        },
-        setSelectedProductType: (productType) => {
-            selectedProductTypeSignal.set(productType);
-        },
-        isFiltered: isFilteredSignal,
-        reset: () => {
-            selectedSortOptionSignal.set(SortType.NAME_ASC);
-            currentLimitSignal.set(DEFAULT_QUERY_LIMIT);
-            currentCursorSignal.set(null);
-            userFilterMinPriceSignal.set(catalogMinPriceSignal.get());
-            userFilterMaxPriceSignal.set(catalogMaxPriceSignal.get());
-            selectedInventoryStatusesSignal.set([]);
-            selectedProductOptionsSignal.set({});
-            selectedVisibleSignal.set(null);
-            selectedProductTypeSignal.set(null);
-        },
-    };
+    return {};
 });
-// Helper functions (copied from the original services)
-function getCurrentLimit(searchOptions) {
-    return searchOptions.cursorPaging?.limit || DEFAULT_QUERY_LIMIT;
-}
-function getCurrentCursor(searchOptions) {
-    return searchOptions.cursorPaging?.cursor || null;
-}
-function getCatalogPriceRange(aggregationData) {
-    const minPrice = getMinPrice(aggregationData);
-    const maxPrice = getMaxPrice(aggregationData);
-    return { minPrice, maxPrice };
-}
-function getMinPrice(aggregationData) {
-    const minPriceAggregation = aggregationData.find((data) => data.fieldPath === 'actualPriceRange.minValue.amount');
-    if (minPriceAggregation?.scalar?.value) {
-        return Number(minPriceAggregation.scalar.value) || 0;
-    }
-    return 0;
-}
-function getMaxPrice(aggregationData) {
-    const maxPriceAggregation = aggregationData.find((data) => data.fieldPath === 'actualPriceRange.maxValue.amount');
-    if (maxPriceAggregation?.scalar?.value) {
-        return Number(maxPriceAggregation.scalar.value) || 0;
-    }
-    return 0;
-}
-function getAvailableProductOptions(aggregationData = [], customizations = []) {
-    const matchesAggregationName = (name, aggregationNames) => {
-        return aggregationNames.some((aggName) => aggName.toLowerCase() === name.toLowerCase());
-    };
-    const sortChoicesIntelligently = (choices) => {
-        return [...choices].sort((a, b) => {
-            const aIsNumber = /^\d+$/.test(a.name);
-            const bIsNumber = /^\d+$/.test(b.name);
-            if (aIsNumber && bIsNumber) {
-                return parseInt(a.name) - parseInt(b.name);
-            }
-            if (aIsNumber && !bIsNumber)
-                return -1;
-            if (!aIsNumber && bIsNumber)
-                return 1;
-            return a.name.localeCompare(b.name);
-        });
-    };
-    const optionNames = [];
-    const choiceNames = [];
-    aggregationData.forEach((result) => {
-        if (result.name === 'optionNames' && result.values?.results) {
-            optionNames.push(...result.values.results
-                .map((item) => item.value)
-                .filter((value) => typeof value === 'string'));
-        }
-        if (result.name === 'choiceNames' && result.values?.results) {
-            choiceNames.push(...result.values.results
-                .map((item) => item.value)
-                .filter((value) => typeof value === 'string'));
-        }
-    });
-    const options = customizations
-        .filter((customization) => customization.name &&
-        customization._id &&
-        customization.customizationType ===
-            customizationsV3.CustomizationType.PRODUCT_OPTION &&
-        (optionNames.length === 0 ||
-            matchesAggregationName(customization.name, optionNames)))
-        .map((customization) => {
-        const choices = (customization.choicesSettings?.choices || [])
-            .filter((choice) => choice._id &&
-            choice.name &&
-            (choiceNames.length === 0 ||
-                matchesAggregationName(choice.name, choiceNames)))
-            .map((choice) => ({
-            id: choice._id,
-            name: choice.name,
-            colorCode: choice.colorCode,
-        }));
-        return {
-            id: customization._id,
-            name: customization.name,
-            choices: sortChoicesIntelligently(choices),
-            optionRenderType: customization.customizationRenderType,
-        };
-    })
-        .filter((option) => option.choices.length > 0);
-    return options;
-}

package/dist/services/products-list-service.d.ts

@@ -1,7 +1,24 @@
-import { type Signal } from '@wix/services-definitions/core-services/signals';
-import { productsV3 } from '@wix/stores';
-import { type InitialSearchState } from './products-list-search-service.js';
+import { type Signal, type ReadOnlySignal } from '@wix/services-definitions/core-services/signals';
+import { customizationsV3, productsV3 } from '@wix/stores';
+import { InventoryStatusType } from './products-list-search-service.js';
 export declare const DEFAULT_QUERY_LIMIT = 100;
+/**
+ * Interface representing a product option (like Size, Color, etc.).
+ */
+export interface ProductOption {
+    id: string;
+    name: string;
+    choices: ProductChoice[];
+    optionRenderType?: string;
+}
+/**
+ * Interface representing a choice within a product option.
+ */
+export interface ProductChoice {
+    id: string;
+    name: string;
+    colorCode?: string;
+}
 /**
  * Configuration interface for the Products List service.
  * Contains the initial products data, search options, and metadata.
@@ -17,6 +34,8 @@ export type ProductsListServiceConfig = {
     pagingMetadata: productsV3.CommonCursorPagingMetadata;
     /** Aggregation data containing filters, facets, and counts */
     aggregations: productsV3.AggregationData;
+    /** Customizations used to fetch the products */
+    customizations: customizationsV3.Customization[];
 };
 /**
  * Loads products list service configuration from the Wix Stores API for SSR initialization.
@@ -132,7 +151,6 @@ export type ProductsListServiceConfig = {
  */
 export declare function loadProductsListServiceConfig(input: string | {
     searchOptions: productsV3.V3ProductSearch;
-    initialSearchState: InitialSearchState;
 }): Promise<ProductsListServiceConfig>;
 /**
  * Service definition for the Products List service.
@@ -154,12 +172,28 @@ export declare const ProductsListServiceDefinition: string & {
         isLoading: Signal<boolean>;
         /** Reactive signal containing any error message, or null if no error */
         error: Signal<string | null>;
+        /** Reactive signal containing the minimum price of the products */
+        minPrice: Signal<number>;
+        /** Reactive signal containing the maximum price of the products */
+        maxPrice: Signal<number>;
+        /** Reactive signal containing the available inventory statuses */
+        availableInventoryStatuses: Signal<InventoryStatusType[]>;
+        /** Reactive signal containing the available product options */
+        availableProductOptions: Signal<ProductOption[]>;
         /** Function to update search options and trigger a new search */
         setSearchOptions: (searchOptions: productsV3.V3ProductSearch) => void;
         /** Function to update only the sort part of search options */
         setSort: (sort: productsV3.V3ProductSearch["sort"]) => void;
         /** Function to update only the filter part of search options */
         setFilter: (filter: productsV3.V3ProductSearch["filter"]) => void;
+        /** Function to reset the filter part of search options */
+        resetFilter: () => void;
+        /** Reactive signal indicating if any filters are currently applied */
+        isFiltered: () => ReadOnlySignal<boolean>;
+        /** Function to load more products */
+        loadMore: (count: number) => void;
+        /** Reactive signal indicating if there are more products to load */
+        hasMoreProducts: ReadOnlySignal<boolean>;
     };
     __config: ProductsListServiceConfig;
     isServiceDefinition?: boolean;
@@ -176,12 +210,28 @@ export declare const ProductsListServiceDefinition: string & {
     isLoading: Signal<boolean>;
     /** Reactive signal containing any error message, or null if no error */
     error: Signal<string | null>;
+    /** Reactive signal containing the minimum price of the products */
+    minPrice: Signal<number>;
+    /** Reactive signal containing the maximum price of the products */
+    maxPrice: Signal<number>;
+    /** Reactive signal containing the available inventory statuses */
+    availableInventoryStatuses: Signal<InventoryStatusType[]>;
+    /** Reactive signal containing the available product options */
+    availableProductOptions: Signal<ProductOption[]>;
     /** Function to update search options and trigger a new search */
     setSearchOptions: (searchOptions: productsV3.V3ProductSearch) => void;
     /** Function to update only the sort part of search options */
     setSort: (sort: productsV3.V3ProductSearch["sort"]) => void;
     /** Function to update only the filter part of search options */
     setFilter: (filter: productsV3.V3ProductSearch["filter"]) => void;
+    /** Function to reset the filter part of search options */
+    resetFilter: () => void;
+    /** Reactive signal indicating if any filters are currently applied */
+    isFiltered: () => ReadOnlySignal<boolean>;
+    /** Function to load more products */
+    loadMore: (count: number) => void;
+    /** Reactive signal indicating if there are more products to load */
+    hasMoreProducts: ReadOnlySignal<boolean>;
 };
 /**
  * Implementation of the Products List service that manages reactive products data.
@@ -251,12 +301,28 @@ export declare const ProductListService: import("@wix/services-definitions").Ser
         isLoading: Signal<boolean>;
         /** Reactive signal containing any error message, or null if no error */
         error: Signal<string | null>;
+        /** Reactive signal containing the minimum price of the products */
+        minPrice: Signal<number>;
+        /** Reactive signal containing the maximum price of the products */
+        maxPrice: Signal<number>;
+        /** Reactive signal containing the available inventory statuses */
+        availableInventoryStatuses: Signal<InventoryStatusType[]>;
+        /** Reactive signal containing the available product options */
+        availableProductOptions: Signal<ProductOption[]>;
         /** Function to update search options and trigger a new search */
         setSearchOptions: (searchOptions: productsV3.V3ProductSearch) => void;
         /** Function to update only the sort part of search options */
         setSort: (sort: productsV3.V3ProductSearch["sort"]) => void;
         /** Function to update only the filter part of search options */
         setFilter: (filter: productsV3.V3ProductSearch["filter"]) => void;
+        /** Function to reset the filter part of search options */
+        resetFilter: () => void;
+        /** Reactive signal indicating if any filters are currently applied */
+        isFiltered: () => ReadOnlySignal<boolean>;
+        /** Function to load more products */
+        loadMore: (count: number) => void;
+        /** Reactive signal indicating if there are more products to load */
+        hasMoreProducts: ReadOnlySignal<boolean>;
     };
     __config: ProductsListServiceConfig;
     isServiceDefinition?: boolean;
@@ -273,10 +339,26 @@ export declare const ProductListService: import("@wix/services-definitions").Ser
     isLoading: Signal<boolean>;
     /** Reactive signal containing any error message, or null if no error */
     error: Signal<string | null>;
+    /** Reactive signal containing the minimum price of the products */
+    minPrice: Signal<number>;
+    /** Reactive signal containing the maximum price of the products */
+    maxPrice: Signal<number>;
+    /** Reactive signal containing the available inventory statuses */
+    availableInventoryStatuses: Signal<InventoryStatusType[]>;
+    /** Reactive signal containing the available product options */
+    availableProductOptions: Signal<ProductOption[]>;
     /** Function to update search options and trigger a new search */
     setSearchOptions: (searchOptions: productsV3.V3ProductSearch) => void;
     /** Function to update only the sort part of search options */
     setSort: (sort: productsV3.V3ProductSearch["sort"]) => void;
     /** Function to update only the filter part of search options */
     setFilter: (filter: productsV3.V3ProductSearch["filter"]) => void;
+    /** Function to reset the filter part of search options */
+    resetFilter: () => void;
+    /** Reactive signal indicating if any filters are currently applied */
+    isFiltered: () => ReadOnlySignal<boolean>;
+    /** Function to load more products */
+    loadMore: (count: number) => void;
+    /** Reactive signal indicating if there are more products to load */
+    hasMoreProducts: ReadOnlySignal<boolean>;
 }, ProductsListServiceConfig>;