@vulog/aima-booking 1.2.30 → 1.2.32

package/dist/index.js

@@ -1,647 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  allocateVehicle: () => allocateVehicle,
-  cancelBookingRequest: () => cancelBookingRequest,
-  deallocateVehicle: () => deallocateVehicle,
-  getAvailableVehicles: () => getAvailableVehicles,
-  getBookingRequestById: () => getBookingRequestById,
-  getBookingRequestByTrip: () => getBookingRequestByTrip,
-  getBookingRequests: () => getBookingRequests,
-  getBookingRequestsByUserId: () => getBookingRequestsByUserId,
-  getSATBookingRequests: () => getSATBookingRequests,
-  getScheduleBookingRequests: () => getScheduleBookingRequests,
-  getStationById: () => getStationById,
-  getStations: () => getStations,
-  getSubscriptionBookingRequestById: () => getSubscriptionBookingRequestById,
-  getSubscriptionBookingRequests: () => getSubscriptionBookingRequests,
-  releaseBRPayment: () => releaseBRPayment,
-  triggerBRPayment: () => triggerBRPayment,
-  updateScheduleBooking: () => updateScheduleBooking
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/getBookingRequests.ts
-var import_aima_core = require("@vulog/aima-core");
-var import_compat = require("es-toolkit/compat");
-var import_zod = require("zod");
-var BookingRequestStatusSchema = import_zod.z.enum([
-  "ALERT",
-  "UPCOMING",
-  "ONGOING",
-  "COMPLETED",
-  "CANCELLED",
-  "PENDING_APPROVAL",
-  "CONFIRMED",
-  "PENDING",
-  "LATE"
-]);
-var ServiceTypeSchema = import_zod.z.enum(["SUBSCRIPTION", "ROUND_TRIP_BOOKING", "SCHEDULED_BOOKING_STATION"]);
-var getBookingRequests = async (client, status, options) => {
-  const preparedOptions = options ? { ...options, filters: options.filters || {} } : { filters: {} };
-  const resultStatus = BookingRequestStatusSchema.safeParse(status);
-  if (!resultStatus.success) {
-    throw new TypeError("Invalid status", {
-      cause: resultStatus.error.issues
-    });
-  }
-  const date = /* @__PURE__ */ new Date();
-  date.setMilliseconds(0);
-  const startDate = date.toISOString().replace(".000Z", "Z");
-  date.setMonth(date.getMonth() + 2);
-  const endDate = date.toISOString().replace(".000Z", "Z");
-  const BookingRequestFiltersSchema = import_zod.z.object({
-    serviceTypes: import_zod.z.array(ServiceTypeSchema).optional(),
-    serviceIds: import_zod.z.array(import_zod.z.string().uuid()).optional(),
-    userId: import_zod.z.string().uuid().optional(),
-    modelId: import_zod.z.number().positive().optional(),
-    vehicleId: import_zod.z.string().uuid().optional(),
-    stationId: import_zod.z.string().uuid().optional(),
-    creationDate: import_zod.z.string().date().optional(),
-    startDate: import_zod.z.string().datetime({ offset: false, precision: 0 }).default(startDate),
-    endDate: import_zod.z.string().datetime({ offset: false, precision: 0 }).default(endDate),
-    includeProducts: import_zod.z.enum(["true", "false"]).optional()
-  }).default({});
-  const PaginableOptionsSchema = (0, import_aima_core.createPaginableOptionsSchema)(BookingRequestFiltersSchema).default({});
-  const resultOptions = PaginableOptionsSchema.safeParse(preparedOptions);
-  if (!resultOptions.success) {
-    throw new TypeError("Invalid options", {
-      cause: resultOptions.error.issues
-    });
-  }
-  const finalOptions = resultOptions.data;
-  const searchParams = new URLSearchParams();
-  searchParams.append("page", finalOptions.page.toString());
-  searchParams.append("size", finalOptions.pageSize.toString());
-  Object.entries(finalOptions.filters).forEach(([key, value]) => {
-    if (value === void 0) {
-      return;
-    }
-    if (Array.isArray(value) && value.length > 0) {
-      searchParams.append(key, value.join(","));
-      return;
-    }
-    if ((0, import_compat.isNumber)(value)) {
-      searchParams.append(key, value.toString());
-      return;
-    }
-    searchParams.append(key, value);
-  });
-  return client.get(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/status/${status}/filters?${searchParams.toString()}`).then(({ data, headers }) => {
-    return {
-      data,
-      page: headers.number,
-      pageSize: headers.size,
-      total: headers.totalelements,
-      totalPages: headers.totalpages
-    };
-  });
-};
-var getScheduleBookingRequests = async (client, status, options) => {
-  return getBookingRequests(client, status, {
-    ...options,
-    filters: {
-      ...options?.filters,
-      serviceTypes: ["ROUND_TRIP_BOOKING", "SCHEDULED_BOOKING_STATION"]
-    }
-  });
-};
-var getSubscriptionBookingRequests = async (client, status, options) => {
-  return getBookingRequests(client, status, {
-    ...options,
-    filters: {
-      ...options?.filters,
-      serviceTypes: ["SUBSCRIPTION"]
-    }
-  });
-};
-
-// src/getSATBookingRequests.ts
-var import_aima_core2 = require("@vulog/aima-core");
-var import_zod2 = require("zod");
-var SATBookingRequestStatusSchema = import_zod2.z.enum([
-  "ALERT",
-  "CANCELLED",
-  "COMPLETED",
-  "CONFIRMED",
-  "LATE_RETURN",
-  "ONGOING",
-  "PENDING_PAYMENT",
-  "PENDING",
-  "UPCOMING_ALLOCATED",
-  "UPCOMING_NOT_ALLOCATED"
-]);
-var getSATBookingRequests = async (client, status, options) => {
-  const resultStatus = SATBookingRequestStatusSchema.safeParse(status);
-  if (!resultStatus.success) {
-    throw new TypeError("Invalid status", {
-      cause: resultStatus.error.issues
-    });
-  }
-  const PaginableOptionsSchema = (0, import_aima_core2.createPaginableOptionsSchema)().default({});
-  const resultOptions = PaginableOptionsSchema.safeParse(options);
-  if (!resultOptions.success) {
-    throw new TypeError("Invalid options", {
-      cause: resultOptions.error.issues
-    });
-  }
-  const finalOptions = resultOptions.data;
-  const searchParams = new URLSearchParams();
-  if (finalOptions.page) {
-    searchParams.append("page", finalOptions.page.toString());
-  }
-  if (finalOptions.pageSize) {
-    searchParams.append("size", finalOptions.pageSize.toString());
-  }
-  if (finalOptions.sortDirection && finalOptions.sort) {
-    searchParams.append("sort", `${finalOptions.sort},${finalOptions.sortDirection}`);
-  }
-  if (finalOptions.sort && !finalOptions.sortDirection) {
-    searchParams.append("sort", finalOptions.sort);
-  }
-  return client.get(`/boapi/proxy/user/scheduleATrip/fleets/${client.clientOptions.fleetId}/bookingrequests/status/${status}?${searchParams.toString()}`).then(({ data, headers }) => {
-    return {
-      data,
-      page: headers.number,
-      pageSize: headers.size,
-      total: headers.totalelements,
-      totalPages: headers.totalpages
-    };
-  });
-};
-
-// src/getBookingRequest.ts
-var import_zod3 = require("zod");
-var getBookingRequestById = async (client, id) => {
-  const result = import_zod3.z.string().trim().min(1).uuid().safeParse(id);
-  if (!result.success) {
-    throw new TypeError("Invalid id", {
-      cause: result.error.issues
-    });
-  }
-  return client.get(
-    `/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/${id}`
-  ).then(({ data }) => data);
-};
-var getBookingRequestByTrip = async (client, tripId) => {
-  const result = import_zod3.z.string().trim().min(1).safeParse(tripId);
-  if (!result.success) {
-    throw new TypeError("Invalid tripId", {
-      cause: result.error.issues
-    });
-  }
-  return client.get(
-    `/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/trip/${tripId}`
-  ).then(({ data }) => data);
-};
-var getSubscriptionBookingRequestById = async (client, id) => {
-  const result = import_zod3.z.string().trim().min(1).uuid().safeParse(id);
-  if (!result.success) {
-    throw new TypeError("Invalid id", {
-      cause: result.error.issues
-    });
-  }
-  return client.get(
-    `/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/subscription/bookingrequests/${id}`
-  ).then(({ data: { stationId, ...data } }) => ({ station: stationId, ...data }));
-};
-
-// src/getAvailableVehicles.ts
-var import_zod4 = require("zod");
-var isoDateTimeNoMs = import_zod4.z.string().trim().datetime({ precision: 0 });
-var getAvailableVehiclesSchema = import_zod4.z.object({
-  stationId: import_zod4.z.string().trim().min(1),
-  startDate: isoDateTimeNoMs
-});
-var getAvailableVehicles = async (client, stationId, startDate) => {
-  const result = getAvailableVehiclesSchema.safeParse({ stationId, startDate });
-  if (!result.success) {
-    throw new TypeError("Invalid args", {
-      cause: result.error.issues
-    });
-  }
-  return client.get(
-    `/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/subscription/stations/${stationId}/vehicles/available?startDate=${startDate}`
-  ).then(({ data }) => data);
-};
-
-// src/getStations.ts
-var import_zod5 = require("zod");
-var IncludeSchema = import_zod5.z.enum(["INFO", "OPEN_HOUR", "SERVICES"]);
-var IncludesSchema = import_zod5.z.array(IncludeSchema);
-var getStations = async (client, includes = []) => {
-  const resultIncludes = IncludesSchema.safeParse(includes);
-  if (!resultIncludes.success) {
-    throw new TypeError("Invalid includes", {
-      cause: resultIncludes.error.issues
-    });
-  }
-  const searchParams = new URLSearchParams();
-  if (includes.includes("OPEN_HOUR")) {
-    searchParams.append("showTimetable", "true");
-  }
-  const stations = await client.get(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/stations${searchParams.size > 0 ? `?${searchParams.toString()}` : ""}`).then(
-    ({ data }) => data.map(
-      (station) => Object.keys(station).reduce((acc, key) => {
-        if (key === "stationTimetableDTO") {
-          if (station.stationTimetableDTO?.stationId) {
-            acc.openingHours = {
-              alwaysOpen: station.stationTimetableDTO.alwaysOpen,
-              timetable: Object.keys(station.stationTimetableDTO.timetable).reduce(
-                (timetable, val) => {
-                  timetable[val] = station.stationTimetableDTO.timetable[val].map(
-                    (day) => ({
-                      id: day.id,
-                      closed: day.closed,
-                      openAt: day.openAt,
-                      closeAt: day.closeAt
-                    })
-                  );
-                  return timetable;
-                },
-                {}
-              )
-            };
-          }
-          return acc;
-        }
-        acc[key] = station[key];
-        return acc;
-      }, {})
-    )
-  );
-  if (includes.includes("INFO")) {
-    const pois = await client.get(`/boapi/proxy/geoloc/fleets/${client.clientOptions.fleetId}/pois`, {
-      headers: { accept: "application/vnd.geo+json" }
-    }).then(
-      ({ data }) => data.features.reduce((acc, poi) => {
-        const {
-          geometry: {
-            coordinates: [longitude, latitude]
-          },
-          properties
-        } = poi;
-        acc[properties.poiId] = {
-          name: properties.name,
-          coordinates: { latitude, longitude },
-          geoProperties: properties
-        };
-        return acc;
-      }, {})
-    );
-    stations.forEach((station) => {
-      if (station.poiId && pois[station.poiId]) {
-        Object.assign(station, pois[station.poiId]);
-      }
-    });
-  }
-  if (includes.includes("SERVICES")) {
-    const services = await client.get(`/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/stations/details?size=1000`).then(
-      ({ data }) => data.stations.reduce((acc, service) => {
-        if (!acc[service.station.id]) {
-          acc[service.station.id] = { services: [] };
-        }
-        acc[service.station.id].services.push({
-          id: service.serviceId,
-          models: service.station.models
-        });
-        return acc;
-      }, {})
-    );
-    stations.forEach((station) => {
-      if (services[station.id]) {
-        Object.assign(station, services[station.id]);
-      }
-    });
-  }
-  return stations;
-};
-
-// src/getStation.ts
-var import_zod6 = require("zod");
-var IncludeSchema2 = import_zod6.z.enum(["INFO", "SERVICES"]);
-var IncludesSchema2 = import_zod6.z.array(IncludeSchema2);
-var getStationById = async (client, id, includes = []) => {
-  const resultIncludes = IncludesSchema2.safeParse(includes);
-  if (!resultIncludes.success) {
-    throw new TypeError("Invalid includes", {
-      cause: resultIncludes.error.issues
-    });
-  }
-  const station = await client.get(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/stations/${id}`).then(({ data, status }) => {
-    if (status === 200) {
-      return Object.keys(data).reduce((acc, key) => {
-        if (key === "stationTimetableDTO") {
-          if (data.stationTimetableDTO?.stationId) {
-            acc.openingHours = {
-              alwaysOpen: data.stationTimetableDTO.alwaysOpen,
-              timetable: Object.keys(data.stationTimetableDTO.timetable).reduce(
-                (timetable, val) => {
-                  timetable[val] = data.stationTimetableDTO.timetable[val].map(
-                    (day) => ({
-                      id: day.id,
-                      closed: day.closed,
-                      openAt: day.openAt,
-                      closeAt: day.closeAt
-                    })
-                  );
-                  return timetable;
-                },
-                {}
-              )
-            };
-          }
-          return acc;
-        }
-        acc[key] = data[key];
-        return acc;
-      }, {});
-    }
-    if (status === 400) {
-      return null;
-    }
-    return null;
-  }).catch((error) => {
-    if (error.formattedError?.status === 400) {
-      return null;
-    }
-    throw error;
-  });
-  if (station && includes.includes("INFO")) {
-    const poi = await client.get(
-      `/boapi/proxy/geoloc/fleets/${client.clientOptions.fleetId}/pois/${station.poiId}`,
-      {
-        headers: { accept: "application/vnd.geo+json" }
-      }
-    ).then(
-      ({ data }) => data.features.reduce(
-        (max, current) => {
-          if (current.properties.Version > max.version) {
-            const {
-              geometry: {
-                coordinates: [longitude, latitude]
-              },
-              properties
-            } = current;
-            return {
-              version: current.properties.Version,
-              name: properties.name,
-              coordinates: { latitude, longitude },
-              geoProperties: properties
-            };
-          }
-          return max;
-        },
-        { version: -1 }
-      )
-    );
-    if (station.poiId && poi) {
-      poi.version = void 0;
-      Object.assign(station, poi);
-      station.name = station.geoProperties?.name;
-    }
-  }
-  if (station && includes.includes("SERVICES")) {
-    const services = await client.get(`/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/stations/details?showTimetable=false`).then(
-      ({ data }) => data.stations.reduce((acc, service) => {
-        if (!acc[service.station.id]) {
-          acc[service.station.id] = { services: [] };
-        }
-        acc[service.station.id].services.push({
-          id: service.serviceId,
-          models: service.station.models
-        });
-        return acc;
-      }, {})
-    );
-    if (services[station.id]) {
-      Object.assign(station, services[station.id]);
-    }
-  }
-  return station;
-};
-
-// src/allocateVehicle.ts
-var import_zod7 = __toESM(require("zod"));
-var allocateVehicleSchema = import_zod7.default.object({
-  bookingRequestId: import_zod7.default.string().uuid(),
-  vehicleId: import_zod7.default.string().uuid(),
-  serviceId: import_zod7.default.string().uuid()
-});
-var allocateVehicle = async (client, bookingRequestId, vehicleId, serviceId) => {
-  const resultPayload = allocateVehicleSchema.safeParse({ bookingRequestId, vehicleId, serviceId });
-  if (!resultPayload.success) {
-    throw new TypeError("Invalid args", {
-      cause: resultPayload.error.issues
-    });
-  }
-  return client.post(
-    `boapi/proxy/user/scheduleATrip/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/allocate/${vehicleId}?serviceId=${serviceId}`
-  ).then(({ data }) => data);
-};
-
-// src/deallocateVehicle.ts
-var import_zod8 = __toESM(require("zod"));
-var deallocateVehicleSchema = import_zod8.default.object({
-  bookingRequestId: import_zod8.default.string().uuid(),
-  vehicleId: import_zod8.default.string().uuid()
-});
-var deallocateVehicle = async (client, bookingRequestId, vehicleId) => {
-  const resultPayload = deallocateVehicleSchema.safeParse({ bookingRequestId, vehicleId });
-  if (!resultPayload.success) {
-    throw new TypeError("Invalid args", {
-      cause: resultPayload.error.issues
-    });
-  }
-  return client.delete(
-    `boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/vehicles/${vehicleId}`
-  ).then(({ data }) => data);
-};
-
-// src/updateScheduleBooking.ts
-var import_zod9 = __toESM(require("zod"));
-var schema = import_zod9.default.object({
-  id: import_zod9.default.string(),
-  startDate: import_zod9.default.string().refine((date) => !Number.isNaN(Date.parse(date)), {
-    message: "Invalid date"
-  }).optional(),
-  latitude: import_zod9.default.number().min(-90).max(90).optional(),
-  longitude: import_zod9.default.number().min(-180).max(180).optional(),
-  radius: import_zod9.default.number().min(0).optional(),
-  userId: import_zod9.default.string().optional(),
-  status: import_zod9.default.enum(["CONFIRMED", "CANCELLED", "PENDING"]).optional(),
-  cityId: import_zod9.default.string().optional(),
-  profileId: import_zod9.default.string().optional(),
-  serviceId: import_zod9.default.string().optional(),
-  warning: import_zod9.default.string().optional(),
-  modelId: import_zod9.default.number().optional(),
-  notes: import_zod9.default.string().optional(),
-  bookingReferenceId: import_zod9.default.string().optional(),
-  plannedReturnDate: import_zod9.default.string().refine((date) => !Number.isNaN(Date.parse(date)), {
-    message: "Invalid date"
-  }).optional()
-});
-var updateScheduleBooking = async (client, bookingRequestId, updateData) => {
-  const result = schema.safeParse({ id: bookingRequestId, ...updateData });
-  if (!result.success) {
-    throw new TypeError("Invalid args", {
-      cause: result.error.issues
-    });
-  }
-  return client.post(
-    `/boapi/proxy/user/scheduleATrip/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}`,
-    updateData
-  ).then(({ data }) => data);
-};
-
-// src/triggerBRPayment.ts
-var import_zod10 = __toESM(require("zod"));
-var triggerBRPaymentSchema = import_zod10.default.object({
-  bookingRequestId: import_zod10.default.string().uuid(),
-  body: import_zod10.default.object({
-    scope: import_zod10.default.enum(["RENTAL", "DEPOSIT"]),
-    requiresActionReturnURL: import_zod10.default.string().url().optional(),
-    online: import_zod10.default.boolean(),
-    amountType: import_zod10.default.enum(["FIXED", "PERCENTAGE"]),
-    amountValue: import_zod10.default.number().nonnegative(),
-    preferredPaymentMethods: import_zod10.default.array(
-      import_zod10.default.object({
-        pspReference: import_zod10.default.string(),
-        amount: import_zod10.default.number().default(0)
-      })
-    ).optional(),
-    profileId: import_zod10.default.string().uuid()
-  })
-});
-var triggerBRPayment = async (client, bookingRequestId, body) => {
-  const resultPayload = triggerBRPaymentSchema.safeParse({ bookingRequestId, body });
-  if (!resultPayload.success) {
-    throw new TypeError("Invalid args", {
-      cause: resultPayload.error.issues
-    });
-  }
-  return client.post(
-    `boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/payment`,
-    resultPayload.data.body
-  ).then(({ data }) => data).catch((error) => {
-    throw new TypeError("Failed to trigger booking request payment", {
-      cause: error
-    });
-  });
-};
-
-// src/getBookingRequestsByUserId.ts
-var import_zod11 = require("zod");
-var schema2 = import_zod11.z.object({
-  userId: import_zod11.z.string().trim().min(1).uuid()
-});
-var getBookingRequestsByUserId = async (client, userId) => {
-  const result = schema2.safeParse({ userId });
-  if (!result.success) {
-    throw new TypeError("Invalid userId", {
-      cause: result.error.issues
-    });
-  }
-  return client.get(
-    `/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/users/${userId}`
-  ).then(({ data }) => data).catch((error) => {
-    if (error.formattedError?.status === 404) {
-      return [];
-    }
-    throw error;
-  });
-};
-
-// src/releaseBRPayment.ts
-var import_zod12 = __toESM(require("zod"));
-var releaseBRPaymentSchema = import_zod12.default.object({
-  bookingRequestId: import_zod12.default.string().uuid(),
-  pspReference: import_zod12.default.string().uuid()
-});
-var releaseBRPayment = async (client, bookingRequestId, pspReference) => {
-  const resultPayload = releaseBRPaymentSchema.safeParse({ bookingRequestId, pspReference });
-  if (!resultPayload.success) {
-    throw new TypeError("Invalid args", {
-      cause: resultPayload.error.issues
-    });
-  }
-  return client.post(
-    `boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/paymentintent/${pspReference}/cancel`,
-    {}
-  ).then(({ data }) => data).catch((error) => {
-    throw new TypeError("Failed to release booking request payment", {
-      cause: error
-    });
-  });
-};
-
-// src/cancelBookingRequest.ts
-var import_zod13 = __toESM(require("zod"));
-var schema3 = import_zod13.default.object({
-  id: import_zod13.default.string().uuid()
-});
-var cancelBookingRequest = async (client, id) => {
-  const result = schema3.safeParse({ id });
-  if (!result.success) {
-    throw new TypeError("Invalid args", {
-      cause: result.error.issues
-    });
-  }
-  return client.post(
-    `/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/cancel/${id}`,
-    {}
-  ).then(({ data }) => data).catch((error) => {
-    throw new TypeError("Failed to cancel booking request", {
-      cause: error
-    });
-  });
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  allocateVehicle,
-  cancelBookingRequest,
-  deallocateVehicle,
-  getAvailableVehicles,
-  getBookingRequestById,
-  getBookingRequestByTrip,
-  getBookingRequests,
-  getBookingRequestsByUserId,
-  getSATBookingRequests,
-  getScheduleBookingRequests,
-  getStationById,
-  getStations,
-  getSubscriptionBookingRequestById,
-  getSubscriptionBookingRequests,
-  releaseBRPayment,
-  triggerBRPayment,
-  updateScheduleBooking
-});