medos-sdk 1.0.0

package/README.md

@@ -0,0 +1,15 @@
+# How to test this package
+
+#### Go to your package directory (medos-sdk-js):
+
+- `cd c:\harsh\projects\medos\medos-sdk-js`
+- `npm link`
+
+#### Go to your test project directory (where you want to use the package):
+
+- `cd path\to\your\test-project`
+- `npm link medos-sdk-js`
+
+### If you still get errors, you can also use the folder path directly:
+
+`npm install --save-dev c:\harsh\projects\medos\medos-sdk-js`

package/dist/appointment-calendar/provider.d.ts

@@ -0,0 +1,13 @@
+import { CreateAppointmentPayload, AppointmentListPayload, AppointmentListResponse, AvailableSlotsPayload, UpdateAppointmentPayload, AvailableSlot, RescheduleAppointmentPayload, CreateMeetingPayload, CreateMeetingResponse, EndMeetingPayload } from "./types";
+export declare const createAppointment: (appointmentPayload: Partial<CreateAppointmentPayload>) => Promise<any>;
+export declare const updateAppointment: (appointmentPayload: UpdateAppointmentPayload) => Promise<any>;
+export declare const rescheduleAppointment: (appointmentPayload: RescheduleAppointmentPayload) => Promise<any>;
+export declare const deleteAppointment: (payload: {
+    appointmentId: number;
+    workspaceId: number;
+    addressId: number;
+}) => Promise<any>;
+export declare const fetchAppointments: (payload: AppointmentListPayload) => Promise<AppointmentListResponse[]>;
+export declare const fetchAvailableSlots: (payload: AvailableSlotsPayload) => Promise<AvailableSlot[]>;
+export declare const createMeeting: (payload: CreateMeetingPayload) => Promise<CreateMeetingResponse>;
+export declare const endMeeting: (payload: EndMeetingPayload) => Promise<any>;

package/dist/appointment-calendar/provider.js

@@ -0,0 +1,60 @@
+import { MedosClient } from "../client/MedosClient";
+export const createAppointment = async (appointmentPayload) => {
+    const formData = new FormData();
+    const blob = new Blob([JSON.stringify(appointmentPayload)], {
+        type: "application/json",
+    });
+    formData.append("payload", blob);
+    const response = await MedosClient.client.post("/appointments/book-appointment", formData, { headers: { "Content-Type": "multipart/form-data" } });
+    return response.data;
+};
+export const updateAppointment = async (appointmentPayload) => {
+    const response = await MedosClient.client.put("/appointments/update-appointment", appointmentPayload);
+    return response.data;
+};
+export const rescheduleAppointment = async (appointmentPayload) => {
+    const response = await MedosClient.client.put(`/appointments/${appointmentPayload.id}/reschedule`, {
+        appointmentDate: appointmentPayload.appointmentDate,
+        fromDateTimeTs: appointmentPayload.fromDateTimeTs,
+        toDateTimeTs: appointmentPayload.toDateTimeTs,
+    }, {
+        params: {
+            workspaceId: appointmentPayload.workspaceId,
+            addressId: appointmentPayload.addressId,
+            doctorId: appointmentPayload.doctorId,
+        },
+    });
+    return response.data;
+};
+export const deleteAppointment = async (payload) => {
+    const response = await MedosClient.client.delete(`/appointments/${payload.appointmentId}/delete`, {
+        params: {
+            workspaceId: payload.workspaceId,
+            addressId: payload.addressId,
+        },
+    });
+    return response.data;
+};
+export const fetchAppointments = async (payload) => {
+    const response = await MedosClient.client.post("/appointments/list-with-details", payload);
+    return response.data;
+};
+export const fetchAvailableSlots = async (payload) => {
+    const response = await MedosClient.client.get("/appointments/available-slots", { params: payload });
+    return response.data;
+};
+export const createMeeting = async (payload) => {
+    const response = await MedosClient.client.post("/meeting/create", null, {
+        params: {
+            hostId: payload.hostId,
+            channelName: payload.channelName,
+            appointmentId: payload.appointmentId,
+            joinerId: payload.joinerId,
+        },
+    });
+    return response.data;
+};
+export const endMeeting = async (payload) => {
+    const response = await MedosClient.client.put(`/meeting/${payload.id}/end-meeting`);
+    return response.data;
+};

package/dist/appointment-calendar/types.d.ts

@@ -0,0 +1,144 @@
+export declare enum PaymentMode {
+    CASH = "CASH",
+    CARD = "CARD",
+    UPI = "UPI"
+}
+export declare enum AppointmentType {
+    CONSULTATION = "CONSULTATION",
+    FOLLOW_UP = "FOLLOW_UP",
+    LAB_TEST = "LAB_TEST",
+    SURGERY = "SURGERY",
+    VIRTUAL = "VIRTUAL",
+    IN_PERSON = "IN_PERSON"
+}
+export declare enum AppointmentStatus {
+    SCHEDULED = "SCHEDULED",
+    CANCELLED = "CANCELLED",
+    COMPLETED = "COMPLETED",
+    NO_SHOW = "NO_SHOW"
+}
+export declare enum AppointmentMode {
+    ONLINE = "ONLINE",
+    OFFLINE = "OFFLINE"
+}
+export declare enum AppointmentAction {
+    EDIT = "EDIT",
+    RESCHEDULE = "RESCHEDULE",
+    CANCEL = "CANCEL"
+}
+export declare enum AppointmentSource {
+    MEDOS_WEBSITE = "MEDOS_WEBSITE",
+    WEBSITE = "WEBSITE",
+    ANDROID = "ANDROID",
+    IOS = "IOS",
+    MEDOS_APP_ANDROID = "MEDOS_APP_ANDROID",
+    MEDOS_APP_IOS = "MEDOS_APP_IOS"
+}
+export interface CreateAppointmentPayload {
+    workspaceId: number;
+    addressId: number;
+    doctorId: number;
+    patientId: number;
+    mode: AppointmentMode;
+    appointmentDate: string;
+    fromDateTimeTs: string;
+    toDateTimeTs: string;
+    consultationCharge: number;
+    appointmentNotes?: string;
+    paymentMode: PaymentMode;
+    type: AppointmentType;
+    patientCheckedIn?: boolean;
+    isNoShow?: boolean;
+    source: AppointmentSource;
+    attachments?: File[];
+}
+export interface UpdateAppointmentPayload {
+    id: number;
+    workspaceId: number;
+    addressId: number;
+    mode: AppointmentMode;
+    consultationCharge: number;
+    appointmentNotes?: string;
+    paymentMode: PaymentMode;
+    type: AppointmentType;
+    patientCheckedIn?: boolean;
+    isNoShow?: boolean;
+    source: AppointmentSource;
+}
+export interface RescheduleAppointmentPayload {
+    id: number;
+    workspaceId: number;
+    addressId: number;
+    doctorId: number;
+    appointmentDate: string;
+    fromDateTimeTs: string;
+    toDateTimeTs: string;
+}
+export interface AppointmentListPayload {
+    workspaceId: number;
+    addressId: number;
+    doctorId?: number;
+    patientId?: number;
+    appointmentDate: string;
+    startDate: string;
+    endDate: string;
+    status: string;
+}
+export interface Appointment {
+    id: number;
+    createdAt: string;
+    deleted: boolean;
+    createdAtEpoch: number;
+    workspaceId: number;
+    addressId: number;
+    doctorId: number;
+    patientId: number;
+    fromDateTimeTs: number;
+    toDateTimeTs: number;
+    appointmentDate: string;
+    status: AppointmentStatus;
+    appointmentNotes: string;
+    type: string;
+    durationInSeconds: number;
+    mode: AppointmentMode;
+    reminderSent: boolean;
+    paymentMode: string;
+    patientCheckedIn: boolean;
+    consultationCharge: number;
+    isNoShow: boolean;
+    source: AppointmentSource;
+}
+export interface AppointmentListResponse {
+    appointment: Appointment;
+    patient?: any;
+}
+export interface AvailableSlot {
+    appointmentDate: string;
+    fromDateTimeTs: string;
+    toDateTimeTs: string;
+}
+export interface AvailableSlotsPayload {
+    workspaceId: number;
+    addressId: number;
+    doctorId: number;
+    appointmentDate?: string;
+}
+export interface CreateMeetingPayload {
+    hostId: number;
+    channelName: string;
+    appointmentId: number;
+    joinerId: number;
+}
+export interface CreateMeetingResponse {
+    meetingId: number;
+    hostToken: string;
+    appId: string;
+    channelName: string;
+    joinerTokens: {
+        userId: number;
+        token: string;
+    }[];
+}
+export interface EndMeetingPayload {
+    id: number;
+}

package/dist/appointment-calendar/types.js

@@ -0,0 +1,42 @@
+export var PaymentMode;
+(function (PaymentMode) {
+    PaymentMode["CASH"] = "CASH";
+    PaymentMode["CARD"] = "CARD";
+    PaymentMode["UPI"] = "UPI";
+})(PaymentMode || (PaymentMode = {}));
+export var AppointmentType;
+(function (AppointmentType) {
+    AppointmentType["CONSULTATION"] = "CONSULTATION";
+    AppointmentType["FOLLOW_UP"] = "FOLLOW_UP";
+    AppointmentType["LAB_TEST"] = "LAB_TEST";
+    AppointmentType["SURGERY"] = "SURGERY";
+    AppointmentType["VIRTUAL"] = "VIRTUAL";
+    AppointmentType["IN_PERSON"] = "IN_PERSON";
+})(AppointmentType || (AppointmentType = {}));
+export var AppointmentStatus;
+(function (AppointmentStatus) {
+    AppointmentStatus["SCHEDULED"] = "SCHEDULED";
+    AppointmentStatus["CANCELLED"] = "CANCELLED";
+    AppointmentStatus["COMPLETED"] = "COMPLETED";
+    AppointmentStatus["NO_SHOW"] = "NO_SHOW";
+})(AppointmentStatus || (AppointmentStatus = {}));
+export var AppointmentMode;
+(function (AppointmentMode) {
+    AppointmentMode["ONLINE"] = "ONLINE";
+    AppointmentMode["OFFLINE"] = "OFFLINE";
+})(AppointmentMode || (AppointmentMode = {}));
+export var AppointmentAction;
+(function (AppointmentAction) {
+    AppointmentAction["EDIT"] = "EDIT";
+    AppointmentAction["RESCHEDULE"] = "RESCHEDULE";
+    AppointmentAction["CANCEL"] = "CANCEL";
+})(AppointmentAction || (AppointmentAction = {}));
+export var AppointmentSource;
+(function (AppointmentSource) {
+    AppointmentSource["MEDOS_WEBSITE"] = "MEDOS_WEBSITE";
+    AppointmentSource["WEBSITE"] = "WEBSITE";
+    AppointmentSource["ANDROID"] = "ANDROID";
+    AppointmentSource["IOS"] = "IOS";
+    AppointmentSource["MEDOS_APP_ANDROID"] = "MEDOS_APP_ANDROID";
+    AppointmentSource["MEDOS_APP_IOS"] = "MEDOS_APP_IOS";
+})(AppointmentSource || (AppointmentSource = {}));

package/dist/appointments/provider.d.ts

@@ -0,0 +1,13 @@
+import { FetchWorkspaceAddressDoctorResponse, AppointmentConfig } from "./types";
+export declare const createAppointmentConfig: (payload: AppointmentConfig) => Promise<AppointmentConfig>;
+export declare const updateAppointmentConfig: ({ id, payload, }: {
+    id: string;
+    payload: Omit<AppointmentConfig, "userId" | "workspaceId" | "addressId">;
+}) => Promise<AppointmentConfig>;
+export declare const deleteAppointmentConfig: ({ id, }: {
+    id: number;
+    workspaceId?: number;
+    addressId?: number;
+    userId?: number;
+}) => Promise<void>;
+export declare const fetchWorkspaceAddressesDoctor: (workspaceId: string) => Promise<FetchWorkspaceAddressDoctorResponse>;

package/dist/appointments/provider.js

@@ -0,0 +1,16 @@
+import { MedosClient } from "../client/MedosClient";
+export const createAppointmentConfig = async (payload) => {
+    const response = await MedosClient.client.post("/appointment/configs", payload);
+    return response.data;
+};
+export const updateAppointmentConfig = async ({ id, payload, }) => {
+    const response = await MedosClient.client.put(`/appointment/configs/${id}`, payload);
+    return response.data;
+};
+export const deleteAppointmentConfig = async ({ id, }) => {
+    await MedosClient.client.delete(`/appointment/configs/${id}`);
+};
+export const fetchWorkspaceAddressesDoctor = async (workspaceId) => {
+    const response = await MedosClient.client.get(`/workspaces/${workspaceId}/addresses/appointments-configs`);
+    return response.data;
+};

package/dist/appointments/types.d.ts

@@ -0,0 +1,81 @@
+export interface DoctorAddress {
+    id: number;
+    completeAddress: string;
+    phoneNumber: string;
+    doctorsCount: number;
+    totalConfiguredAppointments: number;
+    doctors: Doctor[];
+}
+export interface AppointmentFeeConfigurationDTO {
+    offlineConsultationFee: number;
+    onlineConsultationFee: number;
+    currency: string;
+}
+export interface AppointmentTypeAndPermissionDTO {
+    allowOnline: boolean;
+    allowOffline: boolean;
+    allowCancellation: boolean;
+    allowRescheduling: boolean;
+    cancellationAllowedBeforeInHours: number;
+}
+export interface BasicAppointmentSettingDTO {
+    defaultDuration: number;
+    bufferTime: number;
+    bookingLimitPerDay: number;
+    maximumConsecutiveAppointment: number;
+}
+export interface AppointmentConsultationValidityAndFollowUpPolicyDTO {
+    enableConsultationValidity: boolean;
+    consultationValidityDays: number;
+    followUpConsultationFee: number;
+    maximumFollowUpVisits: number;
+    followUpFeeType: string;
+    followUpFeePercentage: number;
+    validityAppliesToSameComplaint: boolean;
+    validityResetOnNewComplaint: boolean;
+}
+export interface AppointmentWorkingHourSlot {
+    id?: number;
+    startTime: string;
+    endTime: string;
+    duration: number;
+}
+export interface AppointmentConfigWorkingHours {
+    id?: number;
+    dayOfWeek: string;
+    workingHours: AppointmentWorkingHourSlot[];
+}
+export interface SpecialDayConfig {
+    eventDayDate: string;
+    eventDayType: string;
+    eventDayName: string;
+}
+export interface AppointmentConfig {
+    id?: number;
+    workspaceId: number;
+    addressId: number;
+    userId: number;
+    status?: string;
+    appointmentConfigWorkingHours: AppointmentConfigWorkingHours[];
+    appointmentConsultationValidityAndFollowUpPolicyDTO: AppointmentConsultationValidityAndFollowUpPolicyDTO;
+    appointmentFeeConfigurationDTO: AppointmentFeeConfigurationDTO;
+    appointmentTypeAndPermissionDTO: AppointmentTypeAndPermissionDTO;
+    basicAppointmentSettingDTO: BasicAppointmentSettingDTO;
+    specialDayConfigs: SpecialDayConfig[];
+}
+export interface Doctor {
+    id: number;
+    email: string;
+    name: string;
+    specialization: string[];
+    phoneNumber: string;
+    profilePic: string | null;
+    appointmentConfig: AppointmentConfig | null;
+}
+export interface FetchWorkspaceAddressDoctorResponse {
+    totalAddresses: number;
+    totalConfiguredAppointments: number;
+    totalPartialConfiguredAppointments: number;
+    totalNotConfiguredAppointments: number;
+    addresses: DoctorAddress[];
+}

package/dist/appointments/types.js

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

package/dist/client/MedosClient.d.ts

@@ -0,0 +1,32 @@
+import { AxiosInstance } from "axios";
+import { AddressesResponse } from "../services/AppointmentService";
+import { SendPhoneVerificationOtpPayload, VerifyPhoneVerificationOtpPayload } from "../services/PatientService";
+interface MedosClientConfig {
+    apiKey: string;
+    baseURL?: string;
+}
+interface MedosClientSessionConfig {
+    sessionToken: string;
+    baseURL?: string;
+}
+declare class MedosClient {
+    private static instance;
+    private static token;
+    private static refreshHandler;
+    private static isRefreshing;
+    private static pendingRequests;
+    private static initPromise;
+    static init({ apiKey, baseURL, }: MedosClientConfig): Promise<void>;
+    static initWithSession({ sessionToken, baseURL, }: MedosClientSessionConfig): Promise<void>;
+    private static initializeAxiosInstance;
+    static fetchAllAddressesAndDoctors(): Promise<AddressesResponse>;
+    static fetchAppointments(workspaceId: string | number, addressId: string | number, doctorId: string | number, appointmentDate: string): Promise<any[]>;
+    static sendPhoneVerificationOtp(payload: SendPhoneVerificationOtpPayload): Promise<any>;
+    static verifyPhoneVerificationOtp(payload: VerifyPhoneVerificationOtpPayload): Promise<any>;
+    static get client(): AxiosInstance;
+    static ensureInitialized(): Promise<AxiosInstance>;
+    static isInitialized(): boolean;
+    private static setToken;
+    static setRefreshHandler(handler: () => Promise<string | null>): void;
+}
+export { MedosClient };

package/dist/client/MedosClient.js

@@ -0,0 +1,181 @@
+import axios from "axios";
+import { AuthService } from "../services/AuthService";
+import { AppointmentService, } from "../services/AppointmentService";
+import { PatientService, } from "../services/PatientService";
+class MedosClient {
+    static async init({ apiKey, baseURL = "https://api-dev.medapi.in/v1", }) {
+        if (!apiKey) {
+            throw new Error("MedosClient.init() requires 'apiKey'");
+        }
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.initPromise = (async () => {
+            try {
+                const sessionToken = await AuthService.init(apiKey);
+                this.initializeAxiosInstance(sessionToken, baseURL);
+            }
+            catch (e) {
+                this.initPromise = null;
+                throw new Error(`MedosClient.init failed: ${e.message}`);
+            }
+        })();
+        return this.initPromise;
+    }
+    static async initWithSession({ sessionToken, baseURL = "https://api-dev.medapi.in/v1", }) {
+        if (!sessionToken) {
+            throw new Error("MedosClient.initWithSession() requires 'sessionToken'");
+        }
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.initPromise = (async () => {
+            try {
+                this.initializeAxiosInstance(sessionToken, baseURL);
+            }
+            catch (e) {
+                this.initPromise = null;
+                throw new Error(`MedosClient.initWithSession failed: ${e.message}`);
+            }
+        })();
+        return this.initPromise;
+    }
+    static initializeAxiosInstance(sessionToken, baseURL) {
+        this.token = sessionToken;
+        this.instance = axios.create({
+            baseURL,
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${sessionToken}`,
+            },
+        });
+        this.instance.interceptors.request.use((config) => {
+            if (!config.headers)
+                config.headers = {};
+            const headersAny = config.headers;
+            const isFormData = config.data instanceof FormData ||
+                (config.data &&
+                    typeof config.data === "object" &&
+                    config.data.constructor &&
+                    config.data.constructor.name === "FormData");
+            if (isFormData) {
+                delete headersAny["Content-Type"];
+                if (config.headers.common) {
+                    delete config.headers.common["Content-Type"];
+                }
+            }
+            if (this.token) {
+                headersAny["Authorization"] = `Bearer ${this.token}`;
+            }
+            return config;
+        });
+        this.instance.interceptors.response.use((response) => response, async (error) => {
+            const originalRequest = error.config;
+            if (error.response?.status === 401 &&
+                !originalRequest._retry &&
+                this.refreshHandler) {
+                originalRequest._retry = true;
+                if (this.isRefreshing) {
+                    return new Promise((resolve, reject) => {
+                        this.pendingRequests.push((token) => {
+                            if (token && originalRequest.headers) {
+                                originalRequest.headers["Authorization"] = `Bearer ${token}`;
+                            }
+                            resolve(this.instance.request(originalRequest));
+                        });
+                    });
+                }
+                this.isRefreshing = true;
+                try {
+                    const newToken = await this.refreshHandler();
+                    this.isRefreshing = false;
+                    if (newToken) {
+                        this.setToken(newToken);
+                    }
+                    this.pendingRequests.forEach((cb) => cb(newToken));
+                    this.pendingRequests = [];
+                    if (newToken && originalRequest.headers) {
+                        originalRequest.headers["Authorization"] = `Bearer ${newToken}`;
+                    }
+                    return this.instance.request(originalRequest);
+                }
+                catch (refreshErr) {
+                    this.isRefreshing = false;
+                    this.pendingRequests.forEach((cb) => cb(null));
+                    this.pendingRequests = [];
+                    return Promise.reject(refreshErr);
+                }
+            }
+            return Promise.reject(error);
+        });
+    }
+    static async fetchAllAddressesAndDoctors() {
+        if (!this.instance) {
+            throw new Error("MedosClient not initialized. Call MedosClient.init() first.");
+        }
+        return AppointmentService.getAddresses();
+    }
+    static async fetchAppointments(workspaceId, addressId, doctorId, appointmentDate) {
+        if (!this.instance) {
+            throw new Error("MedosClient not initialized. Call MedosClient.init() first.");
+        }
+        return AppointmentService.fetchSlots(workspaceId, addressId, doctorId, appointmentDate);
+    }
+    static async sendPhoneVerificationOtp(payload) {
+        if (!this.instance) {
+            throw new Error("MedosClient not initialized. Call MedosClient.init() first.");
+        }
+        return PatientService.sendPhoneVerificationOtp(payload);
+    }
+    static async verifyPhoneVerificationOtp(payload) {
+        if (!this.instance) {
+            throw new Error("MedosClient not initialized. Call MedosClient.init() first.");
+        }
+        return PatientService.verifyPhoneVerificationOtp(payload);
+    }
+    static get client() {
+        if (!this.instance && !this.initPromise) {
+            throw new Error("MedosClient not initialized. Call MedosClient.init() or MedosClient.initWithSession() first.");
+        }
+        if (!this.instance && this.initPromise) {
+            throw new Error("MedosClient initialization is in progress. Please wait for initialization to complete before accessing the client.");
+        }
+        return this.instance;
+    }
+    static async ensureInitialized() {
+        if (this.instance) {
+            return this.instance;
+        }
+        if (this.initPromise) {
+            await this.initPromise;
+            if (this.instance) {
+                return this.instance;
+            }
+        }
+        throw new Error("MedosClient not initialized. Call MedosClient.init() or MedosClient.initWithSession() first.");
+    }
+    static isInitialized() {
+        return this.instance !== null;
+    }
+    static setToken(token) {
+        this.token = token;
+        if (this.instance) {
+            const defaults = this.instance.defaults;
+            if (!defaults.headers)
+                defaults.headers = {};
+            if (!defaults.headers.common)
+                defaults.headers.common = {};
+            defaults.headers.common["Authorization"] = `Bearer ${token}`;
+        }
+    }
+    static setRefreshHandler(handler) {
+        this.refreshHandler = handler;
+    }
+}
+MedosClient.instance = null;
+MedosClient.token = null;
+MedosClient.refreshHandler = null;
+MedosClient.isRefreshing = false;
+MedosClient.pendingRequests = [];
+MedosClient.initPromise = null;
+export { MedosClient };

package/dist/components/AppointmentCalender.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+type AppointmentCalenderProps = {
+    onError?: (err: Error) => void;
+};
+export declare const AppointmentCalender: React.FC<AppointmentCalenderProps>;
+export {};