@vulog/aima-booking 1.2.42 → 1.2.43

package/dist/index.cjs

@@ -157,10 +157,10 @@ const getScheduledBookingById = async (client, bookingId) => {
 //#endregion
 //#region src/getAvailableVehicles.ts
 /** ISO date-time without milliseconds (e.g. 2025-02-10T12:00:00Z or 2025-02-10T12:00:00+01:00). */
-const isoDateTimeNoMs = zod.z.string().trim().datetime({ precision: 0 });
+const isoDateTimeNoMs$2 = zod.z.string().trim().datetime({ precision: 0 });
 const getAvailableVehiclesSchema = zod.z.object({
 	stationId: zod.z.string().trim().min(1),
-	startDate: isoDateTimeNoMs
+	startDate: isoDateTimeNoMs$2
 });
 const getAvailableVehicles = async (client, stationId, startDate) => {
 	const result = getAvailableVehiclesSchema.safeParse({
@@ -526,11 +526,117 @@ const createSubscription = async (client, body) => {
 	return client.post(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/subscription/bookingrequests`, result.data).then(({ data }) => data);
 };
 //#endregion
+//#region src/createBookingRequest.ts
+const createBookingRequestBodySchema = zod.z.object({
+	startDate: zod.z.string().trim().min(1),
+	endDate: zod.z.string().trim().min(1),
+	modelId: zod.z.number().int().positive(),
+	profileId: zod.z.string().trim().min(1).uuid(),
+	serviceId: zod.z.string().trim().min(1).uuid(),
+	userId: zod.z.string().uuid().optional(),
+	vehicleId: zod.z.string().uuid().optional(),
+	station: zod.z.string().optional(),
+	latitude: zod.z.number().optional(),
+	longitude: zod.z.number().optional(),
+	radius: zod.z.number().int().optional(),
+	email: zod.z.string().email().optional(),
+	notes: zod.z.string().optional(),
+	plannedReturnDate: zod.z.string().optional(),
+	deliveryAddress: zod.z.string().optional(),
+	deliveryAddressAdditionalInfo: zod.z.string().optional(),
+	deliveryCity: zod.z.string().optional(),
+	deliveryPostalCode: zod.z.string().optional(),
+	dropOffStation: zod.z.string().optional(),
+	rollingContract: zod.z.boolean().optional(),
+	planDurationInMonths: zod.z.number().int().optional(),
+	planName: zod.z.string().optional(),
+	parentId: zod.z.string().optional(),
+	contractType: zod.z.enum(["SVS", "MVS"]).optional(),
+	productIds: zod.z.array(zod.z.string()).optional(),
+	preallocatedVehicleId: zod.z.string().optional(),
+	bookingReferenceId: zod.z.string().optional(),
+	providedPricingId: zod.z.string().uuid().optional(),
+	preferredPaymentMethods: zod.z.array(zod.z.object({
+		pspReference: zod.z.string(),
+		amount: zod.z.number()
+	})).optional(),
+	requiresActionReturnURL: zod.z.string().optional(),
+	cityId: zod.z.string().optional()
+});
+/**
+* Create a new booking request.
+*
+* Swagger: `POST /scheduledBooking/fleets/{fleetId}/bookingrequests` (admin-booking).
+*/
+const createBookingRequest = async (client, body, options = {}) => {
+	const result = createBookingRequestBodySchema.safeParse(body);
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	const query = options.userStatusCheckRequired !== void 0 ? `?userStatusCheckRequired=${options.userStatusCheckRequired}` : "";
+	return client.post(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests${query}`, {
+		...result.data,
+		fleetId: client.clientOptions.fleetId
+	}).then(({ data }) => data);
+};
+//#endregion
+//#region src/getAvailableModels.ts
+/** ISO date-time without milliseconds (e.g. 2020-09-20T00:00:00Z or 2020-09-20T00:00:00+01:00). */
+const isoDateTimeNoMs$1 = zod.z.string().trim().datetime({ precision: 0 });
+const getAvailableModelsSchema = zod.z.object({
+	startDate: isoDateTimeNoMs$1,
+	endDate: isoDateTimeNoMs$1,
+	cityId: zod.z.string().trim().min(1).optional(),
+	userId: zod.z.string().uuid().optional(),
+	profileId: zod.z.string().uuid().optional(),
+	oneWayTrip: zod.z.boolean().optional(),
+	showUnavailableModels: zod.z.boolean().optional()
+});
+/**
+* Get available models grouped by station in a given time range.
+*
+* Swagger: `GET /scheduledBooking/fleets/{fleetId}/stations/models` (admin-booking / internal).
+*/
+const getAvailableModels = async (client, params) => {
+	const result = getAvailableModelsSchema.safeParse(params);
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	const searchParams = new URLSearchParams();
+	for (const [key, value] of Object.entries(result.data)) if (value !== void 0) searchParams.append(key, String(value));
+	return client.get(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/stations/models?${searchParams.toString()}`).then(({ data }) => data);
+};
+//#endregion
+//#region src/getStationUnavailability.ts
+/** ISO date-time without milliseconds (e.g. 2021-01-01T00:00:00Z). */
+const isoDateTimeNoMs = zod.z.string().trim().datetime({ precision: 0 });
+const getStationUnavailabilitySchema = zod.z.object({
+	stationId: zod.z.string().uuid(),
+	from: isoDateTimeNoMs,
+	to: isoDateTimeNoMs,
+	serviceId: zod.z.string().uuid()
+});
+/**
+* Get the list of vehicle unavailabilities for a given station over a period.
+*
+* Swagger: `GET /fleets/{fleetId}/stations/{stationId}/unavailability` (admin-booking,
+* operationId `getVehicleCalendarForPeriod`).
+*/
+const getStationUnavailability = async (client, params) => {
+	const result = getStationUnavailabilitySchema.safeParse(params);
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	const { stationId, from, to, serviceId } = result.data;
+	const searchParams = new URLSearchParams({
+		from,
+		to,
+		serviceId
+	});
+	return client.get(`/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/stations/${stationId}/unavailability?${searchParams.toString()}`).then(({ data }) => data);
+};
+//#endregion
 exports.allocateVehicle = allocateVehicle;
 exports.cancelBookingRequest = cancelBookingRequest;
+exports.createBookingRequest = createBookingRequest;
 exports.createSubscription = createSubscription;
 exports.deallocateVehicle = deallocateVehicle;
 exports.getAdditionalDrivers = getAdditionalDrivers;
+exports.getAvailableModels = getAvailableModels;
 exports.getAvailableVehicles = getAvailableVehicles;
 exports.getBookingRequestById = getBookingRequestById;
 exports.getBookingRequestByTrip = getBookingRequestByTrip;
@@ -542,6 +648,7 @@ exports.getScheduleBookingRequests = getScheduleBookingRequests;
 exports.getScheduledBookingById = getScheduledBookingById;
 exports.getSlaves = getSlaves;
 exports.getStationById = getStationById;
+exports.getStationUnavailability = getStationUnavailability;
 exports.getStations = getStations;
 exports.getSubscriptionBookingRequestById = getSubscriptionBookingRequestById;
 exports.getSubscriptionBookingRequests = getSubscriptionBookingRequests;

package/dist/index.d.cts

@@ -317,6 +317,71 @@ type BookingRequestSlave = {
   traveledDistance: number;
   energyLevelEnd: number;
 };
+/** Mileage allowance for an available model (Swagger: `MileageAllowanceDTO`). */
+type MileageAllowance = {
+  allowancePerDay?: number;
+  totalAllowance?: number;
+  pricePerExceedingUnit?: number;
+};
+/** Estimated product embedded in a price breakdown (Swagger: `EstimatedProductDTO`). */
+type EstimatedProduct = {
+  productId?: string;
+  price?: number;
+};
+/** Price breakdown for an available model (Swagger: `PriceBreakdownDTO`). */
+type PriceBreakdown = {
+  tripPrice?: number;
+  productsPrice?: number;
+  productDetails?: EstimatedProduct[];
+};
+/** Pricing info for an available model (Swagger: `PricingInfo`). */
+type PricingInfo = {
+  pricingId?: string;
+  type?: string;
+  priceBreakdown?: PriceBreakdown;
+};
+/** Available model entry returned by `getAvailableModels` (Swagger: `BookingRequestModelDTO`). */
+type AvailableModel = {
+  id: number;
+  price?: string;
+  prePaymentPrice?: number;
+  mileageAllowance?: MileageAllowance;
+  pricingInfo?: PricingInfo;
+};
+/** Station entry returned by `getAvailableModels` (Swagger: `StationDTO`). */
+type StationWithAvailableModels = {
+  id: string;
+  zoneId: string;
+  poiId: string;
+  models: AvailableModel[];
+  taxZoneId?: string;
+  cityId?: string;
+  serviceId?: string;
+  fleetId?: string;
+  openTime?: string;
+  closeTime?: string;
+};
+/** Single unavailability entry in a station vehicle calendar (Swagger: `UnavailabilityDTO`). */
+type VehicleUnavailability = {
+  id?: string;
+  vehicleId?: string;
+  modelId?: number;
+  from?: string;
+  to?: string;
+  toWithMargin?: string;
+  type?: 'BOOKING' | 'MAINTENANCE';
+  userId?: string;
+  reason?: string;
+  serviceId?: string;
+};
+/** Vehicle calendar for a station over a period (Swagger: `VehicleCalendarResponseDTO`). */
+type StationVehicleCalendar = {
+  timezone?: string;
+  from?: string;
+  to?: string;
+  vehicleIds?: string[];
+  unavailabilities?: VehicleUnavailability[];
+};
 //#endregion
 //#region src/getBookingRequests.d.ts
 declare const BookingRequestStatusSchema: z.ZodEnum<{
@@ -490,4 +555,85 @@ type CreateSubscriptionBody = {
 };
 declare const createSubscription: (client: Client, body: CreateSubscriptionBody) => Promise<BookingRequest>;
 //#endregion
-export { AdditionalDriver, AvailableVehiclesResponse, BRPaymentItem, BaseBookingRequest, BookingCredit, BookingRequest, type BookingRequestFilters, BookingRequestSlave, type BookingRequestStatus, Contract, type CreateSubscriptionBody, CustomPrice, DayOpeningHours, Days, GeoInfo, IFormatSlave, IFormatSubscription, type Include, type IncludeStation, Master, OpeningHours, PaymentReceipts, PreferredPaymentMethod, SATBookingRequest, type SATBookingRequestStatus, Service, ServiceInfo, type ServiceType, Slave, Station, Timetable, TriggerBRPaymentResponse, Vehicle, allocateVehicle, cancelBookingRequest, createSubscription, deallocateVehicle, getAdditionalDrivers, getAvailableVehicles, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getBookingRequestsByUserId, getDigitalContracts, getSATBookingRequests, getScheduleBookingRequests, getScheduledBookingById, getSlaves, getStationById, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests, getSubscriptionsByUserId, releaseBRPayment, submitCancellationRequest, triggerBRPayment, updateScheduleBooking };
+//#region src/createBookingRequest.d.ts
+type CreateBookingRequestBody = {
+  startDate: string;
+  endDate: string;
+  modelId: number;
+  profileId: string;
+  serviceId: string;
+  userId?: string;
+  vehicleId?: string;
+  station?: string;
+  latitude?: number;
+  longitude?: number;
+  radius?: number;
+  email?: string;
+  notes?: string;
+  plannedReturnDate?: string;
+  deliveryAddress?: string;
+  deliveryAddressAdditionalInfo?: string;
+  deliveryCity?: string;
+  deliveryPostalCode?: string;
+  dropOffStation?: string;
+  rollingContract?: boolean;
+  planDurationInMonths?: number;
+  planName?: string;
+  parentId?: string;
+  contractType?: 'SVS' | 'MVS';
+  productIds?: string[];
+  preallocatedVehicleId?: string;
+  bookingReferenceId?: string;
+  providedPricingId?: string;
+  preferredPaymentMethods?: {
+    pspReference: string;
+    amount: number;
+  }[];
+  requiresActionReturnURL?: string;
+  cityId?: string;
+};
+type CreateBookingRequestOptions = {
+  /** When false, bypass the user status check (operator use). Default true server-side. */userStatusCheckRequired?: boolean;
+};
+/**
+ * Create a new booking request.
+ *
+ * Swagger: `POST /scheduledBooking/fleets/{fleetId}/bookingrequests` (admin-booking).
+ */
+declare const createBookingRequest: (client: Client, body: CreateBookingRequestBody, options?: CreateBookingRequestOptions) => Promise<BookingRequest>;
+//#endregion
+//#region src/getAvailableModels.d.ts
+declare const getAvailableModelsSchema: z.ZodObject<{
+  startDate: z.ZodString;
+  endDate: z.ZodString;
+  cityId: z.ZodOptional<z.ZodString>;
+  userId: z.ZodOptional<z.ZodString>;
+  profileId: z.ZodOptional<z.ZodString>;
+  oneWayTrip: z.ZodOptional<z.ZodBoolean>;
+  showUnavailableModels: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type GetAvailableModelsParams = z.infer<typeof getAvailableModelsSchema>;
+/**
+ * Get available models grouped by station in a given time range.
+ *
+ * Swagger: `GET /scheduledBooking/fleets/{fleetId}/stations/models` (admin-booking / internal).
+ */
+declare const getAvailableModels: (client: Client, params: GetAvailableModelsParams) => Promise<StationWithAvailableModels[]>;
+//#endregion
+//#region src/getStationUnavailability.d.ts
+declare const getStationUnavailabilitySchema: z.ZodObject<{
+  stationId: z.ZodString;
+  from: z.ZodString;
+  to: z.ZodString;
+  serviceId: z.ZodString;
+}, z.core.$strip>;
+type GetStationUnavailabilityParams = z.infer<typeof getStationUnavailabilitySchema>;
+/**
+ * Get the list of vehicle unavailabilities for a given station over a period.
+ *
+ * Swagger: `GET /fleets/{fleetId}/stations/{stationId}/unavailability` (admin-booking,
+ * operationId `getVehicleCalendarForPeriod`).
+ */
+declare const getStationUnavailability: (client: Client, params: GetStationUnavailabilityParams) => Promise<StationVehicleCalendar>;
+//#endregion
+export { AdditionalDriver, AvailableModel, AvailableVehiclesResponse, BRPaymentItem, BaseBookingRequest, BookingCredit, BookingRequest, type BookingRequestFilters, BookingRequestSlave, type BookingRequestStatus, Contract, type CreateBookingRequestBody, type CreateBookingRequestOptions, type CreateSubscriptionBody, CustomPrice, DayOpeningHours, Days, EstimatedProduct, GeoInfo, type GetAvailableModelsParams, type GetStationUnavailabilityParams, IFormatSlave, IFormatSubscription, type Include, type IncludeStation, Master, MileageAllowance, OpeningHours, PaymentReceipts, PreferredPaymentMethod, PriceBreakdown, PricingInfo, SATBookingRequest, type SATBookingRequestStatus, Service, ServiceInfo, type ServiceType, Slave, Station, StationVehicleCalendar, StationWithAvailableModels, Timetable, TriggerBRPaymentResponse, Vehicle, VehicleUnavailability, allocateVehicle, cancelBookingRequest, createBookingRequest, createSubscription, deallocateVehicle, getAdditionalDrivers, getAvailableModels, getAvailableVehicles, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getBookingRequestsByUserId, getDigitalContracts, getSATBookingRequests, getScheduleBookingRequests, getScheduledBookingById, getSlaves, getStationById, getStationUnavailability, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests, getSubscriptionsByUserId, releaseBRPayment, submitCancellationRequest, triggerBRPayment, updateScheduleBooking };

package/dist/index.d.mts

@@ -317,6 +317,71 @@ type BookingRequestSlave = {
   traveledDistance: number;
   energyLevelEnd: number;
 };
+/** Mileage allowance for an available model (Swagger: `MileageAllowanceDTO`). */
+type MileageAllowance = {
+  allowancePerDay?: number;
+  totalAllowance?: number;
+  pricePerExceedingUnit?: number;
+};
+/** Estimated product embedded in a price breakdown (Swagger: `EstimatedProductDTO`). */
+type EstimatedProduct = {
+  productId?: string;
+  price?: number;
+};
+/** Price breakdown for an available model (Swagger: `PriceBreakdownDTO`). */
+type PriceBreakdown = {
+  tripPrice?: number;
+  productsPrice?: number;
+  productDetails?: EstimatedProduct[];
+};
+/** Pricing info for an available model (Swagger: `PricingInfo`). */
+type PricingInfo = {
+  pricingId?: string;
+  type?: string;
+  priceBreakdown?: PriceBreakdown;
+};
+/** Available model entry returned by `getAvailableModels` (Swagger: `BookingRequestModelDTO`). */
+type AvailableModel = {
+  id: number;
+  price?: string;
+  prePaymentPrice?: number;
+  mileageAllowance?: MileageAllowance;
+  pricingInfo?: PricingInfo;
+};
+/** Station entry returned by `getAvailableModels` (Swagger: `StationDTO`). */
+type StationWithAvailableModels = {
+  id: string;
+  zoneId: string;
+  poiId: string;
+  models: AvailableModel[];
+  taxZoneId?: string;
+  cityId?: string;
+  serviceId?: string;
+  fleetId?: string;
+  openTime?: string;
+  closeTime?: string;
+};
+/** Single unavailability entry in a station vehicle calendar (Swagger: `UnavailabilityDTO`). */
+type VehicleUnavailability = {
+  id?: string;
+  vehicleId?: string;
+  modelId?: number;
+  from?: string;
+  to?: string;
+  toWithMargin?: string;
+  type?: 'BOOKING' | 'MAINTENANCE';
+  userId?: string;
+  reason?: string;
+  serviceId?: string;
+};
+/** Vehicle calendar for a station over a period (Swagger: `VehicleCalendarResponseDTO`). */
+type StationVehicleCalendar = {
+  timezone?: string;
+  from?: string;
+  to?: string;
+  vehicleIds?: string[];
+  unavailabilities?: VehicleUnavailability[];
+};
 //#endregion
 //#region src/getBookingRequests.d.ts
 declare const BookingRequestStatusSchema: z.ZodEnum<{
@@ -490,4 +555,85 @@ type CreateSubscriptionBody = {
 };
 declare const createSubscription: (client: Client, body: CreateSubscriptionBody) => Promise<BookingRequest>;
 //#endregion
-export { AdditionalDriver, AvailableVehiclesResponse, BRPaymentItem, BaseBookingRequest, BookingCredit, BookingRequest, type BookingRequestFilters, BookingRequestSlave, type BookingRequestStatus, Contract, type CreateSubscriptionBody, CustomPrice, DayOpeningHours, Days, GeoInfo, IFormatSlave, IFormatSubscription, type Include, type IncludeStation, Master, OpeningHours, PaymentReceipts, PreferredPaymentMethod, SATBookingRequest, type SATBookingRequestStatus, Service, ServiceInfo, type ServiceType, Slave, Station, Timetable, TriggerBRPaymentResponse, Vehicle, allocateVehicle, cancelBookingRequest, createSubscription, deallocateVehicle, getAdditionalDrivers, getAvailableVehicles, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getBookingRequestsByUserId, getDigitalContracts, getSATBookingRequests, getScheduleBookingRequests, getScheduledBookingById, getSlaves, getStationById, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests, getSubscriptionsByUserId, releaseBRPayment, submitCancellationRequest, triggerBRPayment, updateScheduleBooking };
+//#region src/createBookingRequest.d.ts
+type CreateBookingRequestBody = {
+  startDate: string;
+  endDate: string;
+  modelId: number;
+  profileId: string;
+  serviceId: string;
+  userId?: string;
+  vehicleId?: string;
+  station?: string;
+  latitude?: number;
+  longitude?: number;
+  radius?: number;
+  email?: string;
+  notes?: string;
+  plannedReturnDate?: string;
+  deliveryAddress?: string;
+  deliveryAddressAdditionalInfo?: string;
+  deliveryCity?: string;
+  deliveryPostalCode?: string;
+  dropOffStation?: string;
+  rollingContract?: boolean;
+  planDurationInMonths?: number;
+  planName?: string;
+  parentId?: string;
+  contractType?: 'SVS' | 'MVS';
+  productIds?: string[];
+  preallocatedVehicleId?: string;
+  bookingReferenceId?: string;
+  providedPricingId?: string;
+  preferredPaymentMethods?: {
+    pspReference: string;
+    amount: number;
+  }[];
+  requiresActionReturnURL?: string;
+  cityId?: string;
+};
+type CreateBookingRequestOptions = {
+  /** When false, bypass the user status check (operator use). Default true server-side. */userStatusCheckRequired?: boolean;
+};
+/**
+ * Create a new booking request.
+ *
+ * Swagger: `POST /scheduledBooking/fleets/{fleetId}/bookingrequests` (admin-booking).
+ */
+declare const createBookingRequest: (client: Client, body: CreateBookingRequestBody, options?: CreateBookingRequestOptions) => Promise<BookingRequest>;
+//#endregion
+//#region src/getAvailableModels.d.ts
+declare const getAvailableModelsSchema: z.ZodObject<{
+  startDate: z.ZodString;
+  endDate: z.ZodString;
+  cityId: z.ZodOptional<z.ZodString>;
+  userId: z.ZodOptional<z.ZodString>;
+  profileId: z.ZodOptional<z.ZodString>;
+  oneWayTrip: z.ZodOptional<z.ZodBoolean>;
+  showUnavailableModels: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type GetAvailableModelsParams = z.infer<typeof getAvailableModelsSchema>;
+/**
+ * Get available models grouped by station in a given time range.
+ *
+ * Swagger: `GET /scheduledBooking/fleets/{fleetId}/stations/models` (admin-booking / internal).
+ */
+declare const getAvailableModels: (client: Client, params: GetAvailableModelsParams) => Promise<StationWithAvailableModels[]>;
+//#endregion
+//#region src/getStationUnavailability.d.ts
+declare const getStationUnavailabilitySchema: z.ZodObject<{
+  stationId: z.ZodString;
+  from: z.ZodString;
+  to: z.ZodString;
+  serviceId: z.ZodString;
+}, z.core.$strip>;
+type GetStationUnavailabilityParams = z.infer<typeof getStationUnavailabilitySchema>;
+/**
+ * Get the list of vehicle unavailabilities for a given station over a period.
+ *
+ * Swagger: `GET /fleets/{fleetId}/stations/{stationId}/unavailability` (admin-booking,
+ * operationId `getVehicleCalendarForPeriod`).
+ */
+declare const getStationUnavailability: (client: Client, params: GetStationUnavailabilityParams) => Promise<StationVehicleCalendar>;
+//#endregion
+export { AdditionalDriver, AvailableModel, AvailableVehiclesResponse, BRPaymentItem, BaseBookingRequest, BookingCredit, BookingRequest, type BookingRequestFilters, BookingRequestSlave, type BookingRequestStatus, Contract, type CreateBookingRequestBody, type CreateBookingRequestOptions, type CreateSubscriptionBody, CustomPrice, DayOpeningHours, Days, EstimatedProduct, GeoInfo, type GetAvailableModelsParams, type GetStationUnavailabilityParams, IFormatSlave, IFormatSubscription, type Include, type IncludeStation, Master, MileageAllowance, OpeningHours, PaymentReceipts, PreferredPaymentMethod, PriceBreakdown, PricingInfo, SATBookingRequest, type SATBookingRequestStatus, Service, ServiceInfo, type ServiceType, Slave, Station, StationVehicleCalendar, StationWithAvailableModels, Timetable, TriggerBRPaymentResponse, Vehicle, VehicleUnavailability, allocateVehicle, cancelBookingRequest, createBookingRequest, createSubscription, deallocateVehicle, getAdditionalDrivers, getAvailableModels, getAvailableVehicles, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getBookingRequestsByUserId, getDigitalContracts, getSATBookingRequests, getScheduleBookingRequests, getScheduledBookingById, getSlaves, getStationById, getStationUnavailability, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests, getSubscriptionsByUserId, releaseBRPayment, submitCancellationRequest, triggerBRPayment, updateScheduleBooking };

package/dist/index.mjs

@@ -156,10 +156,10 @@ const getScheduledBookingById = async (client, bookingId) => {
 //#endregion
 //#region src/getAvailableVehicles.ts
 /** ISO date-time without milliseconds (e.g. 2025-02-10T12:00:00Z or 2025-02-10T12:00:00+01:00). */
-const isoDateTimeNoMs = z.string().trim().datetime({ precision: 0 });
+const isoDateTimeNoMs$2 = z.string().trim().datetime({ precision: 0 });
 const getAvailableVehiclesSchema = z.object({
 	stationId: z.string().trim().min(1),
-	startDate: isoDateTimeNoMs
+	startDate: isoDateTimeNoMs$2
 });
 const getAvailableVehicles = async (client, stationId, startDate) => {
 	const result = getAvailableVehiclesSchema.safeParse({
@@ -525,4 +525,108 @@ const createSubscription = async (client, body) => {
 	return client.post(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/subscription/bookingrequests`, result.data).then(({ data }) => data);
 };
 //#endregion
-export { allocateVehicle, cancelBookingRequest, createSubscription, deallocateVehicle, getAdditionalDrivers, getAvailableVehicles, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getBookingRequestsByUserId, getDigitalContracts, getSATBookingRequests, getScheduleBookingRequests, getScheduledBookingById, getSlaves, getStationById, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests, getSubscriptionsByUserId, releaseBRPayment, submitCancellationRequest, triggerBRPayment, updateScheduleBooking };
+//#region src/createBookingRequest.ts
+const createBookingRequestBodySchema = z.object({
+	startDate: z.string().trim().min(1),
+	endDate: z.string().trim().min(1),
+	modelId: z.number().int().positive(),
+	profileId: z.string().trim().min(1).uuid(),
+	serviceId: z.string().trim().min(1).uuid(),
+	userId: z.string().uuid().optional(),
+	vehicleId: z.string().uuid().optional(),
+	station: z.string().optional(),
+	latitude: z.number().optional(),
+	longitude: z.number().optional(),
+	radius: z.number().int().optional(),
+	email: z.string().email().optional(),
+	notes: z.string().optional(),
+	plannedReturnDate: z.string().optional(),
+	deliveryAddress: z.string().optional(),
+	deliveryAddressAdditionalInfo: z.string().optional(),
+	deliveryCity: z.string().optional(),
+	deliveryPostalCode: z.string().optional(),
+	dropOffStation: z.string().optional(),
+	rollingContract: z.boolean().optional(),
+	planDurationInMonths: z.number().int().optional(),
+	planName: z.string().optional(),
+	parentId: z.string().optional(),
+	contractType: z.enum(["SVS", "MVS"]).optional(),
+	productIds: z.array(z.string()).optional(),
+	preallocatedVehicleId: z.string().optional(),
+	bookingReferenceId: z.string().optional(),
+	providedPricingId: z.string().uuid().optional(),
+	preferredPaymentMethods: z.array(z.object({
+		pspReference: z.string(),
+		amount: z.number()
+	})).optional(),
+	requiresActionReturnURL: z.string().optional(),
+	cityId: z.string().optional()
+});
+/**
+* Create a new booking request.
+*
+* Swagger: `POST /scheduledBooking/fleets/{fleetId}/bookingrequests` (admin-booking).
+*/
+const createBookingRequest = async (client, body, options = {}) => {
+	const result = createBookingRequestBodySchema.safeParse(body);
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	const query = options.userStatusCheckRequired !== void 0 ? `?userStatusCheckRequired=${options.userStatusCheckRequired}` : "";
+	return client.post(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests${query}`, {
+		...result.data,
+		fleetId: client.clientOptions.fleetId
+	}).then(({ data }) => data);
+};
+//#endregion
+//#region src/getAvailableModels.ts
+/** ISO date-time without milliseconds (e.g. 2020-09-20T00:00:00Z or 2020-09-20T00:00:00+01:00). */
+const isoDateTimeNoMs$1 = z.string().trim().datetime({ precision: 0 });
+const getAvailableModelsSchema = z.object({
+	startDate: isoDateTimeNoMs$1,
+	endDate: isoDateTimeNoMs$1,
+	cityId: z.string().trim().min(1).optional(),
+	userId: z.string().uuid().optional(),
+	profileId: z.string().uuid().optional(),
+	oneWayTrip: z.boolean().optional(),
+	showUnavailableModels: z.boolean().optional()
+});
+/**
+* Get available models grouped by station in a given time range.
+*
+* Swagger: `GET /scheduledBooking/fleets/{fleetId}/stations/models` (admin-booking / internal).
+*/
+const getAvailableModels = async (client, params) => {
+	const result = getAvailableModelsSchema.safeParse(params);
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	const searchParams = new URLSearchParams();
+	for (const [key, value] of Object.entries(result.data)) if (value !== void 0) searchParams.append(key, String(value));
+	return client.get(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/stations/models?${searchParams.toString()}`).then(({ data }) => data);
+};
+//#endregion
+//#region src/getStationUnavailability.ts
+/** ISO date-time without milliseconds (e.g. 2021-01-01T00:00:00Z). */
+const isoDateTimeNoMs = z.string().trim().datetime({ precision: 0 });
+const getStationUnavailabilitySchema = z.object({
+	stationId: z.string().uuid(),
+	from: isoDateTimeNoMs,
+	to: isoDateTimeNoMs,
+	serviceId: z.string().uuid()
+});
+/**
+* Get the list of vehicle unavailabilities for a given station over a period.
+*
+* Swagger: `GET /fleets/{fleetId}/stations/{stationId}/unavailability` (admin-booking,
+* operationId `getVehicleCalendarForPeriod`).
+*/
+const getStationUnavailability = async (client, params) => {
+	const result = getStationUnavailabilitySchema.safeParse(params);
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	const { stationId, from, to, serviceId } = result.data;
+	const searchParams = new URLSearchParams({
+		from,
+		to,
+		serviceId
+	});
+	return client.get(`/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/stations/${stationId}/unavailability?${searchParams.toString()}`).then(({ data }) => data);
+};
+//#endregion
+export { allocateVehicle, cancelBookingRequest, createBookingRequest, createSubscription, deallocateVehicle, getAdditionalDrivers, getAvailableModels, getAvailableVehicles, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getBookingRequestsByUserId, getDigitalContracts, getSATBookingRequests, getScheduleBookingRequests, getScheduledBookingById, getSlaves, getStationById, getStationUnavailability, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests, getSubscriptionsByUserId, releaseBRPayment, submitCancellationRequest, triggerBRPayment, updateScheduleBooking };

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@vulog/aima-booking",
     "type": "module",
-    "version": "1.2.42",
+    "version": "1.2.43",
     "main": "dist/index.cjs",
     "module": "dist/index.mjs",
     "types": "dist/index.d.cts",
@@ -32,8 +32,8 @@
     "author": "Vulog",
     "license": "MIT",
     "dependencies": {
-        "@vulog/aima-client": "1.2.42",
-        "@vulog/aima-core": "1.2.42"
+        "@vulog/aima-client": "1.2.43",
+        "@vulog/aima-core": "1.2.43"
     },
     "peerDependencies": {
         "es-toolkit": "^1.45.1",

package/src/createBookingRequest.test.ts

@@ -0,0 +1,73 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+
+import { Client } from '@vulog/aima-client';
+
+import { createBookingRequest, CreateBookingRequestBody } from './createBookingRequest';
+
+describe('createBookingRequest', () => {
+    const postMock = vi.fn();
+    const client = {
+        post: postMock,
+        clientOptions: {
+            fleetId: 'VULOG-FRPAR',
+        },
+    } as unknown as Client;
+
+    const validBody: CreateBookingRequestBody = {
+        startDate: '2026-06-01T10:00:00Z',
+        endDate: '2026-06-05T10:00:00Z',
+        modelId: 141411,
+        profileId: '9f0fd479-28a9-4754-9c77-611ea48bfb8f',
+        serviceId: '9ed7d9d4-8c64-43ef-bb3d-e2b271fed682',
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should throw on invalid args (missing required fields)', async () => {
+        const badBody = { startDate: '2026-06-01T10:00:00Z' } as unknown as CreateBookingRequestBody;
+        await expect(createBookingRequest(client, badBody)).rejects.toThrow('Invalid args');
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw on invalid UUID profileId', async () => {
+        await expect(
+            createBookingRequest(client, { ...validBody, profileId: 'not-a-uuid' })
+        ).rejects.toThrow('Invalid args');
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('should post body with fleetId injected and return booking request', async () => {
+        const responseBody = {
+            id: '0b528336-2624-42ae-8640-59fb663e17f4',
+            fleetId: 'VULOG-FRPAR',
+            status: 'PENDING',
+        };
+        postMock.mockResolvedValueOnce({ data: responseBody });
+
+        const result = await createBookingRequest(client, validBody);
+
+        expect(postMock).toHaveBeenCalledWith(
+            '/boapi/proxy/user/scheduledBooking/fleets/VULOG-FRPAR/bookingrequests',
+            { ...validBody, fleetId: 'VULOG-FRPAR' }
+        );
+        expect(result).toEqual(responseBody);
+    });
+
+    test('should append userStatusCheckRequired query param when provided', async () => {
+        postMock.mockResolvedValueOnce({ data: {} });
+
+        await createBookingRequest(client, validBody, { userStatusCheckRequired: false });
+
+        expect(postMock).toHaveBeenCalledWith(
+            '/boapi/proxy/user/scheduledBooking/fleets/VULOG-FRPAR/bookingrequests?userStatusCheckRequired=false',
+            { ...validBody, fleetId: 'VULOG-FRPAR' }
+        );
+    });
+
+    test('should propagate client errors', async () => {
+        postMock.mockRejectedValueOnce(new Error('network down'));
+        await expect(createBookingRequest(client, validBody)).rejects.toThrow('network down');
+    });
+});

package/src/createBookingRequest.ts

@@ -0,0 +1,116 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { BookingRequest } from './types';
+
+export type CreateBookingRequestBody = {
+    // Required fields (per Swagger BookingRequestDTO)
+    startDate: string;
+    endDate: string;
+    modelId: number;
+    profileId: string;
+    serviceId: string;
+
+    // Optional fields
+    userId?: string;
+    vehicleId?: string;
+    station?: string;
+    latitude?: number;
+    longitude?: number;
+    radius?: number;
+    email?: string;
+    notes?: string;
+    plannedReturnDate?: string;
+    deliveryAddress?: string;
+    deliveryAddressAdditionalInfo?: string;
+    deliveryCity?: string;
+    deliveryPostalCode?: string;
+    dropOffStation?: string;
+    rollingContract?: boolean;
+    planDurationInMonths?: number;
+    planName?: string;
+    parentId?: string;
+    contractType?: 'SVS' | 'MVS';
+    productIds?: string[];
+    preallocatedVehicleId?: string;
+    bookingReferenceId?: string;
+    providedPricingId?: string;
+    preferredPaymentMethods?: { pspReference: string; amount: number }[];
+    requiresActionReturnURL?: string;
+    cityId?: string;
+};
+
+export type CreateBookingRequestOptions = {
+    /** When false, bypass the user status check (operator use). Default true server-side. */
+    userStatusCheckRequired?: boolean;
+};
+
+const createBookingRequestBodySchema = z.object({
+    startDate: z.string().trim().min(1),
+    endDate: z.string().trim().min(1),
+    modelId: z.number().int().positive(),
+    profileId: z.string().trim().min(1).uuid(),
+    serviceId: z.string().trim().min(1).uuid(),
+
+    userId: z.string().uuid().optional(),
+    vehicleId: z.string().uuid().optional(),
+    station: z.string().optional(),
+    latitude: z.number().optional(),
+    longitude: z.number().optional(),
+    radius: z.number().int().optional(),
+    email: z.string().email().optional(),
+    notes: z.string().optional(),
+    plannedReturnDate: z.string().optional(),
+    deliveryAddress: z.string().optional(),
+    deliveryAddressAdditionalInfo: z.string().optional(),
+    deliveryCity: z.string().optional(),
+    deliveryPostalCode: z.string().optional(),
+    dropOffStation: z.string().optional(),
+    rollingContract: z.boolean().optional(),
+    planDurationInMonths: z.number().int().optional(),
+    planName: z.string().optional(),
+    parentId: z.string().optional(),
+    contractType: z.enum(['SVS', 'MVS']).optional(),
+    productIds: z.array(z.string()).optional(),
+    preallocatedVehicleId: z.string().optional(),
+    bookingReferenceId: z.string().optional(),
+    providedPricingId: z.string().uuid().optional(),
+    preferredPaymentMethods: z
+        .array(
+            z.object({
+                pspReference: z.string(),
+                amount: z.number(),
+            })
+        )
+        .optional(),
+    requiresActionReturnURL: z.string().optional(),
+    cityId: z.string().optional(),
+});
+
+/**
+ * Create a new booking request.
+ *
+ * Swagger: `POST /scheduledBooking/fleets/{fleetId}/bookingrequests` (admin-booking).
+ */
+export const createBookingRequest = async (
+    client: Client,
+    body: CreateBookingRequestBody,
+    options: CreateBookingRequestOptions = {}
+): Promise<BookingRequest> => {
+    const result = createBookingRequestBodySchema.safeParse(body);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    const query =
+        options.userStatusCheckRequired !== undefined
+            ? `?userStatusCheckRequired=${options.userStatusCheckRequired}`
+            : '';
+
+    return client
+        .post<BookingRequest>(
+            `/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests${query}`,
+            { ...result.data, fleetId: client.clientOptions.fleetId }
+        )
+        .then(({ data }) => data);
+};

package/src/getAvailableModels.test.ts

@@ -0,0 +1,88 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+
+import { Client } from '@vulog/aima-client';
+
+import { getAvailableModels } from './getAvailableModels';
+import { StationWithAvailableModels } from './types';
+
+describe('getAvailableModels', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'VULOG-FRPAR',
+        },
+    } as unknown as Client;
+
+    const validParams = {
+        startDate: '2026-06-01T00:00:00Z',
+        endDate: '2026-06-05T00:00:00Z',
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should throw on missing required dates', async () => {
+        await expect(
+            getAvailableModels(client, { startDate: '2026-06-01T00:00:00Z' } as never)
+        ).rejects.toThrow('Invalid args');
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw on invalid ISO datetime', async () => {
+        await expect(
+            getAvailableModels(client, { startDate: 'not-a-date', endDate: validParams.endDate })
+        ).rejects.toThrow('Invalid args');
+    });
+
+    test('should throw on invalid userId UUID', async () => {
+        await expect(
+            getAvailableModels(client, { ...validParams, userId: 'not-a-uuid' })
+        ).rejects.toThrow('Invalid args');
+    });
+
+    test('should call endpoint with required query params and return stations', async () => {
+        const mockResponse: StationWithAvailableModels[] = [
+            {
+                id: 'd63bd962-e846-11ea-adc1-0242ac120002',
+                zoneId: 'f99e9a545059439c99eb81a8a8a88f93',
+                poiId: 'd2760ed840654f25b2beeb0fc52b6cf7',
+                models: [{ id: 141411, price: '120.00', prePaymentPrice: 30 }],
+            },
+        ];
+        getMock.mockResolvedValueOnce({ data: mockResponse });
+
+        const result = await getAvailableModels(client, validParams);
+
+        expect(getMock).toHaveBeenCalledWith(
+            '/boapi/proxy/user/scheduledBooking/fleets/VULOG-FRPAR/stations/models?startDate=2026-06-01T00%3A00%3A00Z&endDate=2026-06-05T00%3A00%3A00Z'
+        );
+        expect(result).toEqual(mockResponse);
+    });
+
+    test('should include all optional query params when provided', async () => {
+        getMock.mockResolvedValueOnce({ data: [] });
+
+        await getAvailableModels(client, {
+            ...validParams,
+            cityId: 'PARIS',
+            userId: '9f0fd479-28a9-4754-9c77-611ea48bfb8f',
+            profileId: '245cb038-0bcd-415f-a3ce-d0a5b2fdb730',
+            oneWayTrip: true,
+            showUnavailableModels: false,
+        });
+
+        const url = getMock.mock.calls[0][0] as string;
+        expect(url).toContain('cityId=PARIS');
+        expect(url).toContain('userId=9f0fd479-28a9-4754-9c77-611ea48bfb8f');
+        expect(url).toContain('profileId=245cb038-0bcd-415f-a3ce-d0a5b2fdb730');
+        expect(url).toContain('oneWayTrip=true');
+        expect(url).toContain('showUnavailableModels=false');
+    });
+
+    test('should propagate client errors', async () => {
+        getMock.mockRejectedValueOnce(new Error('network down'));
+        await expect(getAvailableModels(client, validParams)).rejects.toThrow('network down');
+    });
+});

package/src/getAvailableModels.ts

@@ -0,0 +1,47 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { StationWithAvailableModels } from './types';
+
+/** ISO date-time without milliseconds (e.g. 2020-09-20T00:00:00Z or 2020-09-20T00:00:00+01:00). */
+const isoDateTimeNoMs = z.string().trim().datetime({ precision: 0 });
+
+const getAvailableModelsSchema = z.object({
+    startDate: isoDateTimeNoMs,
+    endDate: isoDateTimeNoMs,
+    cityId: z.string().trim().min(1).optional(),
+    userId: z.string().uuid().optional(),
+    profileId: z.string().uuid().optional(),
+    oneWayTrip: z.boolean().optional(),
+    showUnavailableModels: z.boolean().optional(),
+});
+
+export type GetAvailableModelsParams = z.infer<typeof getAvailableModelsSchema>;
+
+/**
+ * Get available models grouped by station in a given time range.
+ *
+ * Swagger: `GET /scheduledBooking/fleets/{fleetId}/stations/models` (admin-booking / internal).
+ */
+export const getAvailableModels = async (
+    client: Client,
+    params: GetAvailableModelsParams
+): Promise<StationWithAvailableModels[]> => {
+    const result = getAvailableModelsSchema.safeParse(params);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(result.data)) {
+        if (value !== undefined) {
+            searchParams.append(key, String(value));
+        }
+    }
+
+    return client
+        .get<
+            StationWithAvailableModels[]
+        >(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/stations/models?${searchParams.toString()}`)
+        .then(({ data }) => data);
+};

package/src/getStationUnavailability.test.ts

@@ -0,0 +1,79 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+
+import { Client } from '@vulog/aima-client';
+
+import { getStationUnavailability } from './getStationUnavailability';
+import { StationVehicleCalendar } from './types';
+
+describe('getStationUnavailability', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'VULOG-FRPAR',
+        },
+    } as unknown as Client;
+
+    const validParams = {
+        stationId: '57e64770-72c8-4256-b3f2-931242fa7d61',
+        from: '2026-01-01T00:00:00Z',
+        to: '2026-02-01T00:00:00Z',
+        serviceId: '14946b6e-caac-4608-ab92-6068cc7363cf',
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should throw on invalid stationId UUID', async () => {
+        await expect(
+            getStationUnavailability(client, { ...validParams, stationId: 'not-a-uuid' })
+        ).rejects.toThrow('Invalid args');
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw on invalid serviceId UUID', async () => {
+        await expect(
+            getStationUnavailability(client, { ...validParams, serviceId: 'not-a-uuid' })
+        ).rejects.toThrow('Invalid args');
+    });
+
+    test('should throw on invalid ISO date', async () => {
+        await expect(
+            getStationUnavailability(client, { ...validParams, from: 'not-a-date' })
+        ).rejects.toThrow('Invalid args');
+    });
+
+    test('should call endpoint with required query params and return calendar', async () => {
+        const mockResponse: StationVehicleCalendar = {
+            timezone: 'Europe/Paris',
+            from: validParams.from,
+            to: validParams.to,
+            vehicleIds: ['veh-1', 'veh-2'],
+            unavailabilities: [
+                {
+                    id: 'u-1',
+                    vehicleId: 'veh-1',
+                    modelId: 141411,
+                    from: '2026-01-10T08:00:00Z',
+                    to: '2026-01-12T18:00:00Z',
+                    type: 'BOOKING',
+                    serviceId: validParams.serviceId,
+                },
+            ],
+        };
+        getMock.mockResolvedValueOnce({ data: mockResponse });
+
+        const result = await getStationUnavailability(client, validParams);
+
+        expect(getMock).toHaveBeenCalledWith(
+            `/boapi/proxy/user/fleets/VULOG-FRPAR/stations/${validParams.stationId}/unavailability?from=2026-01-01T00%3A00%3A00Z&to=2026-02-01T00%3A00%3A00Z&serviceId=${validParams.serviceId}`
+        );
+        expect(result).toEqual(mockResponse);
+    });
+
+    test('should propagate client errors', async () => {
+        getMock.mockRejectedValueOnce(new Error('network down'));
+        await expect(getStationUnavailability(client, validParams)).rejects.toThrow('network down');
+    });
+});

package/src/getStationUnavailability.ts

@@ -0,0 +1,41 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { StationVehicleCalendar } from './types';
+
+/** ISO date-time without milliseconds (e.g. 2021-01-01T00:00:00Z). */
+const isoDateTimeNoMs = z.string().trim().datetime({ precision: 0 });
+
+const getStationUnavailabilitySchema = z.object({
+    stationId: z.string().uuid(),
+    from: isoDateTimeNoMs,
+    to: isoDateTimeNoMs,
+    serviceId: z.string().uuid(),
+});
+
+export type GetStationUnavailabilityParams = z.infer<typeof getStationUnavailabilitySchema>;
+
+/**
+ * Get the list of vehicle unavailabilities for a given station over a period.
+ *
+ * Swagger: `GET /fleets/{fleetId}/stations/{stationId}/unavailability` (admin-booking,
+ * operationId `getVehicleCalendarForPeriod`).
+ */
+export const getStationUnavailability = async (
+    client: Client,
+    params: GetStationUnavailabilityParams
+): Promise<StationVehicleCalendar> => {
+    const result = getStationUnavailabilitySchema.safeParse(params);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    const { stationId, from, to, serviceId } = result.data;
+    const searchParams = new URLSearchParams({ from, to, serviceId });
+
+    return client
+        .get<StationVehicleCalendar>(
+            `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/stations/${stationId}/unavailability?${searchParams.toString()}`
+        )
+        .then(({ data }) => data);
+};

package/src/index.ts

@@ -28,3 +28,9 @@ export { getSubscriptionsByUserId } from './getSubscriptionsByUserId';
 export { submitCancellationRequest } from './submitCancellationRequest';
 export { createSubscription } from './createSubscription';
 export type { CreateSubscriptionBody } from './createSubscription';
+export { createBookingRequest } from './createBookingRequest';
+export type { CreateBookingRequestBody, CreateBookingRequestOptions } from './createBookingRequest';
+export { getAvailableModels } from './getAvailableModels';
+export type { GetAvailableModelsParams } from './getAvailableModels';
+export { getStationUnavailability } from './getStationUnavailability';
+export type { GetStationUnavailabilityParams } from './getStationUnavailability';

package/src/types.ts

@@ -342,3 +342,76 @@ export type BookingRequestSlave = {
     traveledDistance: number;
     energyLevelEnd: number;
 };
+
+/** Mileage allowance for an available model (Swagger: `MileageAllowanceDTO`). */
+export type MileageAllowance = {
+    allowancePerDay?: number;
+    totalAllowance?: number;
+    pricePerExceedingUnit?: number;
+};
+
+/** Estimated product embedded in a price breakdown (Swagger: `EstimatedProductDTO`). */
+export type EstimatedProduct = {
+    productId?: string;
+    price?: number;
+};
+
+/** Price breakdown for an available model (Swagger: `PriceBreakdownDTO`). */
+export type PriceBreakdown = {
+    tripPrice?: number;
+    productsPrice?: number;
+    productDetails?: EstimatedProduct[];
+};
+
+/** Pricing info for an available model (Swagger: `PricingInfo`). */
+export type PricingInfo = {
+    pricingId?: string;
+    type?: string;
+    priceBreakdown?: PriceBreakdown;
+};
+
+/** Available model entry returned by `getAvailableModels` (Swagger: `BookingRequestModelDTO`). */
+export type AvailableModel = {
+    id: number;
+    price?: string;
+    prePaymentPrice?: number;
+    mileageAllowance?: MileageAllowance;
+    pricingInfo?: PricingInfo;
+};
+
+/** Station entry returned by `getAvailableModels` (Swagger: `StationDTO`). */
+export type StationWithAvailableModels = {
+    id: string;
+    zoneId: string;
+    poiId: string;
+    models: AvailableModel[];
+    taxZoneId?: string;
+    cityId?: string;
+    serviceId?: string;
+    fleetId?: string;
+    openTime?: string;
+    closeTime?: string;
+};
+
+/** Single unavailability entry in a station vehicle calendar (Swagger: `UnavailabilityDTO`). */
+export type VehicleUnavailability = {
+    id?: string;
+    vehicleId?: string;
+    modelId?: number;
+    from?: string;
+    to?: string;
+    toWithMargin?: string;
+    type?: 'BOOKING' | 'MAINTENANCE';
+    userId?: string;
+    reason?: string;
+    serviceId?: string;
+};
+
+/** Vehicle calendar for a station over a period (Swagger: `VehicleCalendarResponseDTO`). */
+export type StationVehicleCalendar = {
+    timezone?: string;
+    from?: string;
+    to?: string;
+    vehicleIds?: string[];
+    unavailabilities?: VehicleUnavailability[];
+};