@wix/headless-restaurants-olo 0.0.0

package/dist/services/item-details-service.d.ts

@@ -0,0 +1,169 @@
+import { type Signal } from '@wix/services-definitions/core-services/signals';
+import { type LineItem } from '@wix/ecom/services';
+import { itemVariants } from '@wix/restaurants';
+import type { EnhancedItem } from '@wix/headless-restaurants-menus/services';
+import { AvailabilityStatus } from './common-types.js';
+type Variant = itemVariants.Variant;
+/**
+ * API interface for the Item Detailsservice, providing reactive item data management.
+ * This service handles loading and managing a single item's data, loading state, and errors.
+ *
+ * @interface ItemServiceAPI
+ */
+export interface ItemServiceAPI {
+    /** Reactive signal containing the current item data */
+    item?: Signal<EnhancedItem | undefined>;
+    quantity: Signal<number>;
+    specialRequest: Signal<string>;
+    lineItem: Signal<LineItem>;
+    selectedVariant: Signal<Variant | undefined>;
+    selectedModifiers: Signal<Record<string, Array<string>>>;
+    availabilityStatus: Signal<AvailabilityStatus>;
+    /** Reactive signal indicating if a item is currently being loaded */
+    isLoading: Signal<boolean>;
+    /** Reactive signal containing any error message, or null if no error */
+    error: Signal<string | null>;
+    /** Function to update the quantity of the item */
+    updateQuantity: (quantity: number) => void;
+    /** Function to update the special request of the item */
+    updateSpecialRequest: (specialRequest: string) => void;
+    /** Function to update the selected variant of the item */
+    updateSelectedVariant: (variant: Variant) => void;
+    /** Function to toggle a modifier instance in a specific group */
+    toggleModifier: (modifierGroupId: string, modifierId: string, singleSelect?: boolean) => void;
+    /** Function to get the selected modifiers for a specific group */
+    getSelectedModifiers: (modifierGroupId: string) => Array<string>;
+}
+/**
+ * Service definition for the Item service.
+ * This defines the contract that the ItemService must implement.
+ *
+ * @constant
+ */
+export declare const ItemServiceDefinition: string & {
+    __api: ItemServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & ItemServiceAPI;
+/**
+ * Configuration interface required to initialize the ItemService.
+ * Contains the initial item data that will be loaded into the service.
+ *
+ * @interface ItemServiceConfig
+ */
+export interface ItemServiceConfig {
+    /** The initial item data to configure the service with */
+    item?: EnhancedItem;
+    itemId?: string;
+    operationId?: string;
+    availabilityStatus?: AvailabilityStatus;
+}
+export declare const ItemService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: ItemServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & ItemServiceAPI, ItemServiceConfig>;
+/**
+ * Success result interface for item service configuration loading.
+ * Returned when a item is successfully found and loaded.
+ *
+ * @interface SuccessItemServiceConfigResult
+ */
+export interface SuccessItemServiceConfigResult {
+    /** Type "success" means that the item was found and the config is valid */
+    type: 'success';
+    /** The item config containing the loaded item data */
+    config: ItemServiceConfig;
+}
+/**
+ * Not found result interface for item service configuration loading.
+ * Returned when a item with the given id cannot be found.
+ *
+ * @interface NotFoundItemServiceConfigResult
+ */
+export interface NotFoundItemServiceConfigResult {
+    /** Type "notFound" means that the item was not found */
+    type: 'notFound';
+}
+/**
+ * Loads item service configuration from the Wix Items API for SSR initialization.
+ * This function is designed to be used during Server-Side Rendering (SSR) to preload
+ * a specific item by id that will be used to configure the ItemService.
+ *
+ * @param itemSlug The item id to load
+ * @returns Promise that resolves to ItemServiceConfigResult (success with config or notFound)
+ *
+ * @example
+ * ```astro
+ * ---
+ * // Astro page example - pages/item/[id].astro
+ * import { loadItemServiceConfig } from '@wix/stores/services';
+ * import { Item } from '@wix/stores/components';
+ *
+ * // Get item id from URL params
+ * const { id } = Astro.params;
+ *
+ * // Load item data during SSR
+ * const itemResult = await loadItemServiceConfig(id);
+ *
+ * // Handle not found case
+ * if (itemResult.type === 'notFound') {
+ *   return Astro.redirect('/404');
+ * }
+ * ---
+ *
+ * <Item.Root itemConfig={itemResult.config}>
+ *   <Item.Name>
+ *     {({ name }) => <h1>{name}</h1>}
+ *   </Item.Name>
+ * </Item.Root>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Next.js page example - pages/item/[id].tsx
+ * import { GetServerSideProps } from 'next';
+ * import { loadItemServiceConfig } from '@wix/stores/services';
+ * import { Item } from '@wix/stores/components';
+ *
+ * interface ItemPageProps {
+ *   itemConfig: Extract<Awaited<ReturnType<typeof loadItemServiceConfig>>, { type: 'success' }>['config'];
+ * }
+ *
+ * export const getServerSideProps: GetServerSideProps<ItemPageProps> = async ({ params }) => {
+ *   const id = params?.id as string;
+ *
+ *   // Load item data during SSR
+ *   const itemResult = await loadItemServiceConfig(id);
+ *
+ *   // Handle not found case
+ *   if (itemResult.type === 'notFound') {
+ *     return {
+ *       notFound: true,
+ *     };
+ *   }
+ *
+ *   return {
+ *     props: {
+ *       itemConfig: itemResult.config,
+ *     },
+ *   };
+ * };
+ *
+ * export default function ItemPage({ itemConfig }: ItemPageProps) {
+ *   return (
+ *     <Item.Root itemConfig={itemConfig}>
+ *       <Item.Name>
+ *         {({ name }) => <h1>{name}</h1>}
+ *       </Item.Name>
+ *     </Item.Root>
+ *   );
+ * }
+ * ```
+ */
+export declare function loadItemServiceConfig({ item, operationId, availabilityStatus, }: {
+    item: EnhancedItem;
+    operationId: string;
+    availabilityStatus?: AvailabilityStatus;
+}): ItemServiceConfig;
+export {};

package/dist/services/item-details-service.js

@@ -0,0 +1,248 @@
+import { defineService, implementService } from '@wix/services-definitions';
+import { SignalsServiceDefinition, } from '@wix/services-definitions/core-services/signals';
+import { AvailabilityStatus } from './common-types.js';
+import { getModifiersInitState } from './utils.js';
+/**
+ * Service definition for the Item service.
+ * This defines the contract that the ItemService must implement.
+ *
+ * @constant
+ */
+export const ItemServiceDefinition = defineService('item');
+/**
+ * Implementation of the Item service that manages reactive item data.
+ * This service provides signals for item data, loading state, and error handling,
+ * along with methods to dynamically load items.
+ *
+ * @example
+ * ```tsx
+ * import { ItemService, ItemServiceDefinition } from '@wix/stores/services';
+ * import { useService } from '@wix/services-manager-react';
+ *
+ * function ItemComponent({ itemConfig }) {
+ *   return (
+ *     <ServiceProvider services={createServicesMap([
+ *       [ItemServiceDefinition, ItemService.withConfig(itemConfig)]
+ *     ])}>
+ *       <ItemDisplay />
+ *     </ServiceProvider>
+ *   );
+ * }
+ *
+ * function ItemDisplay() {
+ *   const itemService = useService(ItemServiceDefinition);
+ *   const item = itemService.item.get();
+ *   const isLoading = itemService.isLoading.get();
+ *   const error = itemService.error.get();
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error}</div>;
+ *
+ *   return <h1>{item.name}</h1>;
+ * }
+ * ```
+ */
+const APP_ID = '9a5d83fd-8570-482e-81ab-cfa88942ee60';
+export const ItemService = implementService.withConfig()(ItemServiceDefinition, ({ getService, config }) => {
+    const signalsService = getService(SignalsServiceDefinition);
+    const availabilityStatus = signalsService.signal(config.availabilityStatus ?? AvailabilityStatus.AVAILABLE);
+    const item = signalsService.signal(config.item);
+    const isLoading = signalsService.signal(!!config.item);
+    const error = signalsService.signal(config.item ? null : 'Item not found');
+    const quantity = signalsService.signal(1);
+    const specialRequest = signalsService.signal('');
+    const lineItem = signalsService.signal({});
+    const priceVariants = config.item?.priceVariants || [];
+    const initialVariant = priceVariants.length > 0 ? priceVariants[0] : undefined;
+    const selectedVariant = signalsService.signal(initialVariant);
+    const modifierGroups = config.item?.modifierGroups || [];
+    const initialSelectedModifiers = getModifiersInitState(modifierGroups);
+    const selectedModifiers = signalsService.signal(initialSelectedModifiers);
+    if (config.item) {
+        console.log('config.item', config.item);
+        lineItem.set({
+            quantity: quantity.get(),
+            catalogReference: {
+                // @ts-expect-error - item is not typed
+                catalogItemId: config.item._id,
+                appId: APP_ID,
+                options: {
+                    operationId: config.operationId,
+                    // @ts-expect-error - item is not typed
+                    menuId: config.item.menuId,
+                    // @ts-expect-error - item is not typed
+                    sectionId: config.item.sectionId,
+                },
+            },
+        });
+    }
+    const updateQuantity = (_quantity) => {
+        quantity.set(_quantity);
+        const _lineItem = lineItem.get();
+        lineItem.set({
+            ..._lineItem,
+            quantity: _quantity,
+        });
+    };
+    const updateSpecialRequest = (_specialRequest) => {
+        specialRequest.set(_specialRequest);
+        const _lineItem = lineItem.get();
+        lineItem.set({
+            ..._lineItem,
+            catalogReference: {
+                ..._lineItem.catalogReference,
+                options: {
+                    ..._lineItem.catalogReference?.options,
+                    specialRequest: _specialRequest,
+                },
+            },
+        });
+    };
+    const updateSelectedVariant = (variant) => {
+        selectedVariant.set(variant);
+    };
+    const getModifierIds = (modifierGroupId, modifierId, singleSelect = false) => {
+        const currentSelectedModifiers = selectedModifiers.get();
+        const groupModifierIds = currentSelectedModifiers[modifierGroupId] || [];
+        // Check if this modifier is already selected
+        const isModifierSelected = groupModifierIds.includes(modifierId);
+        if (singleSelect) {
+            // Single select behavior: select the modifier, replacing any existing selection
+            return [modifierId];
+        }
+        else {
+            // Multi-select behavior: toggle the modifier
+            if (isModifierSelected) {
+                // Remove the modifier if it exists
+                const updatedModifierIds = groupModifierIds.filter((id) => id !== modifierId);
+                return updatedModifierIds;
+            }
+            else {
+                // Add the modifier to the existing selection
+                return [...groupModifierIds, modifierId];
+            }
+        }
+    };
+    const toggleModifier = (modifierGroupId, modifierId, singleSelect = false) => {
+        const currentSelectedModifiers = selectedModifiers.get();
+        const modifierIds = getModifierIds(modifierGroupId, modifierId, singleSelect);
+        selectedModifiers.set({
+            ...currentSelectedModifiers,
+            [modifierGroupId]: modifierIds,
+        });
+    };
+    const getSelectedModifiers = (modifierGroupId) => {
+        const currentSelectedModifiers = selectedModifiers.get();
+        return currentSelectedModifiers[modifierGroupId] || [];
+    };
+    return {
+        item,
+        quantity,
+        updateQuantity,
+        updateSpecialRequest,
+        updateSelectedVariant,
+        toggleModifier,
+        isLoading,
+        error,
+        specialRequest,
+        lineItem,
+        selectedVariant,
+        selectedModifiers,
+        availabilityStatus,
+        getSelectedModifiers,
+    };
+});
+/**
+ * Loads item service configuration from the Wix Items API for SSR initialization.
+ * This function is designed to be used during Server-Side Rendering (SSR) to preload
+ * a specific item by id that will be used to configure the ItemService.
+ *
+ * @param itemSlug The item id to load
+ * @returns Promise that resolves to ItemServiceConfigResult (success with config or notFound)
+ *
+ * @example
+ * ```astro
+ * ---
+ * // Astro page example - pages/item/[id].astro
+ * import { loadItemServiceConfig } from '@wix/stores/services';
+ * import { Item } from '@wix/stores/components';
+ *
+ * // Get item id from URL params
+ * const { id } = Astro.params;
+ *
+ * // Load item data during SSR
+ * const itemResult = await loadItemServiceConfig(id);
+ *
+ * // Handle not found case
+ * if (itemResult.type === 'notFound') {
+ *   return Astro.redirect('/404');
+ * }
+ * ---
+ *
+ * <Item.Root itemConfig={itemResult.config}>
+ *   <Item.Name>
+ *     {({ name }) => <h1>{name}</h1>}
+ *   </Item.Name>
+ * </Item.Root>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Next.js page example - pages/item/[id].tsx
+ * import { GetServerSideProps } from 'next';
+ * import { loadItemServiceConfig } from '@wix/stores/services';
+ * import { Item } from '@wix/stores/components';
+ *
+ * interface ItemPageProps {
+ *   itemConfig: Extract<Awaited<ReturnType<typeof loadItemServiceConfig>>, { type: 'success' }>['config'];
+ * }
+ *
+ * export const getServerSideProps: GetServerSideProps<ItemPageProps> = async ({ params }) => {
+ *   const id = params?.id as string;
+ *
+ *   // Load item data during SSR
+ *   const itemResult = await loadItemServiceConfig(id);
+ *
+ *   // Handle not found case
+ *   if (itemResult.type === 'notFound') {
+ *     return {
+ *       notFound: true,
+ *     };
+ *   }
+ *
+ *   return {
+ *     props: {
+ *       itemConfig: itemResult.config,
+ *     },
+ *   };
+ * };
+ *
+ * export default function ItemPage({ itemConfig }: ItemPageProps) {
+ *   return (
+ *     <Item.Root itemConfig={itemConfig}>
+ *       <Item.Name>
+ *         {({ name }) => <h1>{name}</h1>}
+ *       </Item.Name>
+ *     </Item.Root>
+ *   );
+ * }
+ * ```
+ */
+export function loadItemServiceConfig({ item, operationId, availabilityStatus = AvailabilityStatus.AVAILABLE, }) {
+    return { item, operationId, availabilityStatus };
+}
+// try {
+//   if (item === null) {
+//     return { item: null };
+//   }
+//   console.log('loadItemServiceConfig', item);
+//   const itemResponse = await loadItemById(item._id);
+//   console.log('itemResponse', itemResponse);
+//   if (!itemResponse) {
+//     return { item: itemResponse, item };
+//   }
+//   return { item: itemResponse };
+// } catch (error) {
+//   console.error(`Failed to load item "${itemId}":`, error);
+//   return { item: null, itemId };
+// }}

package/dist/services/olo-settings-service.d.ts

@@ -0,0 +1,37 @@
+import * as operationGroupsApi from '@wix/auto_sdk_restaurants_operation-groups';
+import * as operationsApi from '@wix/auto_sdk_restaurants_operations';
+import { type Signal } from '@wix/services-definitions/core-services/signals';
+export interface OLOSettingsServiceAPI {
+    operationGroup: Signal<operationGroupsApi.OperationGroup | undefined>;
+    operation: Signal<operationsApi.Operation | undefined>;
+    selectedItem?: Signal<unknown>;
+    isLoading: Signal<boolean>;
+    error: Signal<string | null>;
+    availabilityDispatchAction?: Signal<(() => void) | undefined>;
+}
+export interface OLOSettingsServiceConfig {
+    operationGroup?: operationGroupsApi.OperationGroup;
+    operation?: operationsApi.Operation;
+    availabilityDispatchAction?: () => void;
+}
+export declare const OLOSettingsServiceDefinition: string & {
+    __api: OLOSettingsServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & OLOSettingsServiceAPI;
+export declare const OLOSettingsService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: OLOSettingsServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & OLOSettingsServiceAPI, OLOSettingsServiceConfig>;
+export declare function loadOLOSettingsServiceConfig(): Promise<{
+    operationGroup: operationGroupsApi.OperationGroup | undefined;
+    operation: operationsApi.Operation | undefined;
+    isLoading?: undefined;
+    error?: undefined;
+} | {
+    operationGroup: undefined;
+    operation: undefined;
+    isLoading: boolean;
+    error: string;
+}>;

package/dist/services/olo-settings-service.js

@@ -0,0 +1,45 @@
+import { defineService, implementService } from '@wix/services-definitions';
+import * as operationGroupsApi from '@wix/auto_sdk_restaurants_operation-groups';
+import * as operationsApi from '@wix/auto_sdk_restaurants_operations';
+import { SignalsServiceDefinition, } from '@wix/services-definitions/core-services/signals';
+export const OLOSettingsServiceDefinition = defineService('oloSettings');
+export const OLOSettingsService = implementService.withConfig()(OLOSettingsServiceDefinition, ({ getService, config }) => {
+    const signalsService = getService(SignalsServiceDefinition);
+    const availabilityDispatchAction = signalsService.signal(config.availabilityDispatchAction);
+    const operationGroup = signalsService.signal(config.operationGroup);
+    const operation = signalsService.signal(config.operation);
+    const selectedItem = signalsService.signal(null);
+    const isLoading = signalsService.signal(false);
+    const error = signalsService.signal(null);
+    return {
+        operationGroup,
+        operation,
+        isLoading,
+        error,
+        selectedItem,
+        availabilityDispatchAction,
+    };
+});
+export async function loadOLOSettingsServiceConfig() {
+    try {
+        // Fetch operation groups and operations in parallel
+        const [operationGroupsResponse, operationsResponse] = await Promise.all([
+            operationGroupsApi.queryOperationGroups().find(),
+            operationsApi.queryOperation().find(),
+        ]);
+        return {
+            operationGroup: operationGroupsResponse.items[0] || undefined,
+            operation: operationsResponse.items[0] || undefined,
+        };
+    }
+    catch (error) {
+        console.error('Failed to load OLO settings service config:', error);
+        return {
+            operationGroup: undefined,
+            operation: undefined,
+            isLoading: false,
+            error: error?.message ||
+                'Failed to load OLO settings service config',
+        };
+    }
+}

package/dist/services/utils.d.ts

@@ -0,0 +1,20 @@
+import type { EnhancedModifier, EnhancedModifierGroup } from '@wix/headless-restaurants-menus/services';
+export declare const getModifiersInitState: (modifierGroups: EnhancedModifierGroup[]) => Record<string, string[]>;
+export declare const isSingleSelectRule: (rule: NonNullable<EnhancedModifierGroup["rule"]>) => boolean | null | undefined;
+export declare const getFirstPreSelectedModifier: (modifiers: EnhancedModifier[]) => string | null | undefined;
+export declare const getPreSelectedModifiers: (modifiers: EnhancedModifier[]) => string[];
+export declare const convertModifierToFormModifier: (modifier: EnhancedModifier, index: number) => {
+    _id: string;
+    revision?: string | null;
+    _createdDate?: Date | null;
+    _updatedDate?: Date | null;
+    name?: string | null;
+    extendedFields?: import("@wix/auto_sdk_restaurants_item-modifiers").ExtendedFields;
+    inStock?: boolean | null;
+    businessLocationIds?: string[];
+    additionalChargeInfo?: {
+        additionalCharge?: string;
+        formattedAdditionalCharge?: string;
+    };
+    preSelected?: boolean;
+};

package/dist/services/utils.js

@@ -0,0 +1,34 @@
+export const getModifiersInitState = (modifierGroups) => {
+    const initialSelectedModifiers = {};
+    modifierGroups.forEach((group) => {
+        if (group._id) {
+            const isMultiSelectItem = !isSingleSelectRule(group.rule ?? {});
+            const formModifiers = group.modifiers.map(convertModifierToFormModifier);
+            if (isMultiSelectItem) {
+                const preSelectedModifiers = getPreSelectedModifiers(formModifiers);
+                initialSelectedModifiers[group._id] = preSelectedModifiers;
+            }
+            else {
+                const preSelectedModifier = getFirstPreSelectedModifier(formModifiers);
+                initialSelectedModifiers[group._id] = preSelectedModifier
+                    ? [preSelectedModifier]
+                    : [];
+            }
+        }
+    });
+    return initialSelectedModifiers;
+};
+export const isSingleSelectRule = (rule) => rule.required && rule.minSelections === 1 && rule.maxSelections === 1;
+export const getFirstPreSelectedModifier = (modifiers) => modifiers.find(({ preSelected, inStock }) => preSelected && inStock)?._id;
+export const getPreSelectedModifiers = (modifiers) => modifiers.reduce((acc, modifier) => {
+    if (modifier.preSelected && modifier.inStock && modifier._id) {
+        return [...acc, modifier._id];
+    }
+    return acc;
+}, []);
+export const convertModifierToFormModifier = (modifier, index) => {
+    return {
+        ...modifier,
+        _id: `${modifier._id}~${index}`,
+    };
+};

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@wix/headless-restaurants-olo",
+  "version": "0.0.0",
+  "license": "MIT",
+  "type": "module",
+  "scripts": {
+    "prebuild": "cd ../components && yarn build && cd ../ecom && yarn build",
+    "build": "npm run build:esm && npm run build:cjs",
+    "build:esm": "tsc -p tsconfig.json",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "test": "vitest",
+    "lint:fix": "prettier --write \"src/**/*.{ts,tsx,js,jsx,json,md}\"",
+    "lint:check": "prettier --check \"src/**/*.{ts,tsx,js,jsx,json,md}\""
+  },
+  "files": [
+    "dist",
+    "cjs",
+    "react",
+    "services",
+    "server-actions",
+    "astro"
+  ],
+  "exports": {
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "import": "./dist/react/index.js",
+      "require": "./cjs/dist/react/index.js"
+    },
+    "./services": {
+      "types": "./dist/services/index.d.ts",
+      "import": "./dist/services/index.js",
+      "require": "./cjs/dist/services/index.js"
+    }
+  },
+  "devDependencies": {
+    "@testing-library/dom": "^10.4.0",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.3.0",
+    "@types/node": "^20.9.0",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "@vitest/ui": "^3.1.4",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-react": "^7.34.1",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "jsdom": "^26.1.0",
+    "prettier": "^3.4.2",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.4"
+  },
+  "dependencies": {
+    "@radix-ui/react-checkbox": "^1.3.3",
+    "@radix-ui/react-radio-group": "^1.1.3",
+    "@radix-ui/react-slot": "^1.1.0",
+    "@wix/auto_sdk_restaurants_items": "^1.0.48",
+    "@wix/ecom": "^1.0.1461",
+    "@wix/headless-media": "0.0.0",
+    "@wix/headless-restaurants-menus": "0.0.0",
+    "@wix/headless-utils": "0.0.0",
+    "@wix/redirects": "^1.0.0",
+    "@wix/restaurants": "^1.0.396",
+    "@wix/sdk": "^1.15.24",
+    "@wix/services-definitions": "^0.1.4",
+    "@wix/services-manager-react": "^0.1.26"
+  },
+  "peerDependencies": {
+    "@wix/headless-components": "workspace:*"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "wix": {
+    "artifact": {
+      "artifactId": "headless-restaurants-olo",
+      "groupId": "com.wixpress.headless-components"
+    }
+  },
+  "falconPackageHash": "554f40781c7d83a472b195ab0717a348ad238c53c9331339411f7ad8"
+}

package/react/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "../cjs/dist/react/index.js",
+  "types": "../dist/react/index.d.ts"
+}

package/services/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "../cjs/dist/services/index.js",
+  "types": "../dist/services/index.d.ts"
+}