@wix/headless-bookings 0.0.1 → 0.0.2

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

@@ -0,0 +1,184 @@
+import { type Signal, type ReadOnlySignal } from '@wix/services-definitions/core-services/signals';
+import { services } from '@wix/bookings';
+export declare const DEFAULT_QUERY_LIMIT = 100;
+/**
+ * Configuration interface for the Services List service.
+ * Contains the initial services data, search options, and metadata.
+ *
+ * @interface ServicesListServiceConfig
+ */
+export interface ServicesListServiceConfig {
+    /** Array of service objects to initialize the service with */
+    services: services.Service[];
+    /** Search options used to fetch the services */
+    searchOptions?: {
+        cursorPaging?: {
+            limit: number;
+        };
+        filter?: Record<string, any>;
+        sort?: Array<{
+            fieldName: string;
+            order: 'ASC' | 'DESC';
+        }>;
+    };
+    /** Pagination metadata from the search response */
+    pagingMetadata?: {
+        count: number;
+        cursors?: {
+            next?: () => Promise<services.ServicesQueryResult>;
+            prev?: () => Promise<services.ServicesQueryResult>;
+        };
+        hasNext?: boolean;
+    };
+}
+/**
+ * Service definition for the Services List service.
+ * This defines the reactive API contract for managing a list of services with search, pagination, and filtering capabilities.
+ *
+ * @constant
+ */
+export declare const ServicesListServiceDefinition: string & {
+    __api: {
+        /** Reactive signal containing the list of services */
+        services: Signal<services.Service[]>;
+        /** Reactive signal containing pagination metadata */
+        pagingMetadata: Signal<ServicesListServiceConfig["pagingMetadata"]>;
+        /** Reactive signal indicating if services are currently being loaded */
+        isLoading: Signal<boolean>;
+        /** Reactive signal containing any error message, or null if no error*/
+        error: Signal<string | null>;
+        /** Reactive signal containing the current sort configuration */
+        sort: Signal<{
+            fieldName: string;
+            order: "ASC" | "DESC";
+        }[]>;
+        /** Reactive signal containing the current filter configuration */
+        filters: Signal<Record<string, any>>;
+        /** Function to update sort configuration */
+        setSort: (sort: {
+            fieldName: string;
+            order: "ASC" | "DESC";
+        }[]) => void;
+        /** Function to update filter configuration */
+        setFilter: (filter: Record<string, any>) => void;
+        /** Function to reset filter configuration */
+        resetFilter: () => void;
+        /** Reactive signal indicating if any filters are currently applied */
+        isFiltered: () => ReadOnlySignal<boolean>;
+        /** Function to load more services */
+        loadMore: (count: number) => void;
+        /** Reactive signal indicating if there are more services to load */
+        hasMoreServices: ReadOnlySignal<boolean>;
+    };
+    __config: ServicesListServiceConfig;
+    isServiceDefinition?: boolean;
+} & {
+    /** Reactive signal containing the list of services */
+    services: Signal<services.Service[]>;
+    /** Reactive signal containing pagination metadata */
+    pagingMetadata: Signal<ServicesListServiceConfig["pagingMetadata"]>;
+    /** Reactive signal indicating if services are currently being loaded */
+    isLoading: Signal<boolean>;
+    /** Reactive signal containing any error message, or null if no error*/
+    error: Signal<string | null>;
+    /** Reactive signal containing the current sort configuration */
+    sort: Signal<{
+        fieldName: string;
+        order: "ASC" | "DESC";
+    }[]>;
+    /** Reactive signal containing the current filter configuration */
+    filters: Signal<Record<string, any>>;
+    /** Function to update sort configuration */
+    setSort: (sort: {
+        fieldName: string;
+        order: "ASC" | "DESC";
+    }[]) => void;
+    /** Function to update filter configuration */
+    setFilter: (filter: Record<string, any>) => void;
+    /** Function to reset filter configuration */
+    resetFilter: () => void;
+    /** Reactive signal indicating if any filters are currently applied */
+    isFiltered: () => ReadOnlySignal<boolean>;
+    /** Function to load more services */
+    loadMore: (count: number) => void;
+    /** Reactive signal indicating if there are more services to load */
+    hasMoreServices: ReadOnlySignal<boolean>;
+};
+/**
+ * Implementation of the Services List service that manages reactive services data.
+ * This service provides signals for services data, search options, pagination,
+ * loading state, and error handling.
+ */
+export declare const ServicesListService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: {
+        /** Reactive signal containing the list of services */
+        services: Signal<services.Service[]>;
+        /** Reactive signal containing pagination metadata */
+        pagingMetadata: Signal<ServicesListServiceConfig["pagingMetadata"]>;
+        /** Reactive signal indicating if services are currently being loaded */
+        isLoading: Signal<boolean>;
+        /** Reactive signal containing any error message, or null if no error*/
+        error: Signal<string | null>;
+        /** Reactive signal containing the current sort configuration */
+        sort: Signal<{
+            fieldName: string;
+            order: "ASC" | "DESC";
+        }[]>;
+        /** Reactive signal containing the current filter configuration */
+        filters: Signal<Record<string, any>>;
+        /** Function to update sort configuration */
+        setSort: (sort: {
+            fieldName: string;
+            order: "ASC" | "DESC";
+        }[]) => void;
+        /** Function to update filter configuration */
+        setFilter: (filter: Record<string, any>) => void;
+        /** Function to reset filter configuration */
+        resetFilter: () => void;
+        /** Reactive signal indicating if any filters are currently applied */
+        isFiltered: () => ReadOnlySignal<boolean>;
+        /** Function to load more services */
+        loadMore: (count: number) => void;
+        /** Reactive signal indicating if there are more services to load */
+        hasMoreServices: ReadOnlySignal<boolean>;
+    };
+    __config: ServicesListServiceConfig;
+    isServiceDefinition?: boolean;
+} & {
+    /** Reactive signal containing the list of services */
+    services: Signal<services.Service[]>;
+    /** Reactive signal containing pagination metadata */
+    pagingMetadata: Signal<ServicesListServiceConfig["pagingMetadata"]>;
+    /** Reactive signal indicating if services are currently being loaded */
+    isLoading: Signal<boolean>;
+    /** Reactive signal containing any error message, or null if no error*/
+    error: Signal<string | null>;
+    /** Reactive signal containing the current sort configuration */
+    sort: Signal<{
+        fieldName: string;
+        order: "ASC" | "DESC";
+    }[]>;
+    /** Reactive signal containing the current filter configuration */
+    filters: Signal<Record<string, any>>;
+    /** Function to update sort configuration */
+    setSort: (sort: {
+        fieldName: string;
+        order: "ASC" | "DESC";
+    }[]) => void;
+    /** Function to update filter configuration */
+    setFilter: (filter: Record<string, any>) => void;
+    /** Function to reset filter configuration */
+    resetFilter: () => void;
+    /** Reactive signal indicating if any filters are currently applied */
+    isFiltered: () => ReadOnlySignal<boolean>;
+    /** Function to load more services */
+    loadMore: (count: number) => void;
+    /** Reactive signal indicating if there are more services to load */
+    hasMoreServices: ReadOnlySignal<boolean>;
+}, ServicesListServiceConfig>;
+/**
+ * Loads services list service configuration from the Wix Bookings API for SSR initialization.
+ * This function is designed to be used during Server-Side Rendering (SSR) to preload
+ * a list of services based on search criteria.
+ */
+export declare function loadServicesListServiceConfig(searchOptions?: ServicesListServiceConfig['searchOptions']): Promise<ServicesListServiceConfig>;

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

@@ -0,0 +1,168 @@
+import { defineService, implementService } from '@wix/services-definitions';
+import { SignalsServiceDefinition, } from '@wix/services-definitions/core-services/signals';
+import { services } from '@wix/bookings';
+export const DEFAULT_QUERY_LIMIT = 100;
+/**
+ * Fetches services using the Wix Bookings API.
+ * This function handles pagination and returns both services and metadata.
+ *
+ * @param searchOptions - The search options for querying services
+ * @returns Promise that resolves to the search result
+ */
+const fetchServices = async (searchOptions = {}) => {
+    try {
+        let query = services.queryServices();
+        // Apply pagination
+        if (searchOptions.cursorPaging?.limit) {
+            query = query.limit(searchOptions.cursorPaging.limit);
+        }
+        // Apply sorting
+        if (searchOptions.sort?.length) {
+            const { order, fieldName } = searchOptions.sort[0];
+            if (order === 'ASC') {
+                query = query.ascending(fieldName);
+            }
+            else {
+                query = query.descending(fieldName);
+            }
+        }
+        const result = await query.find();
+        return result;
+    }
+    catch (error) {
+        console.error('Error fetching services:', error);
+        throw error;
+    }
+};
+/**
+ * Service definition for the Services List service.
+ * This defines the reactive API contract for managing a list of services with search, pagination, and filtering capabilities.
+ *
+ * @constant
+ */
+export const ServicesListServiceDefinition = defineService('services-list');
+/**
+ * Implementation of the Services List service that manages reactive services data.
+ * This service provides signals for services data, search options, pagination,
+ * loading state, and error handling.
+ */
+export const ServicesListService = implementService.withConfig()(ServicesListServiceDefinition, ({ getService, config }) => {
+    let firstRun = true;
+    const signalsService = getService(SignalsServiceDefinition);
+    const servicesSignal = signalsService.signal(config.services);
+    const pagingMetadataSignal = signalsService.signal(config.pagingMetadata || { count: 0 });
+    const isLoadingSignal = signalsService.signal(false);
+    const errorSignal = signalsService.signal(null);
+    const sortSignal = signalsService.signal(config.searchOptions?.sort || []);
+    const filtersSignal = signalsService.signal(config.searchOptions?.filter || {});
+    if (typeof window !== 'undefined') {
+        signalsService.effect(async () => {
+            // Read signals to establish dependencies
+            const sort = sortSignal.get();
+            const filters = filtersSignal.get();
+            if (firstRun) {
+                firstRun = false;
+                return;
+            }
+            try {
+                isLoadingSignal.set(true);
+                const result = await fetchServices({
+                    cursorPaging: { limit: DEFAULT_QUERY_LIMIT },
+                    sort,
+                    filter: filters,
+                });
+                servicesSignal.set(result.items);
+                pagingMetadataSignal.set({
+                    count: result.totalCount || 0,
+                    cursors: {
+                        next: result.next,
+                        prev: result.prev,
+                    },
+                    hasNext: result.hasNext(),
+                });
+            }
+            catch (error) {
+                errorSignal.set(error instanceof Error ? error.message : 'Unknown error');
+            }
+            finally {
+                isLoadingSignal.set(false);
+            }
+        });
+    }
+    firstRun = false;
+    const loadMoreServices = async () => {
+        try {
+            isLoadingSignal.set(true);
+            const result = await pagingMetadataSignal?.peek()?.cursors?.next?.();
+            servicesSignal.set([
+                ...servicesSignal.peek(),
+                ...(result?.items ?? []),
+            ]);
+            pagingMetadataSignal.set({
+                count: result?.totalCount || 0,
+                cursors: {
+                    next: result?.next,
+                    prev: result?.prev,
+                },
+                hasNext: result?.hasNext(),
+            });
+        }
+        catch (error) {
+            errorSignal.set(error instanceof Error ? error.message : 'Unknown error');
+        }
+        finally {
+            isLoadingSignal.set(false);
+        }
+    };
+    return {
+        services: servicesSignal,
+        pagingMetadata: pagingMetadataSignal,
+        isLoading: isLoadingSignal,
+        error: errorSignal,
+        sort: sortSignal,
+        filters: filtersSignal,
+        setSort: (sort) => {
+            sortSignal.set(sort);
+        },
+        setFilter: (filter) => {
+            filtersSignal.set(filter);
+        },
+        resetFilter: () => {
+            filtersSignal.set({});
+        },
+        isFiltered: () => {
+            return signalsService.computed(() => {
+                const filters = filtersSignal.peek();
+                return Object.keys(filters).length > 0;
+            });
+        },
+        loadMore: loadMoreServices,
+        hasMoreServices: signalsService.computed(() => pagingMetadataSignal.get()?.hasNext ?? false),
+    };
+});
+/**
+ * Loads services list service configuration from the Wix Bookings API for SSR initialization.
+ * This function is designed to be used during Server-Side Rendering (SSR) to preload
+ * a list of services based on search criteria.
+ */
+export async function loadServicesListServiceConfig(searchOptions) {
+    try {
+        const result = await fetchServices(searchOptions);
+        return {
+            services: result.items ?? [],
+            searchOptions,
+            pagingMetadata: {
+                count: result.totalCount ?? 0,
+                cursors: {
+                    next: result.next,
+                    prev: result.prev,
+                },
+                hasNext: result.hasNext(),
+            },
+        };
+    }
+    catch (error) {
+        console.error('Error loading services configuration:', error);
+        throw error;
+    }
+}

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/react/ServiceList.d.ts

@@ -0,0 +1,50 @@
+import React from 'react';
+import { ServicesListServiceConfig } from '../services/services-list-service.js';
+import { services } from '@wix/bookings';
+/**
+ * Props for the ServiceList root component following the documented API
+ */
+export interface ServiceListRootProps {
+    children: ((props: {
+        services: services.Service[];
+    }) => React.ReactNode) | React.ReactNode;
+    services?: services.Service[];
+    servicesListConfig?: ServicesListServiceConfig;
+    className?: string;
+}
+/**
+ * Root component that provides the ServiceList context for rendering service lists.
+ * This component manages the service data and provides it to child components through context.
+ */
+export declare const List: React.ForwardRefExoticComponent<ServiceListRootProps & React.RefAttributes<HTMLDivElement>>;
+export interface ServiceOptionsProps {
+    children: ((props: {
+        services: services.Service[];
+    }) => React.ReactNode) | React.ReactNode;
+    emptyState?: React.ReactNode;
+    infiniteScroll?: boolean;
+    pageSize?: number;
+    className?: string;
+}
+export declare const Options: React.ForwardRefExoticComponent<ServiceOptionsProps & React.RefAttributes<HTMLDivElement>>;
+export interface ServiceRepeaterProps {
+    children: ((props: {
+        service: services.Service;
+    }) => React.ReactNode) | React.ReactNode;
+    className?: string;
+}
+export declare const ServiceRepeater: React.ForwardRefExoticComponent<ServiceRepeaterProps & React.RefAttributes<HTMLDivElement>>;
+export interface RawProps {
+    children: ((props: {
+        totalServices: number;
+        displayedServices: number;
+        isFiltered: boolean;
+    }) => React.ReactNode) | React.ReactNode;
+}
+export declare const Raw: React.ForwardRefExoticComponent<RawProps & React.RefAttributes<HTMLDivElement>>;
+export interface ErrorProps {
+    asChild?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+}
+export declare const Error: React.ForwardRefExoticComponent<ErrorProps & React.RefAttributes<HTMLDivElement>>;

package/dist/react/ServiceList.js

@@ -0,0 +1,100 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import React from 'react';
+import { useService } from '@wix/services-manager-react';
+import { TestIds } from './test-ids.js';
+import { AsChildSlot } from '@wix/headless-utils/react';
+import { Root as CoreServiceListRoot, Error as CoreServiceListError, } from './core/ServiceList.js';
+import { Root as CoreServiceRoot } from './core/Service.js';
+import { ServicesListServiceDefinition, } from '../services/services-list-service.js';
+/**
+ * Root component that provides the ServiceList context for rendering service lists.
+ * This component manages the service data and provides it to child components through context.
+ */
+export const List = React.forwardRef((props, ref) => {
+    const { children, services = [], servicesListConfig, className } = props;
+    const serviceConfig = servicesListConfig || {
+        services: services,
+        searchOptions: {
+            cursorPaging: { limit: 10 },
+        },
+        pagingMetadata: {
+            count: services?.length || 0,
+        },
+        aggregations: {
+            results: [],
+        },
+        customizations: [],
+    };
+    return (_jsx(CoreServiceListRoot, { servicesListConfig: serviceConfig, children: _jsx(ListContent, { children: children, className: className, ref: ref }) }));
+});
+List.displayName = 'Services.List';
+const ListContent = React.forwardRef((props, ref) => {
+    const { children, className } = props;
+    const servicesListService = useService(ServicesListServiceDefinition);
+    const services = servicesListService.services.get();
+    const pagingMetadata = servicesListService.pagingMetadata.get();
+    const displayedServices = services.length;
+    const totalServices = pagingMetadata?.count || services.length;
+    const isFiltered = Object.keys(servicesListService.filters.get()).length > 0;
+    const attributes = {
+        'data-testid': TestIds.servicesList,
+        'data-total-services': totalServices,
+        'data-displayed-services': displayedServices,
+        'data-filtered': isFiltered,
+        className,
+    };
+    return (_jsx("div", { ...attributes, ref: ref, children: typeof children === 'function' ? children({ services }) : children }));
+});
+export const Options = React.forwardRef((props, ref) => {
+    const { children, emptyState, infiniteScroll = true, pageSize = 0, className, } = props;
+    const servicesListService = useService(ServicesListServiceDefinition);
+    const services = servicesListService.services.get();
+    const hasServices = services.length > 0;
+    if (!hasServices) {
+        return emptyState || null;
+    }
+    const attributes = {
+        'data-testid': TestIds.servicesOptions,
+        'data-empty': !hasServices,
+        'data-infinite-scroll': infiniteScroll,
+        'data-page-size': pageSize,
+        className,
+    };
+    return (_jsx("div", { ...attributes, ref: ref, children: typeof children === 'function' ? children({ services }) : children }));
+});
+Options.displayName = 'Services.Options';
+export const ServiceRepeater = React.forwardRef((props, _ref) => {
+    const { children, className } = props;
+    const servicesListService = useService(ServicesListServiceDefinition);
+    const services = servicesListService.services.get();
+    const hasServices = services.length > 0;
+    if (!hasServices)
+        return null;
+    return (_jsx(_Fragment, { children: services.map((service) => (_jsx(CoreServiceRoot, { serviceConfig: { service }, "data-testid": TestIds.serviceRepeater, "data-service-id": service._id, className: className, children: typeof children === 'function' ? children({ service }) : children }, service._id))) }));
+});
+ServiceRepeater.displayName = 'Services.ServiceRepeater';
+export const Raw = React.forwardRef((props, ref) => {
+    const { children } = props;
+    const servicesListService = useService(ServicesListServiceDefinition);
+    const services = servicesListService.services.get();
+    const pagingMetadata = servicesListService.pagingMetadata.get();
+    const displayedServices = services.length;
+    const totalServices = pagingMetadata?.count || services.length;
+    const isFiltered = Object.keys(servicesListService.filters.get()).length > 0;
+    return (_jsx("div", { ref: ref, children: typeof children === 'function'
+            ? children({ totalServices, displayedServices, isFiltered })
+            : children }));
+});
+Raw.displayName = 'Services.Raw';
+export const Error = React.forwardRef((props, ref) => {
+    const { asChild, children, className, ...otherProps } = props;
+    return (_jsx(CoreServiceListError, { children: ({ error }) => {
+            if (!error) {
+                return null;
+            }
+            return (_jsx(AsChildSlot, { ref: ref, asChild: asChild, className: className, "data-testid": TestIds.serviceError, "data-error": error, customElement: children, customElementProps: {
+                    error,
+                }, content: error, ...otherProps, children: _jsx("div", { className: "text-status-error text-sm sm:text-base", children: error }) }));
+        } }));
+});
+Error.displayName = 'Services.Error';

package/dist/react/ServiceListSort.d.ts

@@ -0,0 +1,37 @@
+import React from 'react';
+import { Sort as SortPrimitive } from '@wix/headless-components/react';
+export interface ServiceListSortProps {
+    children: (props: {
+        currentSort: {
+            fieldName: string;
+            order: 'ASC' | 'DESC';
+        }[];
+        sortOptions: SortPrimitive.SortOption[];
+        setSort: (sort: {
+            fieldName: string;
+            order: 'ASC' | 'DESC';
+        }[]) => void;
+    }) => React.ReactNode;
+}
+export declare const ServiceListSort: (props: ServiceListSortProps) => React.ReactNode;
+export interface ServiceListSeparateSortProps {
+    children: (props: {
+        currentSort: {
+            fieldName: string;
+            order: 'ASC' | 'DESC';
+        }[];
+        sortFieldOptions: Array<{
+            fieldName: string;
+            label: string;
+        }>;
+        sortOrderOptions: Array<{
+            order: 'ASC' | 'DESC';
+            label: string;
+        }>;
+        setSort: (sort: {
+            fieldName: string;
+            order: 'ASC' | 'DESC';
+        }[]) => void;
+    }) => React.ReactNode;
+}
+export declare function ServiceListSeparateSort(props: ServiceListSeparateSortProps): React.ReactNode;

package/dist/react/ServiceListSort.js

@@ -0,0 +1,35 @@
+import { useService } from '@wix/services-manager-react';
+import { ServicesListServiceDefinition } from '../services/services-list-service.js';
+export const ServiceListSort = (props) => {
+    const servicesListService = useService(ServicesListServiceDefinition);
+    const currentSort = servicesListService.sort.get();
+    // Define sort options
+    const sortOptions = [
+        { fieldName: 'name', order: 'ASC', label: 'Name (A-Z)' },
+        { fieldName: 'name', order: 'DESC', label: 'Name (Z-A)' },
+    ];
+    return props.children({
+        currentSort,
+        sortOptions,
+        setSort: (sort) => {
+            servicesListService.setSort(sort);
+        },
+    });
+};
+export function ServiceListSeparateSort(props) {
+    const servicesListService = useService(ServicesListServiceDefinition);
+    const currentSort = servicesListService.sort.get();
+    const sortFieldOptions = [{ fieldName: 'name', label: 'Name' }];
+    const sortOrderOptions = [
+        { order: 'ASC', label: 'Ascending' },
+        { order: 'DESC', label: 'Descending' },
+    ];
+    return props.children({
+        currentSort,
+        sortFieldOptions,
+        sortOrderOptions,
+        setSort: (sort) => {
+            servicesListService.setSort(sort);
+        },
+    });
+}

package/dist/react/core/Service.d.ts

@@ -0,0 +1,91 @@
+import React from 'react';
+import { services } from '@wix/bookings';
+import { type ServiceServiceConfig } from '../../services/service-service.js';
+export interface RootProps {
+    children: React.ReactNode;
+    serviceConfig: ServiceServiceConfig;
+    className?: string;
+}
+export interface ServiceNameProps {
+    children: (props: ServiceNameRenderProps) => React.ReactNode;
+}
+export interface ServiceNameRenderProps {
+    name: string;
+}
+export interface ServiceDescriptionProps {
+    children: (props: ServiceDescriptionRenderProps) => React.ReactNode;
+}
+export interface ServiceDescriptionRenderProps {
+    description: string | null;
+}
+export interface ServicePriceProps {
+    children: (props: ServicePriceRenderProps) => React.ReactNode;
+}
+export interface ServicePriceRenderProps {
+    price: {
+        value: number;
+        currency: string;
+    } | null;
+}
+export interface ServiceImageRenderProps {
+    image: string | null;
+    alt: string;
+}
+export interface ServiceCategoryProps {
+    children: (props: ServiceCategoryRenderProps) => React.ReactNode;
+}
+export interface ServiceCategoryRenderProps {
+    category: {
+        name: string;
+    } | null;
+}
+export interface ServiceLoadingProps {
+    children: (props: ServiceLoadingRenderProps) => React.ReactNode;
+}
+export interface ServiceLoadingRenderProps {
+    isLoading: boolean;
+}
+export interface ServiceContentProps {
+    children: (props: ServiceContentRenderProps) => React.ReactNode;
+}
+export interface ServiceContentRenderProps {
+    service: services.Service;
+}
+declare function Content(props: ServiceContentProps): React.ReactNode;
+declare namespace Content {
+    var displayName: string;
+}
+declare function Loading(props: ServiceLoadingProps): React.ReactNode;
+declare namespace Loading {
+    var displayName: string;
+}
+export declare function Name(props: ServiceNameProps): React.ReactNode;
+export declare namespace Name {
+    var displayName: string;
+}
+export declare function Description(props: ServiceDescriptionProps): React.ReactNode;
+export declare namespace Description {
+    var displayName: string;
+}
+export declare function Price(props: ServicePriceProps): React.ReactNode;
+export declare namespace Price {
+    var displayName: string;
+}
+export declare function Image(): import("react/jsx-runtime").JSX.Element | null;
+export declare namespace Image {
+    var displayName: string;
+}
+export declare function Root(props: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Root {
+    var displayName: string;
+}
+export declare const Service: {
+    Root: typeof Root;
+    Content: typeof Content;
+    Loading: typeof Loading;
+    Name: typeof Name;
+    Description: typeof Description;
+    Price: typeof Price;
+    Image: typeof Image;
+};
+export {};