@wix/headless-bookings 1.0.9 → 1.0.11

package/dist/api/query-services/index.d.ts

@@ -1,8 +1,16 @@
 /**
  * Query Services API
- * Fetches single or multiple services with pagination and sorting
+ * Fetches single or multiple services with pagination and sorting.
+ *
+ * `queryServices` is the single entry point. It decides which underlying endpoint
+ * to call based on the request: when an `availabilityFilter` is present it queries
+ * the catalog-search `QueryServicesByAvailability` endpoint (cursor paging, each
+ * service enriched with an `available` flag); otherwise it uses the services
+ * `queryServices` endpoint (offset paging). Callers always get the same
+ * `{ services, pagingMetadata }` shape.
  */
 import { type Service, type Paging, type Sorting } from '@wix/auto_sdk_bookings_services';
+import { LocationType as AvailabilityLocationType, type ServiceFilters as AvailabilityFilter, type Attribute, type Location as AvailabilityLocation } from '@wix/auto_sdk_bookings_catalog-search';
 import type { FilterValue as Filter } from '@wix/headless-components/react';
 /**
  * Synthetic location ID constants for non-business locations
@@ -10,24 +18,48 @@ import type { FilterValue as Filter } from '@wix/headless-components/react';
 export declare const SYNTHETIC_CUSTOM_ID = "custom";
 export declare const SYNTHETIC_CUSTOMER_ID = "customer";
 /**
- * Paging metadata from query services response.
- * Extends the SDK's Paging type with hasNext flag to indicate if more services are available.
+ * Re-exported availability filter types so consumers can build availability UIs
+ * without importing the ambassador package directly.
+ */
+export { AvailabilityLocationType, type AvailabilityFilter, type Attribute, type AvailabilityLocation, };
+/**
+ * A service, optionally enriched with a bookable-availability flag.
+ * `available` is only populated when the query runs in availability mode.
+ */
+export type ServiceWithAvailabilityItem = Service & {
+    /** Whether the service has bookable slots in the requested window. */
+    available?: boolean;
+};
+/**
+ * Paging metadata from a query response. Extends the SDK's Paging type with a
+ * `hasNext` flag and an opaque `cursor` (used in availability/cursor mode).
  */
 export type PagingMetadata = Paging & {
     /** Number of items returned in the current page */
     count?: number;
     /** Whether there are more services available to load */
     hasNext?: boolean;
+    /** Opaque cursor for the next page (availability/cursor mode only). Undefined in offset mode. */
+    cursor?: string;
 };
 /**
- * Query services request options
- * Used internally by ServiceListService to track query state
+ * Query services request options.
+ * When `availabilityFilter` is present, services are queried by real bookable
+ * availability; `pagingMetadata.cursor` then drives pagination instead of `offset`.
  */
 export interface QueryServicesRequest {
     appId: string;
     filter?: Filter;
     pagingMetadata?: PagingMetadata;
     sort?: Sorting[];
+    availabilityFilter?: AvailabilityFilter;
+}
+/**
+ * Result shape shared by both query modes.
+ */
+export interface QueryServicesResult {
+    services: ServiceWithAvailabilityItem[];
+    pagingMetadata: PagingMetadata;
 }
 /**
  * Fetches a service by its ID
@@ -72,28 +104,41 @@ export declare const getServiceBySlug: (slug: string, appId?: string) => Promise
  * ```
  */
 export declare function convertPlatformFilterToApiFilter(platformFilter: Filter): Record<string, any>;
+/**
+ * Whether an availability filter carries a real bookable constraint that warrants
+ * routing to the availability endpoint. Modifiers that don't define a query on their
+ * own (`timeZone`, `exactMatch`, `includeUnavailable`) are ignored: only a complete
+ * date window (both `localStartDate` and `localEndDate`) or a resource constraint
+ * (`locations`/`attributes`/`resourceTypes`) counts.
+ *
+ * This is the single source of truth shared by the API dispatch and the service's
+ * `hasAvailabilityFilterSignal`.
+ */
+export declare function hasActiveAvailabilityFilter(availabilityFilter?: AvailabilityFilter): boolean;
 /**
  * Query services with pagination and sorting.
- * Returns services array and paging metadata including hasNext flag.
+ * Picks the underlying endpoint by request: availability filter present → catalog-search
+ * (cursor paging, `available` flag); otherwise the offset services query.
  *
- * @param params - Query parameters including appId, filter (platform Filter type), paging metadata, and sort options
+ * @param request - Query parameters including appId, filter (platform Filter type), paging
+ *   metadata, sort options, and an optional availability filter
  * @returns Promise that resolves to services array and paging metadata with hasNext flag
  *
  * @example
  * ```ts
+ * // Offset query
  * const { services, pagingMetadata } = await queryServices({
  *   appId: '13d21c63-b5ec-5912-8397-c3a5ddb27a97',
  *   filter: { '_id': { $in: ['service1', 'service2'] } },
  *   pagingMetadata: { limit: 20, offset: 0 },
- *   sort: [{ fieldName: 'name', order: 'ASC' }]
  * });
  *
- * if (pagingMetadata.hasNext) {
- *   // Load more services
- * }
+ * // Availability-aware query (cursor paging + `available` flag)
+ * const availability = await queryServices({
+ *   appId: '13d21c63-b5ec-5912-8397-c3a5ddb27a97',
+ *   availabilityFilter: { localStartDate: '...', localEndDate: '...', timeZone: '...' },
+ *   pagingMetadata: { limit: 20 },
+ * });
  * ```
  */
-export declare function queryServices({ appId, filter, pagingMetadata, sort, }: QueryServicesRequest): Promise<{
-    services: Service[];
-    pagingMetadata: PagingMetadata;
-}>;
+export declare function queryServices(request: QueryServicesRequest): Promise<QueryServicesResult>;

package/dist/api/query-services/index.js

@@ -1,14 +1,27 @@
 /**
  * Query Services API
- * Fetches single or multiple services with pagination and sorting
+ * Fetches single or multiple services with pagination and sorting.
+ *
+ * `queryServices` is the single entry point. It decides which underlying endpoint
+ * to call based on the request: when an `availabilityFilter` is present it queries
+ * the catalog-search `QueryServicesByAvailability` endpoint (cursor paging, each
+ * service enriched with an `available` flag); otherwise it uses the services
+ * `queryServices` endpoint (offset paging). Callers always get the same
+ * `{ services, pagingMetadata }` shape.
  */
 import { queryServices as queryServicesApi, LocationTypeEnumLocationType as LocationType, } from '@wix/auto_sdk_bookings_services';
-import { BOOKING_APP_ID } from '../../services/constants.js';
+import { queryServicesByFilters as queryServicesByAvailabilitySdk, LocationType as AvailabilityLocationType, } from '@wix/auto_sdk_bookings_catalog-search';
+import { BOOKING_APP_ID, DEFAULT_QUERY_LIMIT, } from '../../services/constants.js';
 /**
  * Synthetic location ID constants for non-business locations
  */
 export const SYNTHETIC_CUSTOM_ID = 'custom';
 export const SYNTHETIC_CUSTOMER_ID = 'customer';
+/**
+ * Re-exported availability filter types so consumers can build availability UIs
+ * without importing the ambassador package directly.
+ */
+export { AvailabilityLocationType, };
 /**
  * Fetches a service by its ID
  * @param id - The service ID
@@ -180,34 +193,100 @@ const buildServicesQueryRequest = ({ appId, filter: platformFilter, paging, sort
     const query = {
         filter: Object.keys(filter).length > 0 ? filter : undefined,
         paging: paging || {
-            limit: 100, // Default limit
+            limit: DEFAULT_QUERY_LIMIT,
         },
         sort,
     };
     return { query };
 };
+/**
+ * Whether an availability filter carries a real bookable constraint that warrants
+ * routing to the availability endpoint. Modifiers that don't define a query on their
+ * own (`timeZone`, `exactMatch`, `includeUnavailable`) are ignored: only a complete
+ * date window (both `localStartDate` and `localEndDate`) or a resource constraint
+ * (`locations`/`attributes`/`resourceTypes`) counts.
+ *
+ * This is the single source of truth shared by the API dispatch and the service's
+ * `hasAvailabilityFilterSignal`.
+ */
+export function hasActiveAvailabilityFilter(availabilityFilter) {
+    if (!availabilityFilter)
+        return false;
+    const { localStartDate, localEndDate, locationIds, attributes, resourceTypes, } = availabilityFilter;
+    const hasDateWindow = Boolean(localStartDate && localEndDate);
+    const hasResourceConstraint = (locationIds?.length ?? 0) > 0 ||
+        (attributes?.length ?? 0) > 0 ||
+        (resourceTypes?.length ?? 0) > 0;
+    return hasDateWindow || hasResourceConstraint;
+}
+/**
+ * Queries services by real bookable availability (catalog-search). Cursor-based.
+ * The WQL filter reuses the same platform→API conversion as the offset query.
+ */
+async function queryServicesByAvailability({ appId, filter, availabilityFilter, sort, pagingMetadata, }) {
+    const wqlFilter = {
+        appId: appId ?? BOOKING_APP_ID,
+    };
+    if (filter) {
+        Object.assign(wqlFilter, convertPlatformFilterToApiFilter(filter));
+    }
+    const limit = pagingMetadata?.limit ?? DEFAULT_QUERY_LIMIT;
+    const cursor = pagingMetadata?.cursor;
+    const availabilityQuery = {
+        filter: wqlFilter,
+        sort,
+        cursorPaging: { limit, ...(cursor ? { cursor } : {}) },
+    };
+    const response = await queryServicesByAvailabilitySdk({
+        query: availabilityQuery,
+        serviceFilters: availabilityFilter,
+    });
+    const results = response.results ?? [];
+    return {
+        services: results.map((result) => ({
+            ...result.service,
+            available: result.available ?? true,
+        })),
+        pagingMetadata: {
+            limit,
+            count: response.pagingMetadata?.count ?? results.length,
+            hasNext: response.pagingMetadata?.hasNext ?? false,
+            cursor: response.pagingMetadata?.cursors?.next ?? undefined,
+        },
+    };
+}
 /**
  * Query services with pagination and sorting.
- * Returns services array and paging metadata including hasNext flag.
+ * Picks the underlying endpoint by request: availability filter present → catalog-search
+ * (cursor paging, `available` flag); otherwise the offset services query.
  *
- * @param params - Query parameters including appId, filter (platform Filter type), paging metadata, and sort options
+ * @param request - Query parameters including appId, filter (platform Filter type), paging
+ *   metadata, sort options, and an optional availability filter
  * @returns Promise that resolves to services array and paging metadata with hasNext flag
  *
  * @example
  * ```ts
+ * // Offset query
  * const { services, pagingMetadata } = await queryServices({
  *   appId: '13d21c63-b5ec-5912-8397-c3a5ddb27a97',
  *   filter: { '_id': { $in: ['service1', 'service2'] } },
  *   pagingMetadata: { limit: 20, offset: 0 },
- *   sort: [{ fieldName: 'name', order: 'ASC' }]
  * });
  *
- * if (pagingMetadata.hasNext) {
- *   // Load more services
- * }
+ * // Availability-aware query (cursor paging + `available` flag)
+ * const availability = await queryServices({
+ *   appId: '13d21c63-b5ec-5912-8397-c3a5ddb27a97',
+ *   availabilityFilter: { localStartDate: '...', localEndDate: '...', timeZone: '...' },
+ *   pagingMetadata: { limit: 20 },
+ * });
  * ```
  */
-export async function queryServices({ appId, filter, pagingMetadata, sort, }) {
+export async function queryServices(request) {
+    const { appId, filter, pagingMetadata, sort, availabilityFilter } = request;
+    // Decide the endpoint by the filters passed.
+    if (hasActiveAvailabilityFilter(availabilityFilter)) {
+        return queryServicesByAvailability(request);
+    }
     try {
         const queryRequest = buildServicesQueryRequest({
             appId,

package/dist/react/core/service-list/ServiceList.d.ts

@@ -4,8 +4,7 @@
  */
 import React from 'react';
 import { type ServiceListServiceConfig, type QueryOptions } from '../../../services/service-list/service-list.js';
-import type { Service } from '@wix/auto_sdk_bookings_services';
-import type { PagingMetadata } from '../../../api/query-services/index.js';
+import type { PagingMetadata, ServiceWithAvailabilityItem } from '../../../api/query-services/index.js';
 /**
  * Props for ServiceList.Root component
  */
@@ -37,7 +36,7 @@ export interface ServicesProps {
  */
 export interface ServicesRenderProps {
     /** Array of services */
-    services: Service[];
+    services: ServiceWithAvailabilityItem[];
     /** Whether services are currently loading */
     isLoading: boolean;
     /** Error message, or null if no error */

package/dist/react/service-list/ServiceList.d.ts

@@ -6,7 +6,7 @@ import React from 'react';
 import { ListVariant, GenericListLoadMoreRenderProps, type FilterRootProps } from '@wix/headless-components/react';
 import { AsChildChildren } from '@wix/headless-utils/react';
 import type { ServiceListServiceConfig } from '../../services/service-list/service-list.js';
-import type { Service as ServiceType } from '@wix/auto_sdk_bookings_services';
+import type { ServiceWithAvailabilityItem } from '../../api/query-services/index.js';
 export declare const TestIds: {
     readonly serviceListRoot: "service-list-root";
     readonly serviceListServices: "service-list-services";
@@ -95,7 +95,7 @@ export type ServiceRootChildren = AsChildChildren<{
  * Supports both ReactNode and function children that receive { selected, bookable }
  */
 export interface ServiceItemWrapperProps {
-    item: ServiceType;
+    item: ServiceWithAvailabilityItem;
     index?: number;
     /** Children can be ReactNode or a function that receives { selected, bookable } from Service.Root */
     children: React.ReactNode | ServiceRootChildren;
@@ -105,7 +105,7 @@ export interface ServiceItemWrapperProps {
  * Provides items array and itemWrapper function for custom rendering
  */
 export interface ServiceRepeaterRenderProps {
-    items: ServiceType[];
+    items: ServiceWithAvailabilityItem[];
     variant?: ListVariant;
     /** Wraps each item in Service.Root - children can be ReactNode or function receiving { selected, bookable } */
     itemWrapper: (props: ServiceItemWrapperProps) => React.ReactNode;

package/dist/react/service-list/ServiceList.js

@@ -121,7 +121,7 @@ export const ServiceRepeater = React.forwardRef((props, ref) => {
     // Custom itemWrapper that matches ItemWrapperProps signature
     const serviceItemWrapper = (wrapperProps) => {
         const { item: service, children: itemChildren } = wrapperProps;
-        return (_jsx(Service.Root, { service: service, "data-testid": TestIds.serviceListService, "data-service-id": service._id, "data-item-id": service._id, children: isServiceRootFunction
+        return (_jsx(Service.Root, { service: service, "data-testid": TestIds.serviceListService, "data-service-id": service._id, "data-item-id": service._id, "data-available": service.available, children: isServiceRootFunction
                 ? children
                 : itemChildren }, service._id));
     };

package/dist/react/service-list/ServiceList.stories.d.ts

@@ -0,0 +1,29 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import * as ServiceList from './ServiceList';
+/**
+ * ServiceList component story.
+ *
+ * ServiceList renders a list of bookings services. When the configured services
+ * carry an `available` flag (availability mode), stories can style each item by
+ * its availability. It supports filtering by categories, availability dates, and
+ * custom attributes.
+ */
+declare const meta: Meta<typeof ServiceList.Root>;
+export default meta;
+type Story = StoryObj<typeof meta>;
+/**
+ * Basic list with three services, two available and one unavailable.
+ */
+export declare const BasicList: Story;
+/**
+ * List with empty state message displayed when no services are available.
+ */
+export declare const EmptyState: Story;
+/**
+ * List with detailed service information (name and price).
+ */
+export declare const WithServiceDetails: Story;
+/**
+ * List with custom styling for available/unavailable items.
+ */
+export declare const WithAvailabilityStates: Story;

package/dist/react/service-list/ServiceList.stories.js

@@ -0,0 +1,89 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as ServiceList from './ServiceList';
+import * as Booking from '../booking/Booking';
+import * as Service from '../service/Service';
+import { mockServicesWithAvailability, mockCategories, } from '../../__mocks__/services/services-mocks';
+import { BOOKING_APP_ID } from '../../services/constants';
+const config = {
+    services: mockServicesWithAvailability,
+    categories: mockCategories,
+    options: { appId: BOOKING_APP_ID },
+};
+const emptyConfig = {
+    services: [],
+    categories: [],
+    options: { appId: BOOKING_APP_ID },
+};
+/**
+ * ServiceList component story.
+ *
+ * ServiceList renders a list of bookings services. When the configured services
+ * carry an `available` flag (availability mode), stories can style each item by
+ * its availability. It supports filtering by categories, availability dates, and
+ * custom attributes.
+ */
+const meta = {
+    title: 'Bookings/ServiceList',
+    component: ServiceList.Root,
+    tags: ['autodocs'],
+};
+export default meta;
+/**
+ * Basic list with three services, two available and one unavailable.
+ */
+export const BasicList = {
+    render: () => (_jsx(Booking.Root, { children: _jsx(ServiceList.Root, { serviceListConfig: config, children: _jsx(ServiceList.Services, { children: _jsx(ServiceList.ServiceRepeater, { children: _jsx(Service.Name, {}) }) }) }) })),
+};
+/**
+ * List with empty state message displayed when no services are available.
+ */
+export const EmptyState = {
+    render: () => (_jsx(Booking.Root, { children: _jsx(ServiceList.Root, { serviceListConfig: emptyConfig, children: _jsx(ServiceList.Services, { emptyState: _jsx("div", { style: {
+                        padding: '2rem',
+                        textAlign: 'center',
+                        color: 'var(--color-muted-foreground)',
+                    }, children: "No services available" }), children: _jsx(ServiceList.ServiceRepeater, { children: _jsx(Service.Name, {}) }) }) }) })),
+};
+/**
+ * List with detailed service information (name and price).
+ */
+export const WithServiceDetails = {
+    render: () => (_jsx(Booking.Root, { children: _jsx(ServiceList.Root, { serviceListConfig: config, children: _jsx(ServiceList.Services, { children: _jsx(ServiceList.ServiceRepeater, { asChild: true, children: ({ items, itemWrapper, }) => (_jsx("ul", { style: { listStyle: 'none', padding: 0 }, children: items.map((service, index) => (_jsx("li", { style: {
+                                padding: '1rem',
+                                borderBottom: '1px solid var(--color-border)',
+                                opacity: service.available === false ? 0.6 : 1,
+                            }, children: itemWrapper({
+                                item: service,
+                                index,
+                                children: (_jsxs("div", { children: [_jsx(Service.Name, {}), _jsx(Service.Price, {})] })),
+                            }) }, service._id))) })) }) }) }) })),
+};
+/**
+ * List with custom styling for available/unavailable items.
+ */
+export const WithAvailabilityStates = {
+    render: () => (_jsx(Booking.Root, { children: _jsx(ServiceList.Root, { serviceListConfig: config, children: _jsx(ServiceList.Services, { children: _jsx(ServiceList.ServiceRepeater, { asChild: true, children: ({ items, itemWrapper, }) => (_jsx("ul", { style: { listStyle: 'none', padding: 0 }, children: items.map((service, index) => (_jsx("li", { style: {
+                                padding: '1rem',
+                                marginBottom: '0.5rem',
+                                borderRadius: '4px',
+                                backgroundColor: service.available
+                                    ? 'color-mix(in srgb, var(--color-primary) 8%, transparent)'
+                                    : 'var(--color-secondary)',
+                                borderLeft: `4px solid ${service.available ? 'var(--color-primary)' : 'var(--color-border)'}`,
+                                opacity: service.available ? 1 : 0.7,
+                            }, children: itemWrapper({
+                                item: service,
+                                index,
+                                children: (_jsxs("div", { style: {
+                                        display: 'flex',
+                                        justifyContent: 'space-between',
+                                        alignItems: 'center',
+                                    }, children: [_jsx(Service.Name, {}), _jsx("span", { style: {
+                                                fontSize: '0.875rem',
+                                                fontWeight: 500,
+                                                color: service.available
+                                                    ? 'var(--color-primary)'
+                                                    : 'var(--color-muted-foreground)',
+                                            }, children: service.available ? 'Available' : 'Not Available' })] })),
+                            }) }, service._id))) })) }) }) }) })),
+};

package/dist/services/constants.d.ts

@@ -5,6 +5,8 @@
  */
 /** Booking app definition ID */
 export declare const BOOKING_APP_ID = "13d21c63-b5ec-5912-8397-c3a5ddb27a97";
+/** Default page size for service queries (offset and cursor/availability modes) */
+export declare const DEFAULT_QUERY_LIMIT = 100;
 /** Resource type ID for staff members */
 export declare const STAFF_MEMBER_RESOURCE_TYPE_ID = "1cd44cf8-756f-41c3-bd90-3e2ffcaf1155";
 export declare const ClientServiceIds: {

package/dist/services/constants.js

@@ -5,6 +5,8 @@
  */
 /** Booking app definition ID */
 export const BOOKING_APP_ID = '13d21c63-b5ec-5912-8397-c3a5ddb27a97';
+/** Default page size for service queries (offset and cursor/availability modes) */
+export const DEFAULT_QUERY_LIMIT = 100;
 /** Resource type ID for staff members */
 export const STAFF_MEMBER_RESOURCE_TYPE_ID = '1cd44cf8-756f-41c3-bd90-3e2ffcaf1155';
 export const ClientServiceIds = {

package/dist/services/index.d.ts

@@ -5,8 +5,8 @@
 export { ServiceService, ServiceServiceDefinition, type ServiceServiceAPI, type ServiceServiceConfig, type ServiceActions, type ServicePaymentData, loadServiceServiceInitialData, type SuccessServiceServiceConfigResult, type NotFoundServiceServiceConfigResult, } from './service/service.js';
 export { BookingService, BookingServiceDefinition, type BookingServiceConfig, type BookingServiceActions, type ServiceSelection, type ServiceSelectionTimeSlot, } from './booking/booking.js';
 export { TimeSlotListService, TimeSlotListServiceDefinition, TimeSlotService, TimeSlotServiceDefinition, ViewMode, loadTimeSlotListConfig, type TimeSlotListServiceAPI, type TimeSlotListServiceActions, type TimeSlotListServiceConfig, type TimeSlotServiceAPI, type TimeSlotServiceConfig, type LoadTimeSlotListConfigOptions, type LoadTimeSlotListConfigResult, } from './time-slot-list/index.js';
-export { ServiceListService, ServiceListServiceDefinition, type ServiceListServiceAPI, type ServiceListServiceConfig, type ServiceListActions, type QueryOptions, loadServiceListServiceInitialData, type SuccessServiceListServiceConfigResult, type ErrorServiceListServiceConfigResult, } from './service-list/service-list.js';
-export { SYNTHETIC_CUSTOM_ID, SYNTHETIC_CUSTOMER_ID, } from '../api/query-services/index.js';
+export { ServiceListService, ServiceListServiceDefinition, type ServiceListServiceAPI, type ServiceListServiceConfig, type ServiceListActions, type QueryOptions, loadServiceListServiceInitialData, type LoadServiceListServiceOptions, type SuccessServiceListServiceConfigResult, type ErrorServiceListServiceConfigResult, } from './service-list/service-list.js';
+export { SYNTHETIC_CUSTOM_ID, SYNTHETIC_CUSTOMER_ID, AvailabilityLocationType, type ServiceWithAvailabilityItem, type AvailabilityFilter, type Attribute, type AvailabilityLocation, } from '../api/query-services/index.js';
 export { executeBookAction, canBook, buildBookingRequest, buildCartRequest, buildDayRangeBookingRequest, createBookingsForCart, isDayRangeService, getDayRangeBounds, type CanBookParams, type BookResult, type BookingError, type BookActionParams, type BookChildProps, type BookProps, type BuildCartParams, type BuildDayRangeBookingRequest, type CreatedBookings, type DayRangeBounds, } from './booking/book-action/index.js';
 export { BookingFormService, BookingFormServiceDefinition, type BookingFormServiceAPI, type BookingFormServiceConfig, } from './booking-form/booking-form.js';
 export { PaymentService, PaymentServiceDefinition, type PaymentServiceAPI, type PaymentServiceConfig, type PaymentDetails, type PricingServiceSelection, type LineItemAdditionalInfo, type ServicePaymentOptions, loadPaymentConfig, type SuccessPaymentConfigResult, type ErrorPaymentConfigResult, } from './payment/payment.js';

package/dist/services/index.js

@@ -6,7 +6,7 @@ export { ServiceService, ServiceServiceDefinition, loadServiceServiceInitialData
 export { BookingService, BookingServiceDefinition, } from './booking/booking.js';
 export { TimeSlotListService, TimeSlotListServiceDefinition, TimeSlotService, TimeSlotServiceDefinition, ViewMode, loadTimeSlotListConfig, } from './time-slot-list/index.js';
 export { ServiceListService, ServiceListServiceDefinition, loadServiceListServiceInitialData, } from './service-list/service-list.js';
-export { SYNTHETIC_CUSTOM_ID, SYNTHETIC_CUSTOMER_ID, } from '../api/query-services/index.js';
+export { SYNTHETIC_CUSTOM_ID, SYNTHETIC_CUSTOMER_ID, AvailabilityLocationType, } from '../api/query-services/index.js';
 export { executeBookAction, canBook, buildBookingRequest, buildCartRequest, buildDayRangeBookingRequest, createBookingsForCart, isDayRangeService, getDayRangeBounds, } from './booking/book-action/index.js';
 export { BookingFormService, BookingFormServiceDefinition, } from './booking-form/booking-form.js';
 export { PaymentService, PaymentServiceDefinition, loadPaymentConfig, } from './payment/payment.js';

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

@@ -1,22 +1,29 @@
 /**
  * ServiceList Service - Reactive service list data management
- * Handles querying and pagination of services list (NO selection management)
+ * Handles querying and pagination of services list (NO selection management).
+ *
+ * Availability is just part of the query: when the query options carry an
+ * `availabilityFilter`, the API layer queries services by real bookable
+ * availability (and each service gets an `available` flag); otherwise it runs the
+ * plain offset query. The service does not know or care which endpoint is used —
+ * that decision lives in {@link queryServices}.
  */
 import { type Signal, type ReadOnlySignal } from '@wix/services-definitions/core-services/signals';
-import type { Service } from '@wix/auto_sdk_bookings_services';
-import type { QueryServicesRequest, PagingMetadata } from '../../api/query-services/index.js';
+import type { Sorting } from '@wix/auto_sdk_bookings_services';
+import type { QueryServicesRequest, PagingMetadata, ServiceWithAvailabilityItem, AvailabilityFilter } from '../../api/query-services/index.js';
 import { type Category } from '../../api/query-categories/index.js';
 import type { FilterOption, FilterValue as Filter } from '@wix/headless-components/react';
 /**
- * Query options without paging metadata (user-controlled request params)
- * Effect subscribes to changes in this signal to trigger re-fetches
+ * Query options without paging metadata (user-controlled request params).
+ * Includes `filter` (category/location) and `availabilityFilter`; the effect
+ * subscribes to changes in this signal to trigger re-fetches.
  */
 export type QueryOptions = Omit<QueryServicesRequest, 'pagingMetadata'>;
 /**
  * Configuration for the ServiceList service
  */
 export interface ServiceListServiceConfig {
-    services?: Service[];
+    services?: ServiceWithAvailabilityItem[];
     categories?: Category[];
     options?: QueryServicesRequest;
 }
@@ -35,10 +42,10 @@ export interface ServiceListActions {
  */
 export interface ServiceListServiceAPI {
     /** Reactive signal containing the list of services */
-    servicesSignal: Signal<Service[]>;
-    /** Reactive signal containing current query options (appId, filter, sort) - changes trigger re-fetch */
+    servicesSignal: Signal<ServiceWithAvailabilityItem[]>;
+    /** Reactive signal containing current query options (appId, filter, availabilityFilter, sort) - changes trigger re-fetch */
     queryOptionsSignal: Signal<QueryOptions>;
-    /** Reactive signal containing pagination metadata (limit, offset, count, hasNext) - updated after fetches */
+    /** Reactive signal containing pagination metadata (limit, offset/cursor, count, hasNext) - updated after fetches */
     pagingMetadataSignal: Signal<PagingMetadata>;
     /** Reactive signal indicating if services are currently being loaded */
     isLoadingSignal: Signal<boolean>;
@@ -50,6 +57,8 @@ export interface ServiceListServiceAPI {
     filterOptionsSignal: ReadOnlySignal<FilterOption[]>;
     /** Computed signal indicating if any filters are active (from queryOptionsSignal.filter) */
     isFilteredSignal: ReadOnlySignal<boolean>;
+    /** Computed signal indicating whether an availability filter is currently applied */
+    hasAvailabilityFilterSignal: ReadOnlySignal<boolean>;
     /** Computed signal containing effective filter (queryOptions.filter + location from BookingService) */
     effectiveFilterSignal: ReadOnlySignal<Filter | undefined>;
     /** Actions object containing query actions */
@@ -91,7 +100,6 @@ export declare const ServiceListServiceDefinition: string & {
  *   const services = serviceListService.servicesSignal.get();
  *   const isLoading = serviceListService.isLoadingSignal.get();
  *   const error = serviceListService.errorSignal.get();
- *   const pagingMetadata = serviceListService.pagingMetadataSignal.get();
  *   const hasMore = serviceListService.hasMoreServicesSignal.get();
  *
  *   if (isLoading) return <div>Loading services...</div>;
@@ -110,9 +118,6 @@ export declare const ServiceListServiceDefinition: string & {
  *           Load More
  *         </button>
  *       )}
- *       {pagingMetadata.hasNext && (
- *         <span>More services available</span>
- *       )}
  *     </div>
  *   );
  * }
@@ -135,36 +140,40 @@ export type ErrorServiceListServiceConfigResult = {
     error: Error;
 };
 /**
- * Load service list configuration for Server-Side Rendering (SSR).
- * This function is designed to be called during the build or server-side rendering phase
- * to pre-fetch services data before the React components are hydrated on the client.
- * The returned config includes paging metadata with hasNext flag indicating if more services are available.
+ * Options for {@link loadServiceListServiceInitialData}.
+ * Pass an `availabilityFilter` to load availability-aware services.
+ */
+export interface LoadServiceListServiceOptions {
+    appId?: string;
+    filter?: Filter;
+    pagingMetadata?: PagingMetadata;
+    sort?: Sorting[];
+    availabilityFilter?: AvailabilityFilter;
+}
+/**
+ * Loads service list configuration for SSR, pre-fetching services and categories.
+ * Pass an `availabilityFilter` to query availability-aware services.
  *
- * @param options - Query options following QueryServicesRequest type, or a URL string (to be implemented)
- * @returns A promise that resolves to either a success result with the config or an error result
+ * @param options - Query options.
+ * @returns A success result with the config, or an error result.
  *
  * @example
  * ```ts
- * // In an Astro page or API route
- * import { loadServiceListServiceInitialData } from '@wix/bookings/services';
- *
- * // Load with query options
- * const serviceListResult = await loadServiceListServiceInitialData({
+ * // Plain offset query
+ * const result = await loadServiceListServiceInitialData({
  *   appId: '13d21c63-b5ec-5912-8397-c3a5ddb27a97',
  *   pagingMetadata: { limit: 20, offset: 0 },
  * });
  *
- * if (serviceListResult.type === 'error') {
- *   console.error('Failed to load services:', serviceListResult.error);
- *   return Astro.redirect('/500');
- * }
- *
- * const serviceListConfig = serviceListResult.config;
- *
- * // Check if more services are available
- * if (serviceListConfig.options?.pagingMetadata?.hasNext) {
- *   // More services can be loaded
- * }
+ * // Availability-aware query (cursor paging + `available` flag)
+ * const availabilityResult = await loadServiceListServiceInitialData({
+ *   availabilityFilter: {
+ *     localStartDate: '2026-06-01T09:00:00',
+ *     localEndDate: '2026-06-07T17:00:00',
+ *     timeZone: 'America/New_York',
+ *   },
+ *   pagingMetadata: { limit: 20 },
+ * });
  * ```
  */
-export declare function loadServiceListServiceInitialData(options: QueryServicesRequest): Promise<SuccessServiceListServiceConfigResult | ErrorServiceListServiceConfigResult>;
+export declare function loadServiceListServiceInitialData(options: LoadServiceListServiceOptions): Promise<SuccessServiceListServiceConfigResult | ErrorServiceListServiceConfigResult>;