medos-sdk 1.1.9 → 1.1.10

package/dist/components/appointment-booking/AppointmentCalender.js

@@ -0,0 +1,107 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { AppointmentDateTimeModal } from "../AppointmentDateTimeModal";
+import { DoctorSelectModal } from "../DoctorSelectModal";
+import { PhoneVerificationStep } from "../PhoneVerificationStep";
+import { PatientDetailsStep } from "../PatientDetailsStep";
+import AppointmentConfirmationStep from "../AppointmentConfirmationStep";
+import { useTheme } from "../../react/hooks/useTheme";
+import MedosLogo from "../Icons/MedosLogo";
+import { useAppointmentState, useAppointmentFlow, useInitializeAddresses, } from "./hooks";
+import { formatDateToISO } from "../utils";
+export const AppointmentCalender = ({ onError, }) => {
+    const { state, dispatch, setStep, resetForm } = useAppointmentState();
+    const { goBack, goToNext, handleDateChange, sendOtp, verifyOtp, submitAppointment, } = useAppointmentFlow(state, dispatch, onError);
+    useInitializeAddresses(dispatch, onError);
+    const handleDoctorSelect = (addrId, docId) => {
+        dispatch({ type: "SET_SELECTED_ADDRESS", payload: addrId });
+        dispatch({ type: "SET_SELECTED_DOCTOR", payload: docId });
+        setStep(1);
+    };
+    const handleDateTimeModalContinue = (mode, date, slot, charge) => {
+        dispatch({ type: "SET_CONSULTATION_MODE", payload: mode });
+        dispatch({ type: "SET_SELECTED_DATE", payload: date });
+        dispatch({ type: "SET_SELECTED_SLOT", payload: slot });
+        dispatch({ type: "SET_CONSULTATION_CHARGE", payload: charge });
+        setStep(3);
+    };
+    const theme = useTheme();
+    const styles = getStyles(theme);
+    return (_jsx("div", { style: styles.container, children: _jsxs("div", { style: styles.card, children: [_jsx("div", { style: styles.header, children: _jsx("h2", { style: styles.title, children: "Book Appointment" }) }), _jsx("hr", {}), _jsxs("div", { style: styles.content, children: [state.loading && _jsx("div", { style: { marginBottom: 12 }, children: "Loading..." }), state.error && _jsx("div", { style: styles.errorMessage, children: state.error }), state.step === 0 && (_jsx(DoctorSelectModal, { addresses: state.addresses, addressDoctorsMap: state.addressDoctorsMap, selectedAddressId: state.selectedAddress, selectedDoctorId: state.selectedDoctor, onCancel: () => setStep(0), onContinue: handleDoctorSelect })), state.step === 1 && (_jsx(AppointmentDateTimeModal, { onlineFee: 500, offlineFee: 300, slots: state.slots, selectedDate: state.selectedDate, selectedSlot: state.selectedSlot, consultationMode: state.consultationMode, onCancel: goBack, onDateChange: handleDateChange, onContinue: handleDateTimeModalContinue })), state.step === 3 && (_jsx(PhoneVerificationStep, { state: state, dispatch: dispatch, onSendOtp: sendOtp, onVerifyOtp: verifyOtp, onBack: goBack, onContinue: goToNext })), state.step === 4 && (_jsx(PatientDetailsStep, { state: state, dispatch: dispatch, onBack: goBack, onSubmit: submitAppointment })), state.step === 5 && (_jsx(AppointmentConfirmationStep, { appointment: {
+                                patientName: state.patientName,
+                                visitationType: state.consultationMode === "ONLINE"
+                                    ? "Online Consultation"
+                                    : "In-Person Visit",
+                                appointmentDate: formatDateToISO(state.selectedDate),
+                                fromTime: state.selectedSlot?.start
+                                    ? new Date(state.selectedSlot.start)
+                                        .toTimeString()
+                                        .slice(0, 5)
+                                    : "",
+                                toTime: state.selectedSlot?.end
+                                    ? new Date(state.selectedSlot.end).toTimeString().slice(0, 5)
+                                    : "",
+                                location: state.addresses.find((addr) => addr.id === state.selectedAddress)?.label || "Clinic",
+                                mode: state.consultationMode,
+                                paymentMode: "Cash",
+                            }, patient: {
+                                patientName: state.patientName,
+                            }, selectedDoctor: state.selectedAddress && state.selectedDoctor
+                                ? state.addressDoctorsMap[state.selectedAddress]?.find((doc) => doc.id === state.selectedDoctor) || null
+                                : null, selectedAddress: state.selectedAddress
+                                ? state.addresses.find((addr) => addr.id === state.selectedAddress) || null
+                                : null, onClose: resetForm })), _jsxs("div", { style: styles.branding, children: [_jsx("span", { style: styles.poweredBy, children: "Powered by" }), _jsx("a", { href: "https://medos.one", target: "_blank", rel: "noopener noreferrer", children: _jsx(MedosLogo, { style: { height: 50, width: "auto" } }) })] })] })] }) }));
+};
+const getStyles = (theme) => ({
+    container: {
+        display: "flex",
+        justifyContent: "center",
+        padding: 20,
+        fontFamily: theme.typography.fontFamily,
+        background: theme.colors.background,
+    },
+    card: {
+        width: "100%",
+        maxWidth: 840,
+        background: theme.colors.surface,
+        borderRadius: theme.radii.lg,
+        boxShadow: theme.shadows.lg,
+        overflow: "hidden",
+        boxSizing: "border-box",
+    },
+    header: {
+        padding: "20px 24px",
+    },
+    title: {
+        margin: 0,
+        fontSize: theme.typography.fontSizeXl,
+        fontWeight: theme.typography.fontWeightSemibold,
+    },
+    content: {
+        padding: 24,
+    },
+    errorMessage: {
+        marginBottom: 12,
+        color: theme.colors.error,
+        fontWeight: 600,
+        padding: "12px",
+        background: theme.colors.errorBackground,
+        borderRadius: theme.radii.md,
+        border: `1px solid ${theme.colors.errorBorder}`,
+        fontSize: theme.typography.fontSizeSm,
+    },
+    branding: {
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        gap: 8,
+        marginTop: 24,
+        paddingTop: 16,
+        borderTop: `1px solid ${theme.colors.border}`,
+        opacity: 0.8,
+    },
+    poweredBy: {
+        fontSize: 12,
+        color: theme.colors.textSecondary,
+        fontWeight: 500,
+    },
+});

package/dist/components/appointment-booking/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export { useAppointmentState } from "./useAppointmentState";
+export { useAppointmentFlow } from "./useAppointmentFlow";
+export { useInitializeAddresses } from "./useInitializeAddresses";

package/dist/components/appointment-booking/hooks/index.js

@@ -0,0 +1,3 @@
+export { useAppointmentState } from "./useAppointmentState";
+export { useAppointmentFlow } from "./useAppointmentFlow";
+export { useInitializeAddresses } from "./useInitializeAddresses";

package/dist/components/appointment-booking/hooks/useAppointmentFlow.d.ts

@@ -0,0 +1,9 @@
+import { AppointmentState } from "../types";
+export declare const useAppointmentFlow: (state: AppointmentState, dispatch: React.Dispatch<any>, onError?: (error: Error) => void) => {
+    goBack: () => void;
+    goToNext: () => void;
+    handleDateChange: (date: Date) => Promise<(() => void) | undefined>;
+    sendOtp: () => Promise<void>;
+    verifyOtp: () => Promise<void>;
+    submitAppointment: () => Promise<void>;
+};

package/dist/components/appointment-booking/hooks/useAppointmentFlow.js

@@ -0,0 +1,233 @@
+import { useCallback } from "react";
+import { AppointmentService } from "../../../services/AppointmentService";
+import { PatientService } from "../../../services/PatientService";
+import { validatePhoneNumber, validateCountryCode, } from "../../../components/validation";
+import { formatDateToISO, parsePatientName } from "../../../components/utils";
+export const useAppointmentFlow = (state, dispatch, onError) => {
+    const goBack = useCallback(() => {
+        if (state.step === 3) {
+            dispatch({ type: "SET_OTP_SENT", payload: false });
+            dispatch({ type: "SET_OTP_CODE", payload: "" });
+            dispatch({ type: "SET_OTP_VERIFIED", payload: false });
+            dispatch({ type: "SET_STEP", payload: 1 });
+        }
+        else if (state.step === 4) {
+            dispatch({ type: "SET_STEP", payload: 3 });
+        }
+        else {
+            dispatch({ type: "SET_STEP", payload: Math.max(0, state.step - 1) });
+        }
+    }, [state.step, dispatch]);
+    const goToNext = useCallback(() => {
+        dispatch({ type: "SET_STEP", payload: Math.min(5, state.step + 1) });
+    }, [state.step, dispatch]);
+    const handleDateChange = useCallback(async (date) => {
+        dispatch({ type: "SET_SELECTED_DATE", payload: date });
+        if (!state.workspaceId ||
+            !state.selectedAddress ||
+            !state.selectedDoctor) {
+            dispatch({ type: "SET_SLOTS", payload: [] });
+            return;
+        }
+        let mounted = true;
+        dispatch({ type: "SET_LOADING", payload: true });
+        dispatch({ type: "SET_ERROR", payload: null });
+        try {
+            const dateStr = formatDateToISO(date);
+            const fetchedSlots = await AppointmentService.fetchSlots(state.workspaceId, state.selectedAddress, state.selectedDoctor, dateStr);
+            if (mounted) {
+                dispatch({ type: "SET_SLOTS", payload: fetchedSlots || [] });
+            }
+        }
+        catch (e) {
+            if (mounted) {
+                const msg = e.message || "Failed to load slots";
+                dispatch({ type: "SET_ERROR", payload: msg });
+                onError?.(e);
+            }
+        }
+        finally {
+            if (mounted)
+                dispatch({ type: "SET_LOADING", payload: false });
+        }
+        return () => {
+            mounted = false;
+        };
+    }, [
+        state.workspaceId,
+        state.selectedAddress,
+        state.selectedDoctor,
+        dispatch,
+        onError,
+    ]);
+    const sendOtp = useCallback(async () => {
+        dispatch({ type: "SET_ERROR", payload: null });
+        if (!state.countryCode) {
+            dispatch({ type: "SET_ERROR", payload: "Please enter country code." });
+            return;
+        }
+        if (!validateCountryCode(state.countryCode)) {
+            dispatch({
+                type: "SET_ERROR",
+                payload: "Please enter a valid country code (e.g., +91, +1).",
+            });
+            return;
+        }
+        if (!state.patientPhone) {
+            dispatch({ type: "SET_ERROR", payload: "Please enter phone number." });
+            return;
+        }
+        if (!validatePhoneNumber(state.patientPhone)) {
+            dispatch({
+                type: "SET_ERROR",
+                payload: "Please enter a valid phone number (7-15 digits).",
+            });
+            return;
+        }
+        dispatch({ type: "SET_OTP_SENDING", payload: true });
+        try {
+            await PatientService.sendPhoneVerificationOtp({
+                countryCode: state.countryCode,
+                phoneNumber: state.patientPhone,
+            });
+            dispatch({ type: "SET_OTP_SENT", payload: true });
+            dispatch({ type: "SET_ERROR", payload: null });
+        }
+        catch (e) {
+            const msg = e.message || "Failed to send OTP";
+            dispatch({ type: "SET_ERROR", payload: msg });
+            onError?.(e);
+        }
+        finally {
+            dispatch({ type: "SET_OTP_SENDING", payload: false });
+        }
+    }, [state.countryCode, state.patientPhone, dispatch, onError]);
+    const verifyOtp = useCallback(async () => {
+        dispatch({ type: "SET_ERROR", payload: null });
+        if (!state.countryCode || !state.patientPhone || !state.otpCode) {
+            dispatch({
+                type: "SET_ERROR",
+                payload: "Please enter all required fields.",
+            });
+            return;
+        }
+        if (state.otpCode.length !== 6) {
+            dispatch({
+                type: "SET_ERROR",
+                payload: "Please enter a 6-digit OTP code.",
+            });
+            return;
+        }
+        dispatch({ type: "SET_OTP_VERIFYING", payload: true });
+        try {
+            await PatientService.verifyPhoneVerificationOtp({
+                countryCode: state.countryCode,
+                phoneNumber: state.patientPhone,
+                otpCode: state.otpCode,
+            });
+            dispatch({ type: "SET_OTP_VERIFIED", payload: true });
+            dispatch({ type: "SET_ERROR", payload: null });
+        }
+        catch (e) {
+            const msg = e.message || "Invalid OTP code";
+            dispatch({ type: "SET_ERROR", payload: msg });
+            onError?.(e);
+        }
+        finally {
+            dispatch({ type: "SET_OTP_VERIFYING", payload: false });
+        }
+    }, [state.countryCode, state.patientPhone, state.otpCode, dispatch, onError]);
+    const submitAppointment = useCallback(async () => {
+        dispatch({ type: "SET_ERROR", payload: null });
+        if (!state.selectedDoctor ||
+            !state.selectedSlot ||
+            !state.workspaceId ||
+            !state.selectedAddress) {
+            dispatch({
+                type: "SET_ERROR",
+                payload: "Please ensure all required fields are complete.",
+            });
+            return;
+        }
+        if (!state.otpVerified) {
+            dispatch({
+                type: "SET_ERROR",
+                payload: "Please verify your phone number first.",
+            });
+            return;
+        }
+        if (!state.patientName ||
+            !state.patientAge ||
+            !state.patientEmail ||
+            !state.patientGender ||
+            !state.bloodGroup) {
+            dispatch({
+                type: "SET_ERROR",
+                payload: "Please fill in all patient details.",
+            });
+            return;
+        }
+        if (!state.patientAddress ||
+            !state.patientCity ||
+            !state.patientState ||
+            !state.patientCountry ||
+            !state.patientZipcode) {
+            dispatch({
+                type: "SET_ERROR",
+                payload: "Please fill in all address fields.",
+            });
+            return;
+        }
+        dispatch({ type: "SET_LOADING", payload: true });
+        try {
+            const { firstName, lastName } = parsePatientName(state.patientName);
+            const appointmentDate = formatDateToISO(state.selectedDate);
+            await AppointmentService.createAppointment({
+                workspaceId: state.workspaceId,
+                workspaceAddressId: state.selectedAddress,
+                doctorId: state.selectedDoctor,
+                mode: state.consultationMode,
+                appointmentDate: appointmentDate,
+                fromDateTimeTs: state.selectedSlot.start,
+                toDateTimeTs: state.selectedSlot.end,
+                consultationCharge: state.consultationCharge || "0",
+                type: "CONSULTATION",
+                source: "SDK_POWERED_WEBSITE",
+                patientPayload: {
+                    firstName,
+                    lastName,
+                    email: state.patientEmail,
+                    countryCode: state.countryCode,
+                    phoneNumber: state.patientPhone,
+                    age: parseInt(state.patientAge, 10),
+                    gender: state.patientGender.toUpperCase(),
+                },
+                patientAddress: {
+                    addressLine1: state.patientAddress,
+                    city: state.patientCity,
+                    state: state.patientState,
+                    country: state.patientCountry,
+                    zipcode: state.patientZipcode,
+                    landmark: state.patientLandmark || undefined,
+                },
+            });
+            dispatch({ type: "SET_STEP", payload: 5 });
+        }
+        catch (e) {
+            const msg = e.message || "Failed to create appointment";
+            dispatch({ type: "SET_ERROR", payload: msg });
+            onError?.(e);
+        }
+        finally {
+            dispatch({ type: "SET_LOADING", payload: false });
+        }
+    }, [state, dispatch, onError]);
+    return {
+        goBack,
+        goToNext,
+        handleDateChange,
+        sendOtp,
+        verifyOtp,
+        submitAppointment,
+    };
+};

package/dist/components/appointment-booking/hooks/useAppointmentState.d.ts

@@ -0,0 +1,9 @@
+import { AppointmentState, AppointmentAction } from "../types";
+export declare const useAppointmentState: () => {
+    state: AppointmentState;
+    dispatch: import("react").Dispatch<AppointmentAction>;
+    setStep: (step: number) => void;
+    setError: (error: string | null) => void;
+    setLoading: (loading: boolean) => void;
+    resetForm: () => void;
+};

package/dist/components/appointment-booking/hooks/useAppointmentState.js

@@ -0,0 +1,93 @@
+import { useReducer, useCallback } from "react";
+import { INITIAL_STATE } from "../types";
+const appointmentReducer = (state, action) => {
+    switch (action.type) {
+        case "SET_STEP":
+            return { ...state, step: action.payload };
+        case "SET_LOADING":
+            return { ...state, loading: action.payload };
+        case "SET_ERROR":
+            return { ...state, error: action.payload };
+        case "SET_WORKSPACE": {
+            const doctorMap = {};
+            action.payload.addresses.forEach((addr) => {
+                doctorMap[addr.id] = addr.doctors || [];
+            });
+            return {
+                ...state,
+                workspaceId: action.payload.id,
+                addresses: action.payload.addresses,
+                addressDoctorsMap: doctorMap,
+            };
+        }
+        case "SET_SELECTED_ADDRESS":
+            return { ...state, selectedAddress: action.payload };
+        case "SET_SELECTED_DOCTOR":
+            return { ...state, selectedDoctor: action.payload };
+        case "SET_SELECTED_DATE":
+            return { ...state, selectedDate: action.payload, selectedSlot: null };
+        case "SET_SLOTS":
+            return { ...state, slots: action.payload };
+        case "SET_SELECTED_SLOT":
+            return { ...state, selectedSlot: action.payload };
+        case "SET_CONSULTATION_MODE":
+            return { ...state, consultationMode: action.payload };
+        case "SET_CONSULTATION_CHARGE":
+            return { ...state, consultationCharge: action.payload };
+        case "SET_PATIENT_NAME":
+            return { ...state, patientName: action.payload };
+        case "SET_PATIENT_AGE":
+            return { ...state, patientAge: action.payload };
+        case "SET_PATIENT_EMAIL":
+            return { ...state, patientEmail: action.payload };
+        case "SET_PATIENT_GENDER":
+            return { ...state, patientGender: action.payload };
+        case "SET_BLOOD_GROUP":
+            return { ...state, bloodGroup: action.payload };
+        case "SET_PATIENT_ADDRESS":
+            return { ...state, patientAddress: action.payload };
+        case "SET_PATIENT_CITY":
+            return { ...state, patientCity: action.payload };
+        case "SET_PATIENT_STATE":
+            return { ...state, patientState: action.payload };
+        case "SET_PATIENT_COUNTRY":
+            return { ...state, patientCountry: action.payload };
+        case "SET_PATIENT_ZIPCODE":
+            return { ...state, patientZipcode: action.payload };
+        case "SET_PATIENT_LANDMARK":
+            return { ...state, patientLandmark: action.payload };
+        case "SET_COUNTRY_CODE":
+            return { ...state, countryCode: action.payload };
+        case "SET_PATIENT_PHONE":
+            return { ...state, patientPhone: action.payload };
+        case "SET_OTP_CODE":
+            return { ...state, otpCode: action.payload };
+        case "SET_OTP_SENT":
+            return { ...state, otpSent: action.payload };
+        case "SET_OTP_VERIFIED":
+            return { ...state, otpVerified: action.payload };
+        case "SET_OTP_SENDING":
+            return { ...state, otpSending: action.payload };
+        case "SET_OTP_VERIFYING":
+            return { ...state, otpVerifying: action.payload };
+        case "RESET_FORM":
+            return INITIAL_STATE;
+        default:
+            return state;
+    }
+};
+export const useAppointmentState = () => {
+    const [state, dispatch] = useReducer(appointmentReducer, INITIAL_STATE);
+    const setStep = useCallback((step) => dispatch({ type: "SET_STEP", payload: step }), []);
+    const setError = useCallback((error) => dispatch({ type: "SET_ERROR", payload: error }), []);
+    const setLoading = useCallback((loading) => dispatch({ type: "SET_LOADING", payload: loading }), []);
+    const resetForm = useCallback(() => dispatch({ type: "RESET_FORM" }), []);
+    return {
+        state,
+        dispatch,
+        setStep,
+        setError,
+        setLoading,
+        resetForm,
+    };
+};

package/dist/components/appointment-booking/hooks/useInitializeAddresses.d.ts

@@ -0,0 +1 @@
+export declare const useInitializeAddresses: (dispatch: React.Dispatch<any>, onError?: (error: Error) => void) => void;

package/dist/components/appointment-booking/hooks/useInitializeAddresses.js

@@ -0,0 +1,56 @@
+import { useEffect } from "react";
+import { AppointmentService } from "../../../services/AppointmentService";
+export const useInitializeAddresses = (dispatch, onError) => {
+    useEffect(() => {
+        let mounted = true;
+        (async () => {
+            dispatch({ type: "SET_LOADING", payload: true });
+            dispatch({ type: "SET_ERROR", payload: null });
+            try {
+                const response = await AppointmentService.getAddresses();
+                if (!mounted)
+                    return;
+                if (response.workspaceId && response.addresses?.length > 0) {
+                    dispatch({
+                        type: "SET_WORKSPACE",
+                        payload: {
+                            id: response.workspaceId,
+                            addresses: response.addresses,
+                        },
+                    });
+                    if (response.addresses.length === 1) {
+                        const address = response.addresses[0];
+                        dispatch({ type: "SET_SELECTED_ADDRESS", payload: address.id });
+                        if (address.doctors?.length === 1) {
+                            dispatch({
+                                type: "SET_SELECTED_DOCTOR",
+                                payload: address.doctors[0].id,
+                            });
+                            dispatch({ type: "SET_STEP", payload: 1 });
+                        }
+                    }
+                }
+                else {
+                    dispatch({
+                        type: "SET_ERROR",
+                        payload: "No addresses or doctors available.",
+                    });
+                }
+            }
+            catch (e) {
+                if (!mounted)
+                    return;
+                const msg = e.message || "Failed to load addresses";
+                dispatch({ type: "SET_ERROR", payload: msg });
+                onError?.(e);
+            }
+            finally {
+                if (mounted)
+                    dispatch({ type: "SET_LOADING", payload: false });
+            }
+        })();
+        return () => {
+            mounted = false;
+        };
+    }, [dispatch, onError]);
+};

package/dist/components/appointment-booking/index.d.ts

@@ -0,0 +1,5 @@
+export { AppointmentCalender } from "./AppointmentCalender";
+export type { AppointmentCalenderProps } from "./AppointmentCalender";
+export { useAppointmentState, useAppointmentFlow, useInitializeAddresses, } from "./hooks";
+export type { AppointmentState, AppointmentAction } from "./types";
+export { INITIAL_STATE } from "./types";

package/dist/components/appointment-booking/index.js

@@ -0,0 +1,3 @@
+export { AppointmentCalender } from "./AppointmentCalender";
+export { useAppointmentState, useAppointmentFlow, useInitializeAddresses, } from "./hooks";
+export { INITIAL_STATE } from "./types";

package/dist/components/appointment-booking/types.d.ts

@@ -0,0 +1,128 @@
+import { Doctor, Slot, AddressItem } from "../../services/AppointmentService";
+export interface AppointmentState {
+    step: number;
+    loading: boolean;
+    error: string | null;
+    workspaceId: number | null;
+    addresses: AddressItem[];
+    addressDoctorsMap: Record<number, Doctor[]>;
+    selectedAddress: number | null;
+    selectedDoctor: number | null;
+    selectedDate: Date;
+    slots: Slot[];
+    selectedSlot: Slot | null;
+    consultationMode: "ONLINE" | "OFFLINE";
+    consultationCharge: string;
+    patientName: string;
+    patientAge: string;
+    patientEmail: string;
+    patientGender: string;
+    bloodGroup: string;
+    patientAddress: string;
+    patientCity: string;
+    patientState: string;
+    patientCountry: string;
+    patientZipcode: string;
+    patientLandmark: string;
+    countryCode: string;
+    patientPhone: string;
+    otpCode: string;
+    otpSent: boolean;
+    otpVerified: boolean;
+    otpSending: boolean;
+    otpVerifying: boolean;
+}
+export type AppointmentAction = {
+    type: "SET_STEP";
+    payload: number;
+} | {
+    type: "SET_LOADING";
+    payload: boolean;
+} | {
+    type: "SET_ERROR";
+    payload: string | null;
+} | {
+    type: "SET_WORKSPACE";
+    payload: {
+        id: number;
+        addresses: AddressItem[];
+    };
+} | {
+    type: "SET_SELECTED_ADDRESS";
+    payload: number | null;
+} | {
+    type: "SET_SELECTED_DOCTOR";
+    payload: number | null;
+} | {
+    type: "SET_SELECTED_DATE";
+    payload: Date;
+} | {
+    type: "SET_SLOTS";
+    payload: Slot[];
+} | {
+    type: "SET_SELECTED_SLOT";
+    payload: Slot | null;
+} | {
+    type: "SET_CONSULTATION_MODE";
+    payload: "ONLINE" | "OFFLINE";
+} | {
+    type: "SET_CONSULTATION_CHARGE";
+    payload: string;
+} | {
+    type: "SET_PATIENT_NAME";
+    payload: string;
+} | {
+    type: "SET_PATIENT_AGE";
+    payload: string;
+} | {
+    type: "SET_PATIENT_EMAIL";
+    payload: string;
+} | {
+    type: "SET_PATIENT_GENDER";
+    payload: string;
+} | {
+    type: "SET_BLOOD_GROUP";
+    payload: string;
+} | {
+    type: "SET_PATIENT_ADDRESS";
+    payload: string;
+} | {
+    type: "SET_PATIENT_CITY";
+    payload: string;
+} | {
+    type: "SET_PATIENT_STATE";
+    payload: string;
+} | {
+    type: "SET_PATIENT_COUNTRY";
+    payload: string;
+} | {
+    type: "SET_PATIENT_ZIPCODE";
+    payload: string;
+} | {
+    type: "SET_PATIENT_LANDMARK";
+    payload: string;
+} | {
+    type: "SET_COUNTRY_CODE";
+    payload: string;
+} | {
+    type: "SET_PATIENT_PHONE";
+    payload: string;
+} | {
+    type: "SET_OTP_CODE";
+    payload: string;
+} | {
+    type: "SET_OTP_SENT";
+    payload: boolean;
+} | {
+    type: "SET_OTP_VERIFIED";
+    payload: boolean;
+} | {
+    type: "SET_OTP_SENDING";
+    payload: boolean;
+} | {
+    type: "SET_OTP_VERIFYING";
+    payload: boolean;
+} | {
+    type: "RESET_FORM";
+};
+export declare const INITIAL_STATE: AppointmentState;