medos-sdk 1.1.10 → 1.1.11

package/dist/components/validation.js

@@ -5,3 +5,44 @@ export const validatePhoneNumber = (phone) => {
 export const validateCountryCode = (code) => {
     return /^\+[1-9]\d{0,3}$/.test(code);
 };
+export const validateBloodGroup = (bloodGroup) => {
+    const validBloodGroups = [
+        "A+",
+        "A-",
+        "B+",
+        "B-",
+        "AB+",
+        "AB-",
+        "O+",
+        "O-",
+        "UNKNOWN",
+    ];
+    return validBloodGroups.includes(bloodGroup);
+};
+export const validateDateOfBirth = (dob) => {
+    if (!dob)
+        return false;
+    const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
+    if (!dateRegex.test(dob))
+        return false;
+    const [yearStr, monthStr, dayStr] = dob.split("-");
+    const year = parseInt(yearStr, 10);
+    const month = parseInt(monthStr, 10);
+    const day = parseInt(dayStr, 10);
+    if (month < 1 || month > 12 || day < 1 || day > 31)
+        return false;
+    const date = new Date(year, month - 1, day);
+    if (date.getFullYear() !== year ||
+        date.getMonth() !== month - 1 ||
+        date.getDate() !== day) {
+        return false;
+    }
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    date.setHours(0, 0, 0, 0);
+    if (date > today)
+        return false;
+    if (year < 1900)
+        return false;
+    return true;
+};

package/dist/core/theme/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./types";
 export * from "./themes";
 export * from "./utils";
+export * from "./responsive";

package/dist/core/theme/index.js

@@ -1,3 +1,4 @@
 export * from "./types";
 export * from "./themes";
 export * from "./utils";
+export * from "./responsive";

package/dist/core/theme/responsive.d.ts

@@ -0,0 +1,15 @@
+import { MedosTheme } from "./types";
+export type Breakpoint = "mobile" | "tablet" | "desktop" | "wide";
+export declare function useMediaQuery(query: string): boolean;
+export declare function useBreakpoint(theme: MedosTheme): Breakpoint;
+export declare function useIsMobile(theme: MedosTheme): boolean;
+export declare function useIsTablet(theme: MedosTheme): boolean;
+export declare function useIsDesktop(theme: MedosTheme): boolean;
+export declare function useResponsiveValue<T>(theme: MedosTheme, values: Partial<Record<Breakpoint, T>>): T | undefined;
+export declare function responsiveStyles(styles: Partial<Record<Breakpoint | "base", React.CSSProperties>>, currentBreakpoint: Breakpoint): React.CSSProperties;
+export declare function getResponsiveMaxWidth(theme: MedosTheme, breakpoint: Breakpoint, customMaxWidths?: Partial<Record<Breakpoint, string>>): string;
+export declare function getResponsivePadding(theme: MedosTheme, breakpoint: Breakpoint): string;
+export declare function getResponsiveFontSize(theme: MedosTheme, breakpoint: Breakpoint, size?: keyof MedosTheme["typography"]): string;
+export declare function isTouchDevice(): boolean;
+export declare const MIN_TOUCH_TARGET_SIZE = "44px";
+export declare function getResponsiveInputHeight(breakpoint: Breakpoint): string;

package/dist/core/theme/responsive.js

@@ -0,0 +1,113 @@
+import { useState, useEffect } from "react";
+export function useMediaQuery(query) {
+    const [matches, setMatches] = useState(false);
+    useEffect(() => {
+        const mediaQuery = window.matchMedia(query);
+        setMatches(mediaQuery.matches);
+        const handler = (event) => {
+            setMatches(event.matches);
+        };
+        if (mediaQuery.addEventListener) {
+            mediaQuery.addEventListener("change", handler);
+            return () => mediaQuery.removeEventListener("change", handler);
+        }
+        else {
+            mediaQuery.addListener(handler);
+            return () => mediaQuery.removeListener(handler);
+        }
+    }, [query]);
+    return matches;
+}
+export function useBreakpoint(theme) {
+    const isWide = useMediaQuery(`(min-width: ${theme.breakpoints.wide})`);
+    const isDesktop = useMediaQuery(`(min-width: ${theme.breakpoints.desktop})`);
+    const isTablet = useMediaQuery(`(min-width: ${theme.breakpoints.tablet})`);
+    if (isWide)
+        return "wide";
+    if (isDesktop)
+        return "desktop";
+    if (isTablet)
+        return "tablet";
+    return "mobile";
+}
+export function useIsMobile(theme) {
+    return useMediaQuery(`(max-width: ${parseInt(theme.breakpoints.tablet) - 1}px)`);
+}
+export function useIsTablet(theme) {
+    const minWidth = theme.breakpoints.tablet;
+    const maxWidth = `${parseInt(theme.breakpoints.desktop) - 1}px`;
+    return useMediaQuery(`(min-width: ${minWidth}) and (max-width: ${maxWidth})`);
+}
+export function useIsDesktop(theme) {
+    return useMediaQuery(`(min-width: ${theme.breakpoints.desktop})`);
+}
+export function useResponsiveValue(theme, values) {
+    const breakpoint = useBreakpoint(theme);
+    if (values[breakpoint] !== undefined) {
+        return values[breakpoint];
+    }
+    if (breakpoint === "wide" && values.desktop !== undefined) {
+        return values.desktop;
+    }
+    if ((breakpoint === "desktop" || breakpoint === "wide") &&
+        values.tablet !== undefined) {
+        return values.tablet;
+    }
+    if (values.mobile !== undefined) {
+        return values.mobile;
+    }
+    return undefined;
+}
+export function responsiveStyles(styles, currentBreakpoint) {
+    const baseStyles = styles.base || {};
+    const breakpointStyles = styles[currentBreakpoint] || {};
+    return {
+        ...baseStyles,
+        ...breakpointStyles,
+    };
+}
+export function getResponsiveMaxWidth(theme, breakpoint, customMaxWidths) {
+    if (customMaxWidths?.[breakpoint]) {
+        return customMaxWidths[breakpoint];
+    }
+    const defaults = {
+        mobile: "100%",
+        tablet: "100%",
+        desktop: "840px",
+        wide: "1200px",
+    };
+    return defaults[breakpoint];
+}
+export function getResponsivePadding(theme, breakpoint) {
+    const paddingMap = {
+        mobile: "md",
+        tablet: "lg",
+        desktop: "xl",
+        wide: "2xl",
+    };
+    return theme.spacing[paddingMap[breakpoint]];
+}
+export function getResponsiveFontSize(theme, breakpoint, size = "fontSizeMd") {
+    if (breakpoint === "mobile" && size.startsWith("fontSize")) {
+        const sizeMap = {
+            fontSize3xl: "fontSize2xl",
+            fontSize2xl: "fontSizeXl",
+            fontSizeXl: "fontSizeLg",
+            fontSizeLg: "fontSizeMd",
+        };
+        const adjustedSize = sizeMap[size] || size;
+        return theme.typography[adjustedSize];
+    }
+    return theme.typography[size];
+}
+export function isTouchDevice() {
+    return ("ontouchstart" in window ||
+        navigator.maxTouchPoints > 0 ||
+        navigator.msMaxTouchPoints > 0);
+}
+export const MIN_TOUCH_TARGET_SIZE = "44px";
+export function getResponsiveInputHeight(breakpoint) {
+    return breakpoint === "mobile" && isTouchDevice()
+        ? MIN_TOUCH_TARGET_SIZE
+        : "40px";
+}

package/dist/core/theme/themes.js

@@ -18,11 +18,11 @@ export const defaultTheme = {
         borderFocus: "#27903F",
         text: "#111827",
         textSecondary: "#374151",
-        textTertiary: "#6b7280",
+        textTertiary: "#4E8F50",
         textDisabled: "#9ca3af",
         textOnPrimary: "#fff",
         textOnSecondary: "#fff",
-        success: "#10b981",
+        success: "#4E8F50",
         successBackground: "#ecfdf5",
         successBorder: "#6ee7b7",
         error: "#ef4444",
@@ -84,6 +84,12 @@ export const defaultTheme = {
         normal: "200ms cubic-bezier(0.4, 0, 0.2, 1)",
         slow: "300ms cubic-bezier(0.4, 0, 0.2, 1)",
     },
+    breakpoints: {
+        mobile: "320px",
+        tablet: "768px",
+        desktop: "1024px",
+        wide: "1280px",
+    },
 };
 export const modernTheme = {
     name: "modern",
@@ -95,7 +101,7 @@ export const modernTheme = {
         secondaryHover: "#ff5722",
         accent: "#3b82f6",
         accentHover: "#2563eb",
-        background: "#ffffff",
+        background: "#fff",
         backgroundSecondary: "#f8fafc",
         backgroundTertiary: "#f1f5f9",
         surface: "#ffffff",
@@ -109,7 +115,7 @@ export const modernTheme = {
         textDisabled: "#cbd5e1",
         textOnPrimary: "#ffffff",
         textOnSecondary: "#ffffff",
-        success: "#10b981",
+        success: "#4E8F50",
         successBackground: "#ecfdf5",
         successBorder: "#6ee7b7",
         error: "#ef4444",
@@ -171,6 +177,12 @@ export const modernTheme = {
         normal: "200ms cubic-bezier(0.4, 0, 0.2, 1)",
         slow: "300ms cubic-bezier(0.4, 0, 0.2, 1)",
     },
+    breakpoints: {
+        mobile: "320px",
+        tablet: "768px",
+        desktop: "1024px",
+        wide: "1280px",
+    },
 };
 export const themes = {
     default: defaultTheme,

package/dist/core/theme/types.d.ts

@@ -82,6 +82,12 @@ export interface ThemeTransitions {
     normal: string;
     slow: string;
 }
+export interface ThemeBreakpoints {
+    mobile: string;
+    tablet: string;
+    desktop: string;
+    wide: string;
+}
 export interface MedosTheme {
     name: string;
     colors: ThemeColors;
@@ -90,6 +96,7 @@ export interface MedosTheme {
     shadows: ThemeShadows;
     radii: ThemeRadii;
     transitions: ThemeTransitions;
+    breakpoints: ThemeBreakpoints;
 }
 export type PartialTheme = {
     name?: string;
@@ -99,6 +106,7 @@ export type PartialTheme = {
     shadows?: Partial<ThemeShadows>;
     radii?: Partial<ThemeRadii>;
     transitions?: Partial<ThemeTransitions>;
+    breakpoints?: Partial<ThemeBreakpoints>;
 };
 export interface ThemeConfig {
     theme?: MedosTheme | PartialTheme;

package/dist/index.d.ts

@@ -14,3 +14,5 @@ export * from "./appointment-calendar/types";
 export * from "./enquiry-form/provider";
 export * from "./enquiry-form/types";
 export { PatientService, SendPhoneVerificationOtpPayload, VerifyPhoneVerificationOtpPayload, } from "./services/PatientService";
+export { WorkspaceService } from "./services/WorkspaceService";
+export type { WorkspaceResponse, Address, ConsultationType, User, Doctor, AddressDoctor, } from "./services/WorkspaceService";

package/dist/index.js

@@ -12,3 +12,4 @@ export * from "./appointment-calendar/types";
 export * from "./enquiry-form/provider";
 export * from "./enquiry-form/types";
 export { PatientService, } from "./services/PatientService";
+export { WorkspaceService } from "./services/WorkspaceService";

package/dist/react/ThemeProvider.d.ts

@@ -10,8 +10,9 @@ export interface MedosThemeProviderProps {
     children: React.ReactNode;
     theme?: ThemeName | MedosTheme | PartialTheme;
     cssVariablePrefix?: string;
+    onThemeError?: (error: Error) => void;
 }
-export declare function MedosThemeProvider({ children, theme, cssVariablePrefix, }: MedosThemeProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function MedosThemeProvider({ children, theme, cssVariablePrefix, onThemeError, }: Readonly<MedosThemeProviderProps>): import("react/jsx-runtime").JSX.Element;
 export declare function useThemeContext(): ThemeContextValue;
 export declare function useTheme(): MedosTheme;
 export declare function useCssVar(category: string, key: string, fallback?: string): string;

package/dist/react/ThemeProvider.js

@@ -2,20 +2,59 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import React, { createContext, useMemo } from "react";
 import { defaultTheme, themes } from "../core/theme/themes";
 import { mergeTheme, generateCssVariablesObject } from "../core/theme/utils";
+import { MedosClient } from "../client/MedosClient";
 const ThemeContext = createContext(undefined);
-export function MedosThemeProvider({ children, theme, cssVariablePrefix = "medos", }) {
-    const resolvedTheme = useMemo(() => {
-        if (!theme) {
-            return defaultTheme;
+export function MedosThemeProvider({ children, theme, cssVariablePrefix = "medos", onThemeError, }) {
+    const [apiTheme, setApiTheme] = React.useState(null);
+    React.useEffect(() => {
+        if (theme !== undefined) {
+            return;
         }
-        if (typeof theme === "string") {
-            return themes[theme] || defaultTheme;
+        let isMounted = true;
+        const fetchThemeFromApi = async () => {
+            try {
+                const fetchedTheme = await MedosClient.fetchTheme();
+                if (isMounted) {
+                    if (fetchedTheme &&
+                        (fetchedTheme === "default" || fetchedTheme === "modern")) {
+                        setApiTheme(fetchedTheme);
+                    }
+                    else {
+                        setApiTheme(null);
+                    }
+                }
+            }
+            catch (error) {
+                if (isMounted) {
+                    if (onThemeError) {
+                        onThemeError(error);
+                    }
+                    else {
+                        console.warn("Failed to fetch theme from API, using default theme:", error);
+                    }
+                }
+            }
+        };
+        fetchThemeFromApi();
+        return () => {
+            isMounted = false;
+        };
+    }, [theme, onThemeError]);
+    const resolvedTheme = useMemo(() => {
+        if (theme !== undefined) {
+            if (typeof theme === "string") {
+                return themes[theme] || defaultTheme;
+            }
+            if ("name" in theme && "colors" in theme && "typography" in theme) {
+                return theme;
+            }
+            return mergeTheme(theme);
         }
-        if ("name" in theme && "colors" in theme && "typography" in theme) {
-            return theme;
+        if (apiTheme) {
+            return themes[apiTheme] || defaultTheme;
         }
-        return mergeTheme(theme);
-    }, [theme]);
+        return defaultTheme;
+    }, [theme, apiTheme]);
     const cssVars = useMemo(() => generateCssVariablesObject(resolvedTheme, cssVariablePrefix), [resolvedTheme, cssVariablePrefix]);
     const contextValue = useMemo(() => ({
         theme: resolvedTheme,

package/dist/services/AppointmentService.d.ts

@@ -11,6 +11,7 @@ export type Slot = {
     [key: string]: any;
 };
 type PatientPayload = {
+    id?: number;
     firstName: string;
     lastName: string;
     email?: string;
@@ -18,6 +19,8 @@ type PatientPayload = {
     phoneNumber: string;
     age?: number;
     gender?: "MALE" | "FEMALE" | "OTHER";
+    dob?: string;
+    bloodGroup?: string;
 };
 type PatientAddressPayload = {
     addressLine1: string;
@@ -26,6 +29,11 @@ type PatientAddressPayload = {
     country: string;
     zipcode: string;
     landmark?: string;
+    addressLine2?: string;
+    completeAddress?: string;
+    countryCode?: string;
+    phoneNumber?: string;
+    patientId?: number;
 };
 type BookAppointmentPayload = {
     workspaceId?: string | number;
@@ -35,13 +43,79 @@ type BookAppointmentPayload = {
     appointmentDate: string;
     fromDateTimeTs: string;
     toDateTimeTs: string;
-    consultationCharge?: string;
+    consultationCharge?: string | number;
     type?: "CONSULTATION" | string;
     source?: string;
+    bookingType?: "PACKAGE_PURCHASE" | "ONE_TIME_APPOINTMENT" | "USE_ACTIVE_PACKAGE";
+    paymentMode?: "CASH" | "CARD" | string;
+    packageConfigId?: number;
+    patientPackageId?: number;
+    packageAmount?: number;
     patientPayload: PatientPayload;
     patientAddress: PatientAddressPayload;
     attachments?: File[];
 };
+export type UnifiedBookAppointmentPayload = {
+    workspaceId: number;
+    workspaceAddressId: number;
+    doctorId: number;
+    mode: "ONLINE" | "OFFLINE";
+    appointmentDate: string;
+    fromDateTimeTs: string;
+    toDateTimeTs: string;
+    bookingType: "PACKAGE_PURCHASE" | "ONE_TIME_APPOINTMENT" | "USE_ACTIVE_PACKAGE";
+    consultationCharge: number;
+    packageConfigId?: number;
+    patientPackageId?: number;
+    packageAmount?: number;
+    paymentMode: "CASH" | "CARD" | string;
+    type: "CONSULTATION" | string;
+    source: string;
+    patientPayload: {
+        id?: number;
+        firstName: string;
+        lastName: string;
+        email: string;
+        countryCode: string;
+        phoneNumber: string;
+        dob: string;
+        age: number;
+        gender: "MALE" | "FEMALE" | "OTHER";
+        bloodGroup: string;
+    };
+    patientAddress: {
+        completeAddress: string;
+        addressLine1: string;
+        addressLine2?: string;
+        city: string;
+        state: string;
+        country: string;
+        zipcode: string;
+        landmark?: string;
+        countryCode: string;
+        phoneNumber: string;
+        patientId: number;
+    };
+};
+export type AppointmentResponse = {
+    id: number;
+    patientName: string;
+    patientEmail: string;
+    patientPhone: string;
+    doctorId: number;
+    addressId: number;
+    appointmentDate: string;
+    startTime: string;
+    endTime: string;
+    status: string;
+    consultationCharge: number;
+    paymentMode: string;
+    type: string;
+    mode: string;
+    notes?: string;
+    createdAt: string;
+    [key: string]: any;
+};
 type AppointmentPayload = {
     workspaceId?: string | number;
     workspaceAddressId: string | number;
@@ -78,8 +152,12 @@ type AddressesResponse = {
     addresses: AddressItem[];
 };
 declare const AppointmentService: {
+    arePackagesConfigured(): Promise<boolean>;
     getAddresses(): Promise<AddressesResponse>;
     fetchSlots(workspaceId: number, addressId: number, doctorId: number, appointmentDate: string): Promise<Slot[]>;
-    createAppointment(payload: BookAppointmentPayload): Promise<any>;
+    transformToUnifiedPayload(payload: BookAppointmentPayload): UnifiedBookAppointmentPayload;
+    createLegacyAppointment(payload: BookAppointmentPayload): Promise<AppointmentResponse>;
+    createAppointment(payload: BookAppointmentPayload): Promise<AppointmentResponse>;
+    createUnifiedAppointment(payload: BookAppointmentPayload): Promise<AppointmentResponse>;
 };
 export { AppointmentService, AppointmentPayload, BookAppointmentPayload, PatientPayload, PatientAddressPayload, AddressesResponse, AddressItem, };

package/dist/services/AppointmentService.js

@@ -1,5 +1,17 @@
 import { MedosClient } from "../client/MedosClient";
+import { mapBloodGroupToApi } from "../components/types";
+import { WorkspaceService } from "./WorkspaceService";
 const AppointmentService = {
+    async arePackagesConfigured() {
+        try {
+            const workspace = await WorkspaceService.fetchWorkspace();
+            return workspace.arePackagesConfigured === true;
+        }
+        catch (error) {
+            console.warn("Failed to check package configuration, defaulting to legacy endpoint:", error);
+            return false;
+        }
+    },
     async getAddresses() {
         const client = await MedosClient.ensureInitialized();
         const res = await client.get("/workspaces");
@@ -73,16 +85,82 @@ const AppointmentService = {
         }
         return [];
     },
-    async createAppointment(payload) {
+    transformToUnifiedPayload(payload) {
+        const consultationCharge = typeof payload.consultationCharge === "string"
+            ? Number.parseFloat(payload.consultationCharge) || 0
+            : payload.consultationCharge || 0;
+        const completeAddress = [
+            payload.patientAddress.addressLine1,
+            payload.patientAddress.addressLine2,
+            payload.patientAddress.city,
+            payload.patientAddress.state,
+            payload.patientAddress.country,
+            payload.patientAddress.zipcode,
+        ]
+            .filter(Boolean)
+            .join(", ");
+        const unifiedPayload = {
+            workspaceId: Number(payload.workspaceId || 0),
+            workspaceAddressId: Number(payload.workspaceAddressId),
+            doctorId: Number(payload.doctorId),
+            mode: (payload.mode || "OFFLINE"),
+            appointmentDate: payload.appointmentDate,
+            fromDateTimeTs: payload.fromDateTimeTs,
+            toDateTimeTs: payload.toDateTimeTs,
+            bookingType: payload.bookingType || "ONE_TIME_APPOINTMENT",
+            consultationCharge,
+            paymentMode: payload.paymentMode || "CASH",
+            type: payload.type || "CONSULTATION",
+            source: payload.source || "SDK_POWERED_WEBSITE",
+            patientPayload: {
+                id: payload.patientPayload.id,
+                firstName: payload.patientPayload.firstName,
+                lastName: payload.patientPayload.lastName,
+                email: payload.patientPayload.email || "",
+                countryCode: payload.patientPayload.countryCode,
+                phoneNumber: payload.patientPayload.phoneNumber,
+                dob: payload.patientPayload.dob || "",
+                age: payload.patientPayload.age || 0,
+                gender: (payload.patientPayload.gender || "OTHER"),
+                bloodGroup: payload.patientPayload.bloodGroup
+                    ? mapBloodGroupToApi(payload.patientPayload.bloodGroup)
+                    : "UNKNOWN",
+            },
+            patientAddress: {
+                completeAddress,
+                addressLine1: payload.patientAddress.addressLine1,
+                addressLine2: payload.patientAddress.addressLine2,
+                city: payload.patientAddress.city,
+                state: payload.patientAddress.state,
+                country: payload.patientAddress.country,
+                zipcode: payload.patientAddress.zipcode,
+                landmark: payload.patientAddress.landmark,
+                countryCode: payload.patientAddress.countryCode || "",
+                phoneNumber: payload.patientAddress.phoneNumber || "",
+                patientId: payload.patientAddress.patientId || 0,
+            },
+        };
+        if (payload.packageConfigId) {
+            unifiedPayload.packageConfigId = payload.packageConfigId;
+        }
+        if (payload.patientPackageId) {
+            unifiedPayload.patientPackageId = payload.patientPackageId;
+        }
+        if (payload.packageAmount) {
+            unifiedPayload.packageAmount = payload.packageAmount;
+        }
+        return unifiedPayload;
+    },
+    async createLegacyAppointment(payload) {
         const client = await MedosClient.ensureInitialized();
-        const appointmentData = {
+        const legacyPayload = {
             workspaceAddressId: payload.workspaceAddressId,
             doctorId: payload.doctorId,
             mode: payload.mode || "OFFLINE",
             appointmentDate: payload.appointmentDate,
             fromDateTimeTs: payload.fromDateTimeTs,
             toDateTimeTs: payload.toDateTimeTs,
-            consultationCharge: payload.consultationCharge || "0",
+            consultationCharge: payload.consultationCharge,
             type: payload.type || "CONSULTATION",
             source: payload.source || "SDK_POWERED_WEBSITE",
             patientPayload: payload.patientPayload,
@@ -90,7 +168,7 @@ const AppointmentService = {
         };
         if (payload.attachments && payload.attachments.length > 0) {
             const formData = new FormData();
-            const payloadString = JSON.stringify(appointmentData);
+            const payloadString = JSON.stringify(legacyPayload);
             formData.append("payload", payloadString);
             payload.attachments.forEach((file) => {
                 formData.append("attachments", file);
@@ -99,7 +177,38 @@ const AppointmentService = {
             return res.data;
         }
         else {
-            const res = await client.post("/appointments/book-appointment", appointmentData, {
+            const res = await client.post("/appointments/book-appointment", legacyPayload, {
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            });
+            return res.data;
+        }
+    },
+    async createAppointment(payload) {
+        const packagesConfigured = await this.arePackagesConfigured();
+        if (packagesConfigured) {
+            return this.createUnifiedAppointment(payload);
+        }
+        else {
+            return this.createLegacyAppointment(payload);
+        }
+    },
+    async createUnifiedAppointment(payload) {
+        const client = await MedosClient.ensureInitialized();
+        const unifiedPayload = this.transformToUnifiedPayload(payload);
+        if (payload.attachments && payload.attachments.length > 0) {
+            const formData = new FormData();
+            const payloadString = JSON.stringify(unifiedPayload);
+            formData.append("payload", payloadString);
+            payload.attachments.forEach((file) => {
+                formData.append("attachments", file);
+            });
+            const res = await client.post("/appointments/book-appointment-unified", formData);
+            return res.data;
+        }
+        else {
+            const res = await client.post("/appointments/book-appointment-unified", unifiedPayload, {
                 headers: {
                     "Content-Type": "application/json",
                 },