medos-sdk 1.0.0

package/dist/services/AppointmentService.js

@@ -0,0 +1,108 @@
+import { MedosClient } from "../client/MedosClient";
+const AppointmentService = {
+    async getAddresses() {
+        const client = await MedosClient.ensureInitialized();
+        const res = await client.get("/workspaces");
+        const data = res.data ?? res;
+        if (data && Array.isArray(data.addressDoctors)) {
+            const addresses = data.addressDoctors
+                .filter((ad) => ad.address)
+                .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,
+                }));
+                return {
+                    id: String(addr.id ?? ""),
+                    completeAddress: addr.completeAddress,
+                    addressLine1: addr.addressLine1,
+                    addressLine2: addr.addressLine2,
+                    city: addr.city,
+                    state: addr.state,
+                    country: addr.country,
+                    zipcode: addr.zipcode,
+                    landmark: addr.landmark,
+                    phoneNumber: addr.phoneNumber,
+                    latitude: addr.latitude,
+                    longitude: addr.longitude,
+                    doctors,
+                };
+            });
+            return {
+                totalAddresses: data.totalAddresses,
+                totalDoctors: data.totalDoctors,
+                workspaceId: data.workspaceId,
+                addresses,
+            };
+        }
+        return { addresses: [] };
+    },
+    async fetchSlots(workspaceId, addressId, doctorId, appointmentDate) {
+        const client = await MedosClient.ensureInitialized();
+        const res = await client.get(`/appointments/available-slots`, {
+            params: {
+                workspaceId,
+                addressId,
+                doctorId,
+                appointmentDate,
+            },
+        });
+        const data = res.data ?? res;
+        if (Array.isArray(data)) {
+            return data.map((slot) => {
+                const { appointmentDate: date, fromDateTimeTs: fromTime, toDateTimeTs: toTime, } = slot;
+                const start = `${date}T${fromTime}:00`;
+                const end = `${date}T${toTime}:00`;
+                return {
+                    start,
+                    end,
+                    id: slot.id,
+                    ...slot,
+                };
+            });
+        }
+        return [];
+    },
+    async createAppointment(payload) {
+        const client = await MedosClient.ensureInitialized();
+        const workspaceId = payload.workspaceId;
+        const appointmentData = {
+            workspaceAddressId: payload.workspaceAddressId,
+            doctorId: payload.doctorId,
+            mode: payload.mode || "OFFLINE",
+            appointmentDate: payload.appointmentDate,
+            fromDateTimeTs: payload.fromDateTimeTs,
+            toDateTimeTs: payload.toDateTimeTs,
+            consultationCharge: payload.consultationCharge || "0",
+            type: payload.type || "CONSULTATION",
+            source: payload.source || "SDK_POWERED_WEBSITE",
+            patientPayload: payload.patientPayload,
+            patientAddress: payload.patientAddress,
+        };
+        const formData = new FormData();
+        const payloadString = JSON.stringify(appointmentData);
+        formData.append("payload", payloadString);
+        if (payload.attachments && payload.attachments.length > 0) {
+            payload.attachments.forEach((file) => {
+                formData.append("attachments", file);
+            });
+        }
+        const config = {
+            headers: {},
+        };
+        if (workspaceId) {
+            config.headers["workspace-id"] = String(workspaceId);
+        }
+        const res = await client.post("/appointments/book-appointment", formData, config);
+        return res.data;
+    },
+};
+export { AppointmentService, };

package/dist/services/AuthService.d.ts

@@ -0,0 +1,6 @@
+declare const AuthService: {
+    init(apiKey: string): Promise<string>;
+    getToken(): string | null;
+    clear(): void;
+};
+export { AuthService };

package/dist/services/AuthService.js

@@ -0,0 +1,25 @@
+import axios from "axios";
+let sessionToken = null;
+const AuthService = {
+    async init(apiKey) {
+        try {
+            const res = await axios.post(`https://api-dev.medapi.in/v1/auth/session?api_key=${apiKey}`, {});
+            const token = res.data?.access_token;
+            if (!token || typeof token !== "string") {
+                throw new Error("Invalid session token response");
+            }
+            sessionToken = token;
+            return token;
+        }
+        catch (e) {
+            throw new Error(`Failed to initialize session: ${e.message}`);
+        }
+    },
+    getToken() {
+        return sessionToken;
+    },
+    clear() {
+        sessionToken = null;
+    },
+};
+export { AuthService };

package/dist/services/PatientService.d.ts

@@ -0,0 +1,14 @@
+type SendPhoneVerificationOtpPayload = {
+    countryCode: string;
+    phoneNumber: string;
+};
+type VerifyPhoneVerificationOtpPayload = {
+    countryCode: string;
+    phoneNumber: string;
+    otpCode: string;
+};
+declare const PatientService: {
+    sendPhoneVerificationOtp(payload: SendPhoneVerificationOtpPayload): Promise<any>;
+    verifyPhoneVerificationOtp(payload: VerifyPhoneVerificationOtpPayload): Promise<any>;
+};
+export { PatientService, SendPhoneVerificationOtpPayload, VerifyPhoneVerificationOtpPayload, };

package/dist/services/PatientService.js

@@ -0,0 +1,14 @@
+import { MedosClient } from "../client/MedosClient";
+const PatientService = {
+    async sendPhoneVerificationOtp(payload) {
+        const client = await MedosClient.ensureInitialized();
+        const res = await client.post("/patients/send-phone-verification-otp", payload);
+        return res.data;
+    },
+    async verifyPhoneVerificationOtp(payload) {
+        const client = await MedosClient.ensureInitialized();
+        const res = await client.post("/patients/verify-phone-verification-otp", payload);
+        return res.data;
+    },
+};
+export { PatientService, };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "medos-sdk",
+  "version": "1.0.0",
+  "description": "Medos SDK for managing appointments, meetings, and calendars in apps",
+  "homepage": "https://github.com/MediLaunch/medos-sdk-react#readme",
+  "bugs": {
+    "url": "https://github.com/MediLaunch/medos-sdk-react/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MediLaunch/medos-sdk-react.git"
+  },
+  "license": "UNLICENSED",
+  "author": "Pooranjoy Bhattacharya",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "build:clean": "tsc --build --clean && tsc",
+    "prepublishOnly": "npm run build:clean",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "axios": "^1.12.2",
+    "react": "^19.2.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.3",
+    "typescript": "^5.9.3"
+  },
+  "keywords": [
+    "medos"
+  ]
+}