oneticket-sdk-vi 1.0.0

package/src/services/apis/city/types.ts

@@ -0,0 +1,62 @@
+// ALL CITIES
+export type AllCitiesApiPayload = {
+
+};
+export type AllCitiesApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+    cities: {
+        _id: string;
+        name: string;
+        description: string;
+        cityCode: string;
+        image: string;
+        metroCancellation: boolean;
+        is_active: boolean;
+        operatingHours: {
+            start: string;
+            end: string;
+        };
+        gps: {
+            latitude: any;
+            longitude: any;
+        };
+    }[];
+};
+
+// ALL CITIES
+export type AllCityLinesApiPayload = {
+
+};
+export type AllCityLinesApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+    lines: {
+        _id: string;
+        name: string;
+        cityCode: string;
+        image: string;
+        metroCancellation: boolean;
+    }[];
+};
+
+// SELECT CITY
+export type SelectCityApiPayload = {
+    cityCode: string;
+};
+export type SelectCityApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+};
+
+// CURRECT CITY
+export type CurrectCityApiPayload = {
+    latitude?: number;
+    longitude?: number;
+};
+export type CurrectCityApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+    currectCity: string;
+    cityCode: string;
+};

package/src/services/apis/metro/cancelTicket/apis.ts

@@ -0,0 +1,16 @@
+import { consoleFunc } from "../../../../utils/consoleFunc";
+import { apiCall } from "../../../apiCall";
+import { hardCancelMetroTicketApiPath, softCancelMetroTicketApiPath } from "../../../apiRoutes";
+import { HardCancelMetroTicketApiPayload, HardCancelMetroTicketApiResponse, SoftCancelMetroTicketApiPayload, SoftCancelMetroTicketApiResponse } from "./types";
+
+// SOFT CANCEL METRO TICKET
+export const softCancelMetroTicketApi = async (payload: SoftCancelMetroTicketApiPayload): Promise<SoftCancelMetroTicketApiResponse> => {
+    const data = await apiCall<SoftCancelMetroTicketApiResponse, SoftCancelMetroTicketApiPayload>("post", `${softCancelMetroTicketApiPath}`, payload);
+    return data;
+}
+
+// HARD CANCEL METRO TICKET
+export const hardCancelMetroTicketApi = async (payload: HardCancelMetroTicketApiPayload): Promise<HardCancelMetroTicketApiResponse> => {
+    const data = await apiCall<HardCancelMetroTicketApiResponse, HardCancelMetroTicketApiPayload>("post", `${hardCancelMetroTicketApiPath}`, payload);
+    return data;
+}

package/src/services/apis/metro/cancelTicket/hooks.ts

@@ -0,0 +1,42 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import Toast from "react-native-toast-message";
+import { HardCancelMetroTicketApiPayload, HardCancelMetroTicketApiResponse, SoftCancelMetroTicketApiPayload, SoftCancelMetroTicketApiResponse } from "./types";
+import { hardCancelMetroTicketApi, softCancelMetroTicketApi } from "./apis";
+
+// SOFT CANCEL METRO TICKET
+export const useMutateSoftCancelMetroTicket = (response: (data: SoftCancelMetroTicketApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: SoftCancelMetroTicketApiPayload) => softCancelMetroTicketApi(payload),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: ["getAllTransactionsApi"] });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message
+                });
+            }
+        }
+    })
+}
+
+// HARD CANCEL METRO TICKET
+export const useMutateHardCancelMetroTicket = (response: (data: HardCancelMetroTicketApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: HardCancelMetroTicketApiPayload) => hardCancelMetroTicketApi(payload),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: ["getMetroTicketStatusApi", "getAllTransactionsApi"] });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message
+                });
+            }
+        }
+    })
+}

package/src/services/apis/metro/cancelTicket/types.ts

@@ -0,0 +1,21 @@
+// SOFT CANCEL METRO TICKET
+export type SoftCancelMetroTicketApiPayload = {
+    transaction_id: string;
+};
+export type SoftCancelMetroTicketApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+    result: {
+        cancellationCharges: number;
+        totalPrice: number;
+    }
+};
+
+// HARD CANCEL METRO TICKET
+export type HardCancelMetroTicketApiPayload = {
+    transaction_id: string;
+};
+export type HardCancelMetroTicketApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+};

package/src/services/apis/metro/confirmTicket/apis.ts

@@ -0,0 +1,8 @@
+import { apiCall } from "../../../apiCall";
+import { confirmMetroTicketApiPath } from "../../../apiRoutes";
+import { ConfirmMetroTicketApiPayload, ConfirmMetroTicketApiResponse } from "./types";
+
+export const confirmMetroTicketApi = async (payload: ConfirmMetroTicketApiPayload): Promise<ConfirmMetroTicketApiResponse> => {
+    const data = await apiCall<ConfirmMetroTicketApiResponse, ConfirmMetroTicketApiPayload>("post", `${confirmMetroTicketApiPath}`, payload);
+    return data;
+}

package/src/services/apis/metro/confirmTicket/hooks.ts

@@ -0,0 +1,22 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { confirmMetroTicketApi } from "./apis";
+import { ConfirmMetroTicketApiPayload, ConfirmMetroTicketApiResponse } from "./types";
+import Toast from "react-native-toast-message";
+
+export const useMutateConfirmMetroTicket = (response: (data: ConfirmMetroTicketApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: ConfirmMetroTicketApiPayload) => confirmMetroTicketApi(payload),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: ["getRecentTransactionsApi", "getAllTransactionsApi"] });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message || 'Confirm ticket fail.'
+                });
+            }
+        }
+    })
+}

package/src/services/apis/metro/confirmTicket/types.ts

@@ -0,0 +1,8 @@
+export type ConfirmMetroTicketApiPayload = {
+    transaction_id: string;
+}
+export type ConfirmMetroTicketApiResponse = {
+    status: string;
+    message: string;
+    transaction_id: string;
+}

package/src/services/apis/metro/fare/apis.ts

@@ -0,0 +1,9 @@
+import { apiCall } from "../../../apiCall";
+import { getMetroFaresApiPath } from "../../../apiRoutes";
+import { GetMetroFaresApiPayload, GetMetroFaresApiResponse } from "./types";
+
+// get METRO FARE
+export const getMetroFaresApi = async (payload: GetMetroFaresApiPayload): Promise<GetMetroFaresApiResponse> => {
+    const data = await apiCall<GetMetroFaresApiResponse, GetMetroFaresApiPayload>("post", `${getMetroFaresApiPath}`, payload);
+    return data;
+}

package/src/services/apis/metro/fare/hooks.ts

@@ -0,0 +1,18 @@
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { GetMetroFaresApiPayload } from "./types";
+import { getMetroFaresApi } from "./apis";
+
+// GET METRO FARES
+export const useFetchGetMetroFares = (payload: GetMetroFaresApiPayload) => {
+    return useQuery({
+        queryKey: ["getMetroFaresApi", payload],
+        queryFn: () => getMetroFaresApi(payload)
+    })
+}
+
+// GET METRO FARES
+export const useMutateGetMetroFares = () => {
+    return useMutation({
+        mutationFn: (payload: GetMetroFaresApiPayload) => getMetroFaresApi(payload)
+    })
+}

package/src/services/apis/metro/fare/types.ts

@@ -0,0 +1,27 @@
+// GET METRO FARE
+export type GetMetroFaresApiPayload = {
+    startStation: string;
+    destinationStation: string;
+    cityCode: string;
+};
+export type GetMetroFaresApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+    result: {
+        itemName: string;
+        maximumTicketAvi: number;
+        cityCode: string;
+        providers: {
+            providerName: string;
+            itemId: string;
+            price: number;
+            providerId: string;
+            transaction_id: string;
+            bpp_id: string;
+            startStationName: string;
+            destinationStationName: string;
+            startStationCode: string;
+            destinationStationCode: string;
+        }[];
+    }[];
+};

package/src/services/apis/metro/issue/apis.ts

@@ -0,0 +1,47 @@
+import { convertToQueryString } from "../../../../utils/queryString";
+import { apiCall } from "../../../apiCall";
+import { closeIssueApiPath, getAllMetroIssuesApiPath, getChatApiPath, getMetroIssueDetailsApiPath, raiseMetroTicketIssueApiPath, sendMessageApiPath } from "../../../apiRoutes";
+import { CloseIssueApiPayload, CloseIssueApiResponse, GetAllMetroIssuesApiPayload, GetAllMetroIssuesApiResponse, GetChatApiPayload, GetChatApiResponse, GetMetroIssueDetailsApiPayload, GetMetroIssueDetailsApiResponse, RaiseMetroTicketIssueApiPayload, RaiseMetroTicketIssueApiResponse, SendMessageApiPayload, SendMessageApiResponse } from "./types";
+
+// RAISE ISSUE
+export const raiseMetroTicketIssueApi = async (payload: RaiseMetroTicketIssueApiPayload): Promise<RaiseMetroTicketIssueApiResponse> => {
+    const data = await apiCall<RaiseMetroTicketIssueApiResponse, RaiseMetroTicketIssueApiPayload>("post", `${raiseMetroTicketIssueApiPath}`, payload);
+    return data;
+}
+
+// GET ALL METRO ISSUES
+export const getAllMetroIssuesApi = async (payload: GetAllMetroIssuesApiPayload): Promise<GetAllMetroIssuesApiResponse> => {
+    const data = await apiCall<GetAllMetroIssuesApiResponse>("post", `${getAllMetroIssuesApiPath}?${convertToQueryString(payload)}`);
+    return data;
+}
+
+// GET METRO ISSUE DETAILS
+export const getMetroIssueDetailsApi = async (payload: GetMetroIssueDetailsApiPayload): Promise<GetMetroIssueDetailsApiResponse> => {
+    const { transaction_id } = payload;
+    const data = await apiCall<GetMetroIssueDetailsApiResponse>("post", `${getMetroIssueDetailsApiPath}/${transaction_id}`);
+    return data;
+}
+
+// GET CHAT
+export const getChatApi = async (payload: GetChatApiPayload): Promise<GetChatApiResponse> => {
+    const { issueId, ...queryParams } = payload;
+    const data = await apiCall<GetChatApiResponse>("post", `${getChatApiPath}/${issueId}?${convertToQueryString(queryParams)}`);
+    return data;
+};
+
+// SEND MESSAGE API
+export const sendMessageApi = async (payload: SendMessageApiPayload): Promise<SendMessageApiResponse> => {
+    const { issueId, message } = payload;
+    const data = await apiCall<SendMessageApiResponse, { message: string }>(
+        "post",
+        `${sendMessageApiPath}/${issueId}`,
+        { message }
+    );
+    return data;
+};
+
+// CLOSE ISSUE
+export const closeIssueApi = async (payload: CloseIssueApiPayload): Promise<CloseIssueApiResponse> => {
+    const data = await apiCall<CloseIssueApiResponse, CloseIssueApiPayload>("post", `${closeIssueApiPath}`, payload);
+    return data;
+};

package/src/services/apis/metro/issue/hooks.ts

@@ -0,0 +1,99 @@
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import Toast from "react-native-toast-message";
+import { CloseIssueApiPayload, CloseIssueApiResponse, GetAllMetroIssuesApiPayload, GetChatApiPayload, GetChatApiResponse, GetMetroIssueDetailsApiPayload, RaiseMetroTicketIssueApiPayload, RaiseMetroTicketIssueApiResponse, SendMessageApiPayload, SendMessageApiResponse } from "./types";
+import { closeIssueApi, getAllMetroIssuesApi, getChatApi, getMetroIssueDetailsApi, raiseMetroTicketIssueApi, sendMessageApi } from "./apis";
+
+// REQUEST RAISE ISSUE
+export const useMutateRaiseMetroTicketIssue = (response: (data: RaiseMetroTicketIssueApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: RaiseMetroTicketIssueApiPayload) => raiseMetroTicketIssueApi(payload),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: [""] });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message || 'Error Raising issue.'
+                });
+            }
+        }
+    })
+}
+
+// GET ALL METRO ISSUES
+export const useFetchGetAllMetroIssues = (payload: Omit<GetAllMetroIssuesApiPayload, "page" | "limit">) => {
+    return useInfiniteQuery({
+        queryKey: ["getAllMetroIssuesApi", payload],
+        queryFn: ({ pageParam }) => getAllMetroIssuesApi({ page: pageParam, limit: 10, ...payload }),
+        initialPageParam: 1,
+        getNextPageParam: lastPage => {
+            if (lastPage.nextPage) {
+                return lastPage.nextPage
+            }
+        }
+    })
+}
+
+// GET ISSUE DETAILS
+export const useFetchGetMetroIssueDetails = (payload: GetMetroIssueDetailsApiPayload) => {
+    return useQuery({
+        queryKey: ["getMetroIssueDetailsApi", payload],
+        queryFn: () => getMetroIssueDetailsApi(payload)
+    })
+}
+
+// SEND MESSAGES
+export const useMutateSendMessage = (response: (data: SendMessageApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: SendMessageApiPayload) => sendMessageApi(payload),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: ["getChat"] });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message || 'Error Raising issue.'
+                });
+            }
+        }
+    })
+}
+
+// GET CHAT
+export const useFetchGetChat = (payload: GetChatApiPayload) => {
+    const { issueId } = payload;
+
+    return useQuery<GetChatApiResponse>({
+        queryKey: ["getChat", issueId],
+        queryFn: () => getChatApi(payload),
+    });
+};
+
+// CLOSE ISSUE  
+export const useMutateCloseIssue = (onSuccess: (data: CloseIssueApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: CloseIssueApiPayload) => closeIssueApi(payload),
+        onSuccess: data => {
+            if (data.status === 'success') {
+                onSuccess(data);
+                queryClient.invalidateQueries({ queryKey: ["getChat"] });
+                queryClient.invalidateQueries({ queryKey: ["getMetroIssueDetailsApi"] });
+                queryClient.invalidateQueries({ queryKey: ["getAllMetroIssuesApi"] });
+                Toast.show({
+                    type: "success",
+                    text1: data.message
+                });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message || "Error closing issue"
+                });
+            }
+        }
+    })
+}

package/src/services/apis/metro/issue/types.ts

@@ -0,0 +1,108 @@
+// RAISE ISSUE
+export type RaiseMetroTicketIssueApiPayload = {
+    transaction_id: string;
+    orders: {
+        transaction_id: string;
+        category: string;
+        sub_category: string;
+        short_desc: string;
+        long_desc: string;
+    }[];
+};
+export type RaiseMetroTicketIssueApiResponse = {
+    status: "success" | "error";
+    message: string;
+};
+
+// GET ALL ISSUES
+export type GetAllMetroIssuesApiPayload = {
+    status?: string;
+    page: number;
+    limit: number;
+};
+export type GetAllMetroIssuesApiResponse = {
+    status: "success" | "error";
+    message: string;
+    nextPage: null | number;
+    allIssues: {
+        _id: string;
+        issueCount: number;
+        createdAt: string;
+        status: string;
+        startStation: string;
+        destinationStation: string;
+        orderCount: number;
+        totalTicketsPerOrder: number;
+    }[];
+};
+
+// GET ISSUE DETAILS
+export type GetMetroIssueDetailsApiPayload = {
+    transaction_id: string;
+};
+export type GetMetroIssueDetailsApiResponse = {
+    status: "success" | "error";
+    message: string;
+    issue: {
+        issueId: string;
+        issue_id: string;
+        transaction_id: string;
+        category: {
+            value: string;
+            label: string;
+        },
+        sub_category: {
+            key: string;
+            value: string;
+        },
+        short_desc: string;
+        long_desc: string;
+        status: string;
+        statusFlow: {
+            status: string;
+            description: string;
+        }[];
+        statusFlowSeller: {
+            status: string;
+            updatedAt: string;
+            updatedBy: string;
+        }[];
+        startStationName: string;
+        destinationStationName: string;
+    }[]
+};
+
+// Payload and Response Types for Get Chat
+export interface GetChatApiPayload {
+    issueId: string;
+}
+
+export interface GetChatApiResponse {
+    status: "success" | "error";
+    message: string;
+    chat: {
+        sender: string;
+        message: string;
+    }[];
+}
+
+// Payload and Response Types for send message
+export interface SendMessageApiPayload {
+    issueId: string;
+    message: string;
+}
+
+export interface SendMessageApiResponse {
+    status: "success" | "error";
+    message: string;
+}
+
+// CLOSE ISSUE
+export type CloseIssueApiPayload = {
+    transaction_id: string;
+    rating: string;
+}
+export type CloseIssueApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+}

package/src/services/apis/metro/payment/apis.ts

@@ -0,0 +1,21 @@
+import { apiCall } from "../../../apiCall";
+import { createPaymentApiPath, errorPaymentApiPath, verifyPaymentApiPath } from "../../../apiRoutes";
+import { CreatePaymentApiPayload, CreatePaymentApiResponse, ErrorPaymentApiPayload, ErrorPaymentApiResponse, VerifyPaymentApiPayload, VerifyPaymentApiResponse } from "./types";
+
+// CREATE PAYMENT
+export const createPaymentApi = async (payload: CreatePaymentApiPayload): Promise<CreatePaymentApiResponse> => {
+    const data = await apiCall<CreatePaymentApiResponse, CreatePaymentApiPayload>("post", `${createPaymentApiPath}`, payload);
+    return data;
+}
+
+// VERIFY PAYMENT
+export const verifyPaymentApi = async (payload: VerifyPaymentApiPayload): Promise<VerifyPaymentApiResponse> => {
+    const data = await apiCall<VerifyPaymentApiResponse, VerifyPaymentApiPayload>("post", `${verifyPaymentApiPath}`, payload);
+    return data;
+}
+
+// ERROR PAYMENT
+export const errorPaymentApi = async (payload: ErrorPaymentApiPayload): Promise<ErrorPaymentApiResponse> => {
+    const data = await apiCall<ErrorPaymentApiResponse, ErrorPaymentApiPayload>("post", `${errorPaymentApiPath}`, payload);
+    return data;
+}

package/src/services/apis/metro/payment/hooks.ts

@@ -0,0 +1,65 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { CreatePaymentApiPayload, CreatePaymentApiResponse, ErrorPaymentApiPayload, ErrorPaymentApiResponse, VerifyPaymentApiPayload, VerifyPaymentApiResponse } from "./types";
+import { createPaymentApi, errorPaymentApi, verifyPaymentApi } from "./apis";
+import Toast from "react-native-toast-message";
+
+// CREATE PAYMENT API
+export const useMutateCreatePayment = (response: (data: CreatePaymentApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: CreatePaymentApiPayload) => createPaymentApi(payload),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: [""] });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message || 'Error Creating Payment.'
+                });
+            }
+        }
+    })
+}
+
+// VERIFY PAYMENT API
+export const useMutateVerifyPayment = (response: (data: VerifyPaymentApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: VerifyPaymentApiPayload) => verifyPaymentApi(payload),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                queryClient.invalidateQueries({ queryKey: [""] });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: data.message || 'Error Verifing payment.'
+                });
+            }
+        }
+    })
+}
+
+// ERROR PAYMENT API
+export const useMutateErrorPayment = (response: (data: ErrorPaymentApiResponse) => void) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload: ErrorPaymentApiPayload) => errorPaymentApi(payload),
+        onSuccess: data => {
+            response(data);
+            if (data.status === 'success') {
+                Toast.show({
+                    type: "error",
+                    text1: 'Payment Failed.'
+                });
+                queryClient.invalidateQueries({ queryKey: [""] });
+            } else {
+                Toast.show({
+                    type: "error",
+                    text1: 'Payment Failed.'
+                });
+            }
+        }
+    })
+}

package/src/services/apis/metro/payment/types.ts

@@ -0,0 +1,42 @@
+// CREATE PAYMENT
+export type CreatePaymentApiPayload = {
+    transaction_id: string;
+    amount: number;
+};
+export type CreatePaymentApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+    payment: {
+        _id: string;
+        amount: number;
+        amount_due: number;
+        amount_paid: number;
+        currency: string;
+        order_id: string;
+    }
+};
+
+// VERIFY PAYMENT
+export type VerifyPaymentApiPayload = {
+    razorpay_order_id: string;
+    razorpay_payment_id: string;
+    razorpay_signature: string;
+}
+export type VerifyPaymentApiResponse = {
+    status: "success" | "error";
+    message: string;
+    payment: {
+        transaction_id: string;
+    }
+}
+
+// ERROR PAYMENT
+export type ErrorPaymentApiPayload = {
+    order_id: string;
+    error: any;
+
+};
+export type ErrorPaymentApiResponse = {
+    status: 'success' | 'error';
+    message: string;
+};

package/src/services/apis/metro/providers/apis.ts

@@ -0,0 +1,15 @@
+import { apiCall } from "../../../apiCall";
+import { getMetroProvidersApiPath, requestMetroProvidersApiPath } from "../../../apiRoutes";
+import { GetMetroProvidersApiPayload, GetMetroProvidersApiResponse, RequestMetroProvidersApiPayload, RequestMetroProvidersApiResponse } from "./types";
+
+// REQUEST METRO PROVIDERS
+export const requestMetroProvidersApi = async (payload: RequestMetroProvidersApiPayload): Promise<RequestMetroProvidersApiResponse> => {
+    const data = await apiCall<RequestMetroProvidersApiResponse, RequestMetroProvidersApiPayload>("post", `${requestMetroProvidersApiPath}`, payload);
+    return data;
+}
+
+// GET METRO PROVIDERS
+export const getMetroProvidersApi = async (payload: GetMetroProvidersApiPayload): Promise<GetMetroProvidersApiResponse> => {
+    const data = await apiCall<GetMetroProvidersApiResponse>("post", `${getMetroProvidersApiPath}`, payload);
+    return data;
+}