@wix/headless-bookings 1.0.8 → 1.0.10

package/cjs/dist/services/service-list/service-list.js

@@ -1,7 +1,13 @@
 "use strict";
 /**
  * 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}.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceListService = exports.ServiceListServiceDefinition = void 0;
@@ -12,10 +18,6 @@ const index_js_1 = require("../../api/query-services/index.js");
 const index_js_2 = require("../../api/query-categories/index.js");
 const booking_js_1 = require("../booking/booking.js");
 const constants_js_1 = require("../constants.js");
-/**
- * Default query limit
- */
-const DEFAULT_QUERY_LIMIT = 100;
 /**
  * Service definition for the ServiceList service
  */
@@ -46,7 +48,6 @@ exports.ServiceListServiceDefinition = (0, services_definitions_1.defineService)
  *   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>;
@@ -65,9 +66,6 @@ exports.ServiceListServiceDefinition = (0, services_definitions_1.defineService)
  *           Load More
  *         </button>
  *       )}
- *       {pagingMetadata.hasNext && (
- *         <span>More services available</span>
- *       )}
  *     </div>
  *   );
  * }
@@ -85,20 +83,22 @@ exports.ServiceListService = services_definitions_1.implementService.withConfig(
     // Initialize services signal - use empty array if not provided
     const initialServices = config.services || [];
     const servicesSignal = signalsService.signal(initialServices);
-    // Initialize query options based on mode:
-    // - If services provided: reset to defaults (appId only) - showcase mode
-    // - If no services: use full queryOptions from config - query mode
-    const initialQueryOptions = hasInitialServices
-        ? { appId } // Reset to defaults when services are provided
-        : {
-            appId,
-            filter: config.options?.filter,
-            sort: config.options?.sort,
-        };
-    // Initialize paging metadata separately (response data - doesn't trigger effect)
+    // Build query options from config. The filter/availabilityFilter/sort must
+    // be preserved even when services are prefetched (e.g. SSR), so loadMore
+    // keeps querying the same way and stays in availability mode. A pure
+    // showcase config (services without options) naturally yields just
+    // { appId } since these fields are absent.
+    const initialQueryOptions = {
+        appId,
+        filter: config.options?.filter,
+        availabilityFilter: config.options?.availabilityFilter,
+        sort: config.options?.sort,
+    };
+    // Initialize paging metadata separately (response data - doesn't trigger effect).
+    // Carries either offset (plain mode) or cursor (availability mode).
     const initialPagingMetadata = config.options
         ?.pagingMetadata || {
-        limit: DEFAULT_QUERY_LIMIT,
+        limit: constants_js_1.DEFAULT_QUERY_LIMIT,
         offset: 0,
         count: initialServices.length,
         hasNext: false,
@@ -159,6 +159,10 @@ exports.ServiceListService = services_definitions_1.implementService.withConfig(
             return true;
         });
     });
+    // Computed signal indicating whether an availability filter is currently
+    // applied. Reuses the same predicate as the API dispatch so the two can't
+    // drift. Exposed for the availability filter UI (follow-up PR).
+    const hasAvailabilityFilterSignal = signalsService.computed(() => (0, index_js_1.hasActiveAvailabilityFilter)(queryOptionsSignal.get().availabilityFilter));
     // Computed signal for effective filter - combines queryOptions.filter with location from BookingService
     const effectiveFilterSignal = signalsService.computed(() => {
         const filter = queryOptionsSignal.get().filter;
@@ -175,23 +179,21 @@ exports.ServiceListService = services_definitions_1.implementService.withConfig(
                 : {}),
         };
     });
-    // Initial fetch - runs once on client when no prefetched data
-    // Fetches both services AND categories in parallel
+    // Initial fetch - runs once on client when no prefetched data.
+    // Fetches both services AND categories in parallel.
     if (typeof window !== 'undefined' && !hasInitialServices) {
-        const initialQueryOptions = queryOptionsSignal.peek();
-        const currentPaging = pagingMetadataSignal.peek();
-        // Use effectiveFilterSignal.peek() to get the computed filter value
-        const effectiveFilter = effectiveFilterSignal.peek();
+        const options = queryOptionsSignal.peek();
         isLoadingSignal.set(true);
         Promise.allSettled([
             (0, index_js_1.queryServices)({
-                appId: initialQueryOptions.appId,
-                filter: effectiveFilter,
+                appId: options.appId,
+                filter: effectiveFilterSignal.peek(),
+                availabilityFilter: options.availabilityFilter,
                 pagingMetadata: {
-                    limit: currentPaging.limit,
+                    limit: pagingMetadataSignal.peek().limit,
                     offset: 0,
                 },
-                sort: initialQueryOptions.sort,
+                sort: options.sort,
             }),
             !hasInitialCategories ? (0, index_js_2.queryCategories)() : Promise.resolve(null),
         ])
@@ -215,37 +217,34 @@ exports.ServiceListService = services_definitions_1.implementService.withConfig(
             isLoadingSignal.set(false);
         });
     }
-    // Reactive effect - only handles query/filter changes (not initial fetch)
-    // IMPORTANT: Subscribes to effectiveFilterSignal which includes queryOptions.filter + location
+    // Re-fetch when query options or the effective filter (filter + location) change.
     if (typeof window !== 'undefined') {
         let isFirstEffectRun = true;
         signalsService.effect(async () => {
-            // CRITICAL: Read queryOptionsSignal and effectiveFilterSignal to establish dependencies
-            // effectiveFilterSignal already subscribes to bookingService.location internally
-            const queryOptions = queryOptionsSignal.get();
+            // Read both signals to establish dependencies.
+            const options = queryOptionsSignal.get();
             const effectiveFilter = effectiveFilterSignal.get();
-            // Skip first run - initial fetch is handled separately above
+            // Skip first run - initial fetch is handled separately above.
             if (isFirstEffectRun) {
                 isFirstEffectRun = false;
                 return;
             }
-            // Read paging metadata outside of dependency tracking for the fetch
-            const currentPaging = pagingMetadataSignal.peek();
             try {
                 isLoadingSignal.set(true);
                 servicesSignal.set([]);
                 errorSignal.set(null);
+                // Reset to the first page when query options change.
                 const result = await (0, index_js_1.queryServices)({
-                    appId: queryOptions.appId,
+                    appId: options.appId,
                     filter: effectiveFilter,
+                    availabilityFilter: options.availabilityFilter,
                     pagingMetadata: {
-                        limit: currentPaging.limit,
-                        offset: 0, // Reset to first page when query options change
+                        limit: pagingMetadataSignal.peek().limit,
+                        offset: 0,
                     },
-                    sort: queryOptions.sort,
+                    sort: options.sort,
                 });
                 servicesSignal.set(result.services);
-                // Update ONLY pagingMetadataSignal (not queryOptionsSignal) to avoid re-triggering effect
                 pagingMetadataSignal.set(result.pagingMetadata);
             }
             catch (error) {
@@ -256,29 +255,25 @@ exports.ServiceListService = services_definitions_1.implementService.withConfig(
             }
         });
     }
-    const loadMoreCursor = async (count) => {
-        const currentQueryOptions = queryOptionsSignal.get();
-        // Calculate next page offset based on current services count
-        const currentServicesCount = servicesSignal.get().length;
-        const nextOffset = currentServicesCount;
-        const nextPaging = {
-            limit: count || DEFAULT_QUERY_LIMIT,
-            offset: nextOffset,
-        };
-        // Get effective filter from computed signal (includes location from BookingService)
-        const effectiveFilter = effectiveFilterSignal.get();
+    const loadMore = async (count) => {
+        const options = queryOptionsSignal.peek();
+        const currentPaging = pagingMetadataSignal.peek();
         try {
             isLoadingSignal.set(true);
             errorSignal.set(null);
             const result = await (0, index_js_1.queryServices)({
-                appId: currentQueryOptions.appId,
-                filter: effectiveFilter,
-                pagingMetadata: nextPaging,
-                sort: currentQueryOptions.sort,
+                appId: options.appId,
+                filter: effectiveFilterSignal.peek(),
+                availabilityFilter: options.availabilityFilter,
+                pagingMetadata: {
+                    limit: count ?? currentPaging.limit ?? constants_js_1.DEFAULT_QUERY_LIMIT,
+                    // Offset (plain mode) and cursor (availability mode) — queryServices uses what it needs.
+                    offset: servicesSignal.peek().length,
+                    cursor: currentPaging.cursor,
+                },
+                sort: options.sort,
             });
-            // Append new services to existing ones
             servicesSignal.set([...servicesSignal.get(), ...result.services]);
-            // Update ONLY pagingMetadataSignal (not queryOptionsSignal)
             pagingMetadataSignal.set(result.pagingMetadata);
         }
         catch (error) {
@@ -297,101 +292,81 @@ exports.ServiceListService = services_definitions_1.implementService.withConfig(
         categoriesSignal,
         filterOptionsSignal,
         isFilteredSignal,
+        hasAvailabilityFilterSignal,
         effectiveFilterSignal,
         actions: {
-            loadMore: async (count) => {
-                await loadMoreCursor(count);
-            },
+            loadMore,
             setQueryOptions: (options) => {
-                // Reset services and paging when query options change
+                // Reset services and paging when query options change.
                 servicesSignal.set([]);
                 pagingMetadataSignal.set({
-                    limit: pagingMetadataSignal.get().limit || DEFAULT_QUERY_LIMIT,
+                    limit: pagingMetadataSignal.get().limit || constants_js_1.DEFAULT_QUERY_LIMIT,
                     offset: 0,
                     count: 0,
                     hasNext: false,
+                    cursor: undefined,
                 });
                 queryOptionsSignal.set(options);
             },
             setFilter: (filter) => {
-                // Update query options with new filter (triggers re-fetch via effectiveFilterSignal)
-                const currentOptions = queryOptionsSignal.get();
-                queryOptionsSignal.set({
-                    ...currentOptions,
-                    filter,
-                });
+                queryOptionsSignal.set({ ...queryOptionsSignal.get(), filter });
             },
             resetFilter: () => {
-                // Clear filter from query options (triggers re-fetch)
-                const currentOptions = queryOptionsSignal.get();
                 queryOptionsSignal.set({
-                    ...currentOptions,
+                    ...queryOptionsSignal.get(),
                     filter: undefined,
                 });
             },
             resetFilterField: (fieldName) => {
-                // Reset a specific filter field
-                const currentFilter = queryOptionsSignal.get().filter || {};
-                const newFilter = { ...currentFilter };
-                // Remove the specific field
+                const newFilter = { ...(queryOptionsSignal.get().filter || {}) };
                 delete newFilter[fieldName];
-                // Update query options with new filter (triggers re-fetch)
-                const currentOptions = queryOptionsSignal.get();
                 queryOptionsSignal.set({
-                    ...currentOptions,
+                    ...queryOptionsSignal.get(),
                     filter: Object.keys(newFilter).length > 0 ? newFilter : undefined,
                 });
             },
         },
-        hasMoreServicesSignal: signalsService.computed(() => {
-            const paging = pagingMetadataSignal.get();
-            // Use hasNext flag from pagingMetadata to determine if more services are available
-            return paging.hasNext ?? false;
-        }),
+        hasMoreServicesSignal: signalsService.computed(() => pagingMetadataSignal.get().hasNext ?? false),
     };
 });
 /**
- * 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.
+ * 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 },
+ * });
  * ```
  */
 async function loadServiceListServiceInitialData(options) {
     try {
-        // Fetch services and categories in parallel; categories failure is non-fatal
+        const appId = options.appId ?? constants_js_1.BOOKING_APP_ID;
+        // Fetch services and categories in parallel; categories failure is non-fatal.
+        // queryServices picks the endpoint by the presence of availabilityFilter.
         const [servicesResult, categoriesResult] = await Promise.all([
             (0, index_js_1.queryServices)({
-                appId: options.appId,
+                appId,
                 filter: options.filter,
                 pagingMetadata: options.pagingMetadata,
                 sort: options.sort,
+                availabilityFilter: options.availabilityFilter,
             }),
             (0, index_js_2.queryCategories)().catch(() => null),
         ]);
@@ -401,7 +376,10 @@ async function loadServiceListServiceInitialData(options) {
                 services: servicesResult.services,
                 categories: categoriesResult?.categories ?? [],
                 options: {
-                    ...options,
+                    appId,
+                    filter: options.filter,
+                    sort: options.sort,
+                    availabilityFilter: options.availabilityFilter,
                     pagingMetadata: servicesResult.pagingMetadata,
                 },
             },

package/dist/__mocks__/services/services-mocks.d.ts

@@ -5,7 +5,7 @@ import type { Service, StaffMember } from '@wix/auto_sdk_bookings_services';
 import type { ServiceServiceConfig } from '../../services/service/service.js';
 import type { ServiceListServiceConfig } from '../../services/service-list/service-list.js';
 import type { StaffMemberListServiceConfig } from '../../services/staff-member-list/staff-member-list.js';
-import type { PagingMetadata } from '../../api/query-services/index.js';
+import type { PagingMetadata, AvailabilityFilter, ServiceWithAvailabilityItem } from '../../api/query-services/index.js';
 import type { Category } from '../../api/query-categories/index.js';
 /**
  * Base mock service with all fields populated (APPOINTMENT type, FIXED pricing)
@@ -102,6 +102,22 @@ export declare const mockCategories: Category[];
  * Service list config with categories for filter testing
  */
 export declare const mockServiceListConfigWithCategories: ServiceListServiceConfig;
+/**
+ * Mock services enriched with an `available` flag (catalog-search results).
+ */
+export declare const mockServicesWithAvailability: ServiceWithAvailabilityItem[];
+/**
+ * Cursor-based paging metadata with a next cursor available.
+ */
+export declare const mockAvailabilityPagingMetadata: PagingMetadata;
+/**
+ * Cursor-based paging metadata for the last page (no next cursor).
+ */
+export declare const mockAvailabilityPagingMetadataLast: PagingMetadata;
+/**
+ * Mock availability filter (date window + timezone).
+ */
+export declare const mockAvailabilityFilter: AvailabilityFilter;
 /**
  * Base mock staff member with all fields
  */

package/dist/__mocks__/services/services-mocks.js

@@ -396,6 +396,40 @@ export const mockServiceListConfigWithCategories = {
     },
 };
 // ============================================================================
+// Availability (catalog-search) Mocks
+// ============================================================================
+/**
+ * Mock services enriched with an `available` flag (catalog-search results).
+ */
+export const mockServicesWithAvailability = mockServices.map((service, index) => ({
+    ...service,
+    available: index !== 2, // third service is unavailable
+}));
+/**
+ * Cursor-based paging metadata with a next cursor available.
+ */
+export const mockAvailabilityPagingMetadata = {
+    count: 3,
+    hasNext: true,
+    cursor: 'next-cursor-token',
+};
+/**
+ * Cursor-based paging metadata for the last page (no next cursor).
+ */
+export const mockAvailabilityPagingMetadataLast = {
+    count: 3,
+    hasNext: false,
+    cursor: undefined,
+};
+/**
+ * Mock availability filter (date window + timezone).
+ */
+export const mockAvailabilityFilter = {
+    localStartDate: '2026-06-01T09:00:00',
+    localEndDate: '2026-06-01T17:00:00',
+    timeZone: 'America/New_York',
+};
+// ============================================================================
 // Staff Member Mocks
 // ============================================================================
 /**

package/dist/api/index.d.ts

@@ -4,7 +4,7 @@
  *
  * @module API
  */
-export { getServiceById, getServiceBySlug, queryServices, convertPlatformFilterToApiFilter, type PagingMetadata, type QueryServicesRequest, SYNTHETIC_CUSTOM_ID, SYNTHETIC_CUSTOMER_ID, } from './query-services/index.js';
+export { getServiceById, getServiceBySlug, queryServices, convertPlatformFilterToApiFilter, type PagingMetadata, type QueryServicesRequest, type QueryServicesResult, type ServiceWithAvailabilityItem, AvailabilityLocationType, type AvailabilityFilter, type Attribute, type AvailabilityLocation, SYNTHETIC_CUSTOM_ID, SYNTHETIC_CUSTOMER_ID, } from './query-services/index.js';
 export { fetchAvailability } from './fetch-availability/index.js';
 export * from '@wix/auto_sdk_bookings_bookings';
 export { createBooking, type CreateBookingOptions, } from './create-booking/index.js';

package/dist/api/index.js

@@ -4,7 +4,7 @@
  *
  * @module API
  */
-export { getServiceById, getServiceBySlug, queryServices, convertPlatformFilterToApiFilter, SYNTHETIC_CUSTOM_ID, SYNTHETIC_CUSTOMER_ID, } from './query-services/index.js';
+export { getServiceById, getServiceBySlug, queryServices, convertPlatformFilterToApiFilter, AvailabilityLocationType, SYNTHETIC_CUSTOM_ID, SYNTHETIC_CUSTOMER_ID, } from './query-services/index.js';
 export { fetchAvailability } from './fetch-availability/index.js';
 export * from '@wix/auto_sdk_bookings_bookings';
 export { createBooking, } from './create-booking/index.js';

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 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>;