medos-sdk 1.0.2 → 1.1.0

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

@@ -0,0 +1,106 @@
+export interface ThemeColors {
+    primary: string;
+    primaryHover: string;
+    primaryActive: string;
+    secondary: string;
+    secondaryHover: string;
+    accent: string;
+    accentHover: string;
+    background: string;
+    backgroundSecondary: string;
+    backgroundTertiary: string;
+    surface: string;
+    surfaceHover: string;
+    border: string;
+    borderHover: string;
+    borderFocus: string;
+    text: string;
+    textSecondary: string;
+    textTertiary: string;
+    textDisabled: string;
+    textOnPrimary: string;
+    textOnSecondary: string;
+    success: string;
+    successBackground: string;
+    successBorder: string;
+    error: string;
+    errorBackground: string;
+    errorBorder: string;
+    warning: string;
+    warningBackground: string;
+    warningBorder: string;
+    info: string;
+    infoBackground: string;
+    infoBorder: string;
+}
+export interface ThemeTypography {
+    fontFamily: string;
+    fontFamilyHeading: string;
+    fontSizeXs: string;
+    fontSizeSm: string;
+    fontSizeMd: string;
+    fontSizeLg: string;
+    fontSizeXl: string;
+    fontSize2xl: string;
+    fontSize3xl: string;
+    fontWeightNormal: string;
+    fontWeightMedium: string;
+    fontWeightSemibold: string;
+    fontWeightBold: string;
+    lineHeightTight: string;
+    lineHeightNormal: string;
+    lineHeightRelaxed: string;
+}
+export interface ThemeSpacing {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    "2xl": string;
+    "3xl": string;
+    "4xl": string;
+}
+export interface ThemeShadows {
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    "2xl": string;
+    none: string;
+}
+export interface ThemeRadii {
+    none: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    full: string;
+}
+export interface ThemeTransitions {
+    fast: string;
+    normal: string;
+    slow: string;
+}
+export interface MedosTheme {
+    name: string;
+    colors: ThemeColors;
+    typography: ThemeTypography;
+    spacing: ThemeSpacing;
+    shadows: ThemeShadows;
+    radii: ThemeRadii;
+    transitions: ThemeTransitions;
+}
+export type PartialTheme = {
+    name?: string;
+    colors?: Partial<ThemeColors>;
+    typography?: Partial<ThemeTypography>;
+    spacing?: Partial<ThemeSpacing>;
+    shadows?: Partial<ThemeShadows>;
+    radii?: Partial<ThemeRadii>;
+    transitions?: Partial<ThemeTransitions>;
+};
+export interface ThemeConfig {
+    theme?: MedosTheme | PartialTheme;
+    cssVariablePrefix?: string;
+}

package/dist/core/theme/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,8 @@
+import { MedosTheme, PartialTheme } from "./types";
+export declare function mergeTheme(partialTheme?: PartialTheme): MedosTheme;
+export declare function generateCssVariables(theme: MedosTheme, prefix?: string): string;
+export declare function generateCssVariablesObject(theme: MedosTheme, prefix?: string): Record<string, string>;
+export declare function getCssVar(prefix: string, category: string, key: string, fallback?: string): string;
+export declare function injectCssVariables(theme: MedosTheme, containerId: string, prefix?: string): void;
+export declare function createThemeStyleTag(theme: MedosTheme, prefix?: string, selector?: string): HTMLStyleElement | null;
+export declare function validateTheme(theme: any): string[];

package/dist/core/theme/utils.js

@@ -0,0 +1,135 @@
+import { defaultTheme } from "./themes";
+function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key in source) {
+        if (source.hasOwnProperty(key)) {
+            const sourceValue = source[key];
+            const targetValue = result[key];
+            if (sourceValue &&
+                typeof sourceValue === "object" &&
+                !Array.isArray(sourceValue) &&
+                targetValue &&
+                typeof targetValue === "object" &&
+                !Array.isArray(targetValue)) {
+                result[key] = deepMerge(targetValue, sourceValue);
+            }
+            else if (sourceValue !== undefined) {
+                result[key] = sourceValue;
+            }
+        }
+    }
+    return result;
+}
+export function mergeTheme(partialTheme) {
+    if (!partialTheme) {
+        return defaultTheme;
+    }
+    return deepMerge(defaultTheme, partialTheme);
+}
+function getCssVarName(prefix, category, key) {
+    return `--${prefix}-${category}-${key
+        .replace(/([A-Z])/g, "-$1")
+        .toLowerCase()}`;
+}
+export function generateCssVariables(theme, prefix = "medos") {
+    const vars = [];
+    Object.entries(theme.colors).forEach(([key, value]) => {
+        vars.push(`${getCssVarName(prefix, "color", key)}: ${value};`);
+    });
+    Object.entries(theme.typography).forEach(([key, value]) => {
+        vars.push(`${getCssVarName(prefix, "typography", key)}: ${value};`);
+    });
+    Object.entries(theme.spacing).forEach(([key, value]) => {
+        vars.push(`${getCssVarName(prefix, "spacing", key)}: ${value};`);
+    });
+    Object.entries(theme.shadows).forEach(([key, value]) => {
+        vars.push(`${getCssVarName(prefix, "shadow", key)}: ${value};`);
+    });
+    Object.entries(theme.radii).forEach(([key, value]) => {
+        vars.push(`${getCssVarName(prefix, "radius", key)}: ${value};`);
+    });
+    Object.entries(theme.transitions).forEach(([key, value]) => {
+        vars.push(`${getCssVarName(prefix, "transition", key)}: ${value};`);
+    });
+    return vars.join("\n  ");
+}
+export function generateCssVariablesObject(theme, prefix = "medos") {
+    const vars = {};
+    Object.entries(theme.colors).forEach(([key, value]) => {
+        vars[getCssVarName(prefix, "color", key)] = value;
+    });
+    Object.entries(theme.typography).forEach(([key, value]) => {
+        vars[getCssVarName(prefix, "typography", key)] = value;
+    });
+    Object.entries(theme.spacing).forEach(([key, value]) => {
+        vars[getCssVarName(prefix, "spacing", key)] = value;
+    });
+    Object.entries(theme.shadows).forEach(([key, value]) => {
+        vars[getCssVarName(prefix, "shadow", key)] = value;
+    });
+    Object.entries(theme.radii).forEach(([key, value]) => {
+        vars[getCssVarName(prefix, "radius", key)] = value;
+    });
+    Object.entries(theme.transitions).forEach(([key, value]) => {
+        vars[getCssVarName(prefix, "transition", key)] = value;
+    });
+    return vars;
+}
+export function getCssVar(prefix, category, key, fallback) {
+    const varName = getCssVarName(prefix, category, key);
+    return fallback ? `var(${varName}, ${fallback})` : `var(${varName})`;
+}
+export function injectCssVariables(theme, containerId, prefix = "medos") {
+    if (typeof document === "undefined") {
+        return;
+    }
+    const container = document.getElementById(containerId);
+    if (!container) {
+        console.warn(`Container with id "${containerId}" not found`);
+        return;
+    }
+    const cssVars = generateCssVariablesObject(theme, prefix);
+    Object.entries(cssVars).forEach(([key, value]) => {
+        container.style.setProperty(key, value);
+    });
+}
+export function createThemeStyleTag(theme, prefix = "medos", selector = ":root") {
+    if (typeof document === "undefined") {
+        return null;
+    }
+    const styleId = `${prefix}-theme-vars`;
+    const existingStyle = document.getElementById(styleId);
+    if (existingStyle) {
+        existingStyle.remove();
+    }
+    const styleElement = document.createElement("style");
+    styleElement.id = styleId;
+    styleElement.innerHTML = `
+    ${selector} {
+      ${generateCssVariables(theme, prefix)}
+    }
+  `;
+    document.head.appendChild(styleElement);
+    return styleElement;
+}
+export function validateTheme(theme) {
+    const errors = [];
+    if (!theme || typeof theme !== "object") {
+        errors.push("Theme must be an object");
+        return errors;
+    }
+    const requiredProps = [
+        "colors",
+        "typography",
+        "spacing",
+        "shadows",
+        "radii",
+        "transitions",
+    ];
+    requiredProps.forEach((prop) => {
+        if (!theme[prop] || typeof theme[prop] !== "object") {
+            errors.push(`Theme.${prop} is required and must be an object`);
+        }
+    });
+    return errors;
+}

package/dist/enquiry-form/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./validation";
+export * from "./provider";
+export * from "./serialization";

package/dist/enquiry-form/index.js

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./validation";
+export * from "./provider";
+export * from "./serialization";

package/dist/enquiry-form/provider.d.ts

@@ -0,0 +1,3 @@
+import { Enquiry, EnquirySubmission } from "./types";
+export declare const submitEnquiry: (payload: EnquirySubmission) => Promise<Enquiry>;
+export declare const getEnquiry: (enquiryId: string) => Promise<Enquiry>;

package/dist/enquiry-form/provider.js

@@ -0,0 +1,9 @@
+import { MedosClient } from "../client/MedosClient";
+export const submitEnquiry = async (payload) => {
+    const response = await MedosClient.client.post("/enquiries", payload);
+    return response.data;
+};
+export const getEnquiry = async (enquiryId) => {
+    const response = await MedosClient.client.get(`/enquiries/${enquiryId}`);
+    return response.data;
+};

package/dist/enquiry-form/serialization.d.ts

@@ -0,0 +1,4 @@
+import { Enquiry } from "./types";
+export declare const serializeEnquiry: (enquiry: Enquiry) => string;
+export declare const deserializeEnquiry: (jsonString: string) => Enquiry;
+export declare const roundTripEnquiry: (enquiry: Enquiry) => Enquiry;

package/dist/enquiry-form/serialization.js

@@ -0,0 +1,57 @@
+export const serializeEnquiry = (enquiry) => {
+    if (!enquiry) {
+        throw new Error("Cannot serialize null or undefined enquiry");
+    }
+    try {
+        return JSON.stringify(enquiry);
+    }
+    catch (error) {
+        throw new Error(`Failed to serialize enquiry: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+export const deserializeEnquiry = (jsonString) => {
+    if (!jsonString || typeof jsonString !== "string") {
+        throw new Error("Cannot deserialize null, undefined, or non-string value");
+    }
+    try {
+        const parsed = JSON.parse(jsonString);
+        if (typeof parsed !== "object" || parsed === null) {
+            throw new Error("Deserialized value is not an object");
+        }
+        const requiredFields = [
+            "patientName",
+            "patientEmail",
+            "countryCode",
+            "patientPhone",
+            "inquirySubject",
+            "inquiryMessage",
+            "preferredContactMethod",
+        ];
+        for (const field of requiredFields) {
+            if (!(field in parsed)) {
+                throw new Error(`Missing required field: ${field}`);
+            }
+        }
+        const validContactMethods = ["PHONE", "EMAIL", "BOTH"];
+        if (!validContactMethods.includes(parsed.preferredContactMethod)) {
+            throw new Error(`Invalid preferredContactMethod: ${parsed.preferredContactMethod}`);
+        }
+        if (parsed.status !== undefined && parsed.status !== null) {
+            const validStatuses = ["PENDING", "RESPONDED", "CLOSED"];
+            if (!validStatuses.includes(parsed.status)) {
+                throw new Error(`Invalid status: ${parsed.status}`);
+            }
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON: ${error.message}`);
+        }
+        throw error;
+    }
+};
+export const roundTripEnquiry = (enquiry) => {
+    const serialized = serializeEnquiry(enquiry);
+    return deserializeEnquiry(serialized);
+};

package/dist/enquiry-form/types.d.ts

@@ -0,0 +1,38 @@
+export interface Enquiry {
+    id?: string;
+    patientName: string;
+    patientEmail: string;
+    countryCode: string;
+    patientPhone: string;
+    inquirySubject: string;
+    inquiryMessage: string;
+    preferredContactMethod: "PHONE" | "EMAIL" | "BOTH";
+    createdAt?: string;
+    status?: "PENDING" | "RESPONDED" | "CLOSED";
+}
+export interface EnquiryFormState {
+    step: number;
+    loading: boolean;
+    error: string | null;
+    patientName: string;
+    patientEmail: string;
+    countryCode: string;
+    patientPhone: string;
+    inquirySubject: string;
+    inquiryMessage: string;
+    preferredContactMethod: "PHONE" | "EMAIL" | "BOTH";
+    submitted: boolean;
+}
+export interface EnquirySubmission {
+    patientName: string;
+    patientEmail: string;
+    countryCode: string;
+    patientPhone: string;
+    inquirySubject: string;
+    inquiryMessage: string;
+    preferredContactMethod: "PHONE" | "EMAIL" | "BOTH";
+}
+export interface ValidationResult {
+    isValid: boolean;
+    error?: string;
+}

package/dist/enquiry-form/types.js

@@ -0,0 +1 @@
+export {};

package/dist/enquiry-form/validation.d.ts

@@ -0,0 +1,6 @@
+export declare const validateName: (name: string) => boolean;
+export declare const validateEmail: (email: string) => boolean;
+export declare const validatePhoneNumber: (phone: string) => boolean;
+export declare const validateSubject: (subject: string) => boolean;
+export declare const validateMessage: (message: string) => boolean;
+export declare const validateCountryCode: (code: string) => boolean;

package/dist/enquiry-form/validation.js

@@ -0,0 +1,21 @@
+export const validateName = (name) => {
+    return name.trim().length > 0;
+};
+export const validateEmail = (email) => {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+};
+export const validatePhoneNumber = (phone) => {
+    const cleaned = phone.replace(/\D/g, "");
+    return cleaned.length >= 7 && cleaned.length <= 15;
+};
+export const validateSubject = (subject) => {
+    return subject.trim().length > 0;
+};
+export const validateMessage = (message) => {
+    const trimmed = message.trim();
+    return trimmed.length > 0 && trimmed.length <= 1000;
+};
+export const validateCountryCode = (code) => {
+    return /^\+[1-9]\d{0,3}$/.test(code);
+};

package/dist/index.d.ts

@@ -1,7 +1,16 @@
 export { MedosClient } from "./client/MedosClient";
+export * from "./core/theme";
+export { MedosThemeProvider } from "./react/ThemeProvider";
+export type { MedosThemeProviderProps } from "./react/ThemeProvider";
+export { defaultTheme, modernTheme } from "./core/theme/themes";
+export { useTheme, useThemeContext, useCssVar } from "./react/hooks/useTheme";
 export { AppointmentCalender } from "./components/AppointmentCalender";
+export { EnquiryForm } from "./components/EnquiryForm";
+export type { EnquiryFormProps } from "./components/EnquiryForm";
 export * from "./appointments/provider";
 export * from "./appointments/types";
 export * from "./appointment-calendar/provider";
 export * from "./appointment-calendar/types";
+export * from "./enquiry-form/provider";
+export * from "./enquiry-form/types";
 export { PatientService, SendPhoneVerificationOtpPayload, VerifyPhoneVerificationOtpPayload, } from "./services/PatientService";

package/dist/index.js

@@ -1,7 +1,14 @@
 export { MedosClient } from "./client/MedosClient";
+export * from "./core/theme";
+export { MedosThemeProvider } from "./react/ThemeProvider";
+export { defaultTheme, modernTheme } from "./core/theme/themes";
+export { useTheme, useThemeContext, useCssVar } from "./react/hooks/useTheme";
 export { AppointmentCalender } from "./components/AppointmentCalender";
+export { EnquiryForm } from "./components/EnquiryForm";
 export * from "./appointments/provider";
 export * from "./appointments/types";
 export * from "./appointment-calendar/provider";
 export * from "./appointment-calendar/types";
+export * from "./enquiry-form/provider";
+export * from "./enquiry-form/types";
 export { PatientService, } from "./services/PatientService";

package/dist/lib/templateUtils.d.ts

@@ -0,0 +1,3 @@
+import type { TemplateId } from "../core";
+export declare function injectTemplateStyles(templateId: TemplateId): void;
+export declare function removeTemplateStyles(): void;

package/dist/lib/templateUtils.js

@@ -0,0 +1,28 @@
+import { templateRegistry } from "../core";
+export function injectTemplateStyles(templateId) {
+    const existing = document.getElementById("medos-template-styles");
+    if (existing)
+        existing.remove();
+    const template = templateRegistry.getTemplate(templateId);
+    const style = document.createElement("style");
+    style.id = "medos-template-styles";
+    style.textContent = `
+    .medos-appointment-container {
+      --medos-primary-color: ${template.primaryColor} !important;
+      --medos-secondary-color: ${template.secondaryColor} !important;
+      --medos-accent-color: ${template.accentColor} !important;
+      --medos-background-color: ${template.backgroundColor} !important;
+      --medos-text-color: ${template.textColor} !important;
+      --medos-border-color: ${template.borderColor} !important;
+      --medos-muted-text: ${template.mutedText} !important;
+      --medos-success-color: ${template.successColor} !important;
+      --medos-error-color: ${template.errorColor} !important;
+    }
+  `;
+    document.head.appendChild(style);
+}
+export function removeTemplateStyles() {
+    const existing = document.getElementById("medos-template-styles");
+    if (existing)
+        existing.remove();
+}

package/dist/react/ThemeProvider.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import { MedosTheme, PartialTheme } from "../core/theme/types";
+import { ThemeName } from "../core/theme/themes";
+interface ThemeContextValue {
+    theme: MedosTheme;
+    cssVars: Record<string, string>;
+    prefix: string;
+}
+export interface MedosThemeProviderProps {
+    children: React.ReactNode;
+    theme?: ThemeName | MedosTheme | PartialTheme;
+    cssVariablePrefix?: string;
+}
+export declare function MedosThemeProvider({ children, theme, cssVariablePrefix, }: 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;
+export {};

package/dist/react/ThemeProvider.js

@@ -0,0 +1,45 @@
+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";
+const ThemeContext = createContext(undefined);
+export function MedosThemeProvider({ children, theme, cssVariablePrefix = "medos", }) {
+    const resolvedTheme = useMemo(() => {
+        if (!theme) {
+            return defaultTheme;
+        }
+        if (typeof theme === "string") {
+            return themes[theme] || defaultTheme;
+        }
+        if ("name" in theme && "colors" in theme && "typography" in theme) {
+            return theme;
+        }
+        return mergeTheme(theme);
+    }, [theme]);
+    const cssVars = useMemo(() => generateCssVariablesObject(resolvedTheme, cssVariablePrefix), [resolvedTheme, cssVariablePrefix]);
+    const contextValue = useMemo(() => ({
+        theme: resolvedTheme,
+        cssVars,
+        prefix: cssVariablePrefix,
+    }), [resolvedTheme, cssVars, cssVariablePrefix]);
+    return (_jsx(ThemeContext.Provider, { value: contextValue, children: _jsx("div", { style: cssVars, children: children }) }));
+}
+export function useThemeContext() {
+    const context = React.useContext(ThemeContext);
+    if (!context) {
+        throw new Error("useThemeContext must be used within a MedosThemeProvider");
+    }
+    return context;
+}
+export function useTheme() {
+    const context = React.useContext(ThemeContext);
+    return context?.theme || defaultTheme;
+}
+export function useCssVar(category, key, fallback) {
+    const context = React.useContext(ThemeContext);
+    const prefix = context?.prefix || "medos";
+    const varName = `--${prefix}-${category}-${key
+        .replace(/([A-Z])/g, "-$1")
+        .toLowerCase()}`;
+    return fallback ? `var(${varName}, ${fallback})` : `var(${varName})`;
+}

package/dist/react/hooks/useTheme.d.ts

@@ -0,0 +1 @@
+export { useTheme, useThemeContext, useCssVar } from "../ThemeProvider";

package/dist/react/hooks/useTheme.js

@@ -0,0 +1 @@
+export { useTheme, useThemeContext, useCssVar } from "../ThemeProvider";

package/dist/react/index.d.ts

@@ -1,2 +1,7 @@
 export * from "../core";
+export { MedosThemeProvider } from "./ThemeProvider";
+export type { MedosThemeProviderProps } from "./ThemeProvider";
+export { useTheme, useThemeContext, useCssVar } from "./hooks/useTheme";
 export { AppointmentCalender } from "../components/AppointmentCalender";
+export { EnquiryForm } from "../components/EnquiryForm";
+export type { EnquiryFormProps } from "../components/EnquiryForm";

package/dist/react/index.js

@@ -1,2 +1,5 @@
 export * from "../core";
+export { MedosThemeProvider } from "./ThemeProvider";
+export { useTheme, useThemeContext, useCssVar } from "./hooks/useTheme";
 export { AppointmentCalender } from "../components/AppointmentCalender";
+export { EnquiryForm } from "../components/EnquiryForm";

package/dist/services/AppointmentService.d.ts

@@ -1,5 +1,5 @@
 export type Doctor = {
-    id: string;
+    id: number;
     name: string;
     specialty?: string;
     [key: string]: any;
@@ -58,7 +58,7 @@ type AppointmentPayload = {
     attachments?: File[];
 };
 type AddressItem = {
-    id: number | string;
+    id: number;
     completeAddress?: string;
     label?: string;
     address?: string;
@@ -67,7 +67,6 @@ type AddressItem = {
     doctorsCount?: number;
     totalConfiguredAppointments?: number;
     doctors?: Doctor[];
-    [key: string]: any;
 };
 type AddressesResponse = {
     totalAddresses?: number;
@@ -75,12 +74,12 @@ type AddressesResponse = {
     totalConfiguredAppointments?: number;
     totalPartialConfiguredAppointments?: number;
     totalNotConfiguredAppointments?: number;
-    workspaceId?: number | string;
+    workspaceId?: number;
     addresses: AddressItem[];
 };
 declare const AppointmentService: {
     getAddresses(): Promise<AddressesResponse>;
-    fetchSlots(workspaceId: string | number, addressId: string | number, doctorId: string | number, appointmentDate: string): Promise<Slot[]>;
+    fetchSlots(workspaceId: number, addressId: number, doctorId: number, appointmentDate: string): Promise<Slot[]>;
     createAppointment(payload: BookAppointmentPayload): Promise<any>;
 };
 export { AppointmentService, AppointmentPayload, BookAppointmentPayload, PatientPayload, PatientAddressPayload, AddressesResponse, AddressItem, };

package/dist/services/AppointmentService.js

@@ -10,18 +10,19 @@ const AppointmentService = {
                 .map((ad) => {
                 const addr = ad.address;
                 const doctors = (ad.doctors || []).map((d) => ({
-                    id: String(d.id ?? ""),
-                    name: `${d.firstName || ""} ${d.lastName || ""}`.trim() || "Doctor",
-                    email: d.email,
-                    gender: d.gender,
-                    countryCode: d.countryCode,
-                    phoneNumber: d.phoneNumber,
-                    dob: d.dob,
-                    platform: d.platform,
-                    isKycCompleted: d.isKycCompleted,
+                    id: Number(d.user.id),
+                    name: `${d.user.firstName || ""} ${d.user.lastName || ""}`.trim() ||
+                        "Doctor",
+                    email: d.user.email,
+                    gender: d.user.gender,
+                    countryCode: d.user.countryCode,
+                    phoneNumber: d.user.phoneNumber,
+                    dob: d.user.dob,
+                    platform: d.user.platform,
+                    isKycCompleted: d.user.isKycCompleted,
                 }));
                 return {
-                    id: String(addr.id ?? ""),
+                    id: Number(addr.id),
                     completeAddress: addr.completeAddress,
                     addressLine1: addr.addressLine1,
                     addressLine2: addr.addressLine2,
@@ -47,6 +48,7 @@ const AppointmentService = {
     },
     async fetchSlots(workspaceId, addressId, doctorId, appointmentDate) {
         const client = await MedosClient.ensureInitialized();
+        console.log("fetching slots", workspaceId, addressId, doctorId, appointmentDate);
         const res = await client.get(`/appointments/available-slots`, {
             params: {
                 workspaceId,

package/dist/services/EnquiryService.d.ts

@@ -0,0 +1,5 @@
+import { EnquirySubmission } from "../enquiry-form/types";
+declare const EnquiryService: {
+    submitEnquiry(payload: EnquirySubmission): Promise<any>;
+};
+export { EnquiryService };