@driveflux/api-functions 1.0.62 → 1.0.63

package/dist/reservation/ensure-user-billing-address.js

@@ -3,27 +3,29 @@ import { makeProblem, PROBLEM_INTERNAL } from '@driveflux/problem';
 import { Err, Ok } from '@driveflux/result';
 import { createScopedLogger } from '../create-logger.js';
 const log = createScopedLogger('reservation:ensure-user-billing-address');
-export const ensureUserBillingAddress = async (userOrBusiness, deliveryAddresses)=>{
+export const ensureUserBillingAddress = async (userOrBusiness, deliveryAddresses) => {
     if (userOrBusiness.addresses?.billing) {
         return new Ok(userOrBusiness);
     }
     try {
         const fullQuery = {
-            where: {
-                id: userOrBusiness.id
-            },
+            where: { id: userOrBusiness.id },
             data: {
                 addresses: {
                     home: deliveryAddresses.home,
-                    billing: deliveryAddresses.billing
-                }
-            }
+                    billing: deliveryAddresses.billing,
+                },
+            },
         };
         // Use the delivery addresses
-        const updatedUserOrBusiness = userOrBusiness.object === 'user' ? await prisma.user.update(fullQuery) : await prisma.business.update(fullQuery);
+        const updatedUserOrBusiness = userOrBusiness.object === 'user'
+            ? await prisma.user.update(fullQuery)
+            : await prisma.business.update(fullQuery);
         return new Ok(updatedUserOrBusiness);
-    } catch (error) {
+    }
+    catch (error) {
         log.error(error, 'Failed to ensure user billing address');
         return new Err(makeProblem(PROBLEM_INTERNAL, 'Failed to ensure user billing address'));
     }
 };
+//# sourceMappingURL=ensure-user-billing-address.js.map

package/dist/reservation/fetch-or-create.js

@@ -1,11 +1,11 @@
-import { prisma } from '@driveflux/db';
+import { prisma, } from '@driveflux/db';
 import { generateId } from '@driveflux/db/id';
 import { reportError } from '@driveflux/reporter';
 import { Ok } from '@driveflux/result';
 import { slackLater } from '../slack.js';
-import { createReservationInvoice, updateReservationInvoiceIfNeeded } from './invoice.js';
-export const fetchOrCreateReservation = async ({ vehicle, payer, body })=>{
-    const { subscribingUser, plan, mileagePackage, couponCode, referralCode, asBusiness, source, deliveryAddresses, deliveryDate, analytics, paymentIntentId, freeReservation, freeReservationReason } = body;
+import { createReservationInvoice, updateReservationInvoiceIfNeeded, } from './invoice.js';
+export const fetchOrCreateReservation = async ({ vehicle, payer, body, }) => {
+    const { subscribingUser, plan, mileagePackage, couponCode, referralCode, asBusiness, source, deliveryAddresses, deliveryDate, analytics, paymentIntentId, freeReservation, freeReservationReason, } = body;
     try {
         const previousReservation = await prisma.subscriptionReservation.findFirst({
             where: {
@@ -19,14 +19,14 @@ export const fetchOrCreateReservation = async ({ vehicle, payer, body })=>{
                 source,
                 // If the subscription ID was populated, this means that this reservation was consumed into a subsription,
                 // so we shouldn't re-use it
-                subscription: null
+                subscription: null,
             },
             orderBy: {
-                updatedAt: 'desc'
+                updatedAt: 'desc',
             },
             include: {
-                invoice: true
-            }
+                invoice: true,
+            },
         });
         if (previousReservation) {
             if (previousReservation.invoice.voided) {
@@ -39,7 +39,7 @@ export const fetchOrCreateReservation = async ({ vehicle, payer, body })=>{
                 'partiallyPaid',
                 'partiallyRefunded',
                 'refunded',
-                'pendingRefund'
+                'pendingRefund',
             ];
             if (wrongStatuses.includes(previousReservation.invoice.status)) {
                 const updatedReservation = await recreateReservationInvoiceAndUpdateReservation(previousReservation, body, vehicle, payer);
@@ -52,16 +52,16 @@ export const fetchOrCreateReservation = async ({ vehicle, payer, body })=>{
                         text: {
                             type: 'plain_text',
                             text: '‼️ Reservation invoice in wrong status',
-                            emoji: true
-                        }
+                            emoji: true,
+                        },
                     },
                     {
                         type: 'section',
                         text: {
                             type: 'plain_text',
-                            text: `The reservation invoice ${previousReservation.invoice.id} was in a wrong status (${previousReservation.invoice.status}), it was discarded and a new invoice (${updatedReservation.val.id}) was created, however, investigate the issue.`
-                        }
-                    }
+                            text: `The reservation invoice ${previousReservation.invoice.id} was in a wrong status (${previousReservation.invoice.status}), it was discarded and a new invoice (${updatedReservation.val.id}) was created, however, investigate the issue.`,
+                        },
+                    },
                 ]);
                 return updatedReservation;
             }
@@ -73,7 +73,8 @@ export const fetchOrCreateReservation = async ({ vehicle, payer, body })=>{
             // Otherwise, we need to create a new reservation
             return new Ok(previousReservation);
         }
-    } catch (error) {
+    }
+    catch (error) {
         // We couldn't fetch the reservation, so we create a new one and just log this
         await reportError(error);
     }
@@ -92,7 +93,7 @@ export const fetchOrCreateReservation = async ({ vehicle, payer, body })=>{
         analytics,
         vehicle,
         payer,
-        subscribingUser
+        subscribingUser,
     });
     if (invoiceResult.err) {
         return invoiceResult;
@@ -111,66 +112,70 @@ export const fetchOrCreateReservation = async ({ vehicle, payer, body })=>{
         deliveryAddresses,
         deliveryDate,
         asBusiness,
-        source
+        source,
     });
     return new Ok(reservation);
 };
-const createReservation = async ({ reservationId, invoiceId, subscribingUserId, vehicleId, businessId, plan, mileagePackage, couponCode, referralCode, analytics, deliveryAddresses, deliveryDate, asBusiness, source })=>{
+const createReservation = async ({ reservationId, invoiceId, subscribingUserId, vehicleId, businessId, plan, mileagePackage, couponCode, referralCode, analytics, deliveryAddresses, deliveryDate, asBusiness, source, }) => {
     return await prisma.subscriptionReservation.create({
         data: {
             id: reservationId,
             invoice: {
                 connect: {
-                    id: invoiceId
-                }
+                    id: invoiceId,
+                },
             },
             user: {
                 connect: {
-                    id: subscribingUserId
-                }
+                    id: subscribingUserId,
+                },
             },
             vehicle: {
                 connect: {
-                    id: vehicleId
-                }
+                    id: vehicleId,
+                },
             },
-            ...businessId ? {
-                business: {
-                    connect: {
-                        id: businessId
-                    }
+            ...(businessId
+                ? {
+                    business: {
+                        connect: {
+                            id: businessId,
+                        },
+                    },
                 }
-            } : undefined,
+                : undefined),
             plan,
             mileagePackage,
             couponCode: couponCode,
             deliveryAddresses: deliveryAddresses,
             deliveryDate: deliveryDate,
-            ...referralCode ? {
-                referral: {
-                    connect: {
-                        id: referralCode
-                    }
+            ...(referralCode
+                ? {
+                    referral: {
+                        connect: {
+                            id: referralCode,
+                        },
+                    },
                 }
-            } : undefined,
+                : undefined),
             asBusiness: !!asBusiness,
             source,
             metadata: {
-                analytics
-            }
+                analytics,
+            },
         },
         include: {
-            invoice: true
-        }
+            invoice: true,
+        },
     });
 };
-const recreateReservationInvoiceAndUpdateReservation = async (previousReservation, body, vehicle, payer)=>{
+const recreateReservationInvoiceAndUpdateReservation = async (previousReservation, body, vehicle, payer) => {
     const invoiceResult = await createReservationInvoice({
         ...body,
         invoiceId: generateId('Invoice'),
         reservationId: previousReservation.id,
         vehicle,
-        payer
+        payer,
     });
     if (!invoiceResult.ok) {
         return invoiceResult;
@@ -178,18 +183,19 @@ const recreateReservationInvoiceAndUpdateReservation = async (previousReservatio
     const invoice = invoiceResult.val;
     const updatedReservation = await prisma.subscriptionReservation.update({
         where: {
-            id: previousReservation.id
+            id: previousReservation.id,
         },
         data: {
             invoice: {
                 connect: {
-                    id: invoice.id
-                }
-            }
+                    id: invoice.id,
+                },
+            },
         },
         include: {
-            invoice: true
-        }
+            invoice: true,
+        },
     });
     return new Ok(updatedReservation);
 };
+//# sourceMappingURL=fetch-or-create.js.map

package/dist/reservation/invoice.js

@@ -1,6 +1,6 @@
 import { config } from '@driveflux/config/backend';
 import { loadCoupon, PROBLEM_APPLICABLE_NOT_FOUND } from '@driveflux/coupon';
-import { prisma } from '@driveflux/db';
+import { prisma, } from '@driveflux/db';
 import { generateId } from '@driveflux/db/id';
 import { EMPTY_BILLING_ADDRESS } from '@driveflux/db/models/other';
 import { PURPOSE_RESERVATION } from '@driveflux/db/models/subscription';
@@ -14,15 +14,16 @@ import { isAfter } from 'date-fns/isAfter';
 import { subMinutes } from 'date-fns/subMinutes';
 import { createScopedLogger } from '../create-logger.js';
 const log = createScopedLogger('reservation:invoice');
-export const updateReservationInvoiceIfNeeded = async (oldReservationInvoice, newParams)=>{
+export const updateReservationInvoiceIfNeeded = async (oldReservationInvoice, newParams) => {
     const couponIsDifferent = oldReservationInvoice.couponCode !== newParams.couponCode;
-    if (!couponIsDifferent && oldReservationInvoice.stripePaymentIntentId === newParams.paymentIntentId) {
+    if (!couponIsDifferent &&
+        oldReservationInvoice.stripePaymentIntentId === newParams.paymentIntentId) {
         return new Ok(oldReservationInvoice);
     }
     // If the coupon or payment intent are differnt we should update the invoice
     let update = {
         stripePaymentIntentId: newParams.paymentIntentId,
-        couponCode: newParams.couponCode
+        couponCode: newParams.couponCode,
     };
     // If the coupon is different, we need to apply the coupon to the invoice
     if (couponIsDifferent) {
@@ -30,56 +31,63 @@ export const updateReservationInvoiceIfNeeded = async (oldReservationInvoice, ne
             const result = await coupons.applyCouponToUnsavedInvoice(newParams.couponCode, oldReservationInvoice);
             if (result.ok) {
                 const { discounts, ...rest } = result.val;
-                const toDisconnect = discounts ? oldReservationInvoice.discountIds?.filter((id)=>!discounts.connect?.some((d)=>d.id === id)) : undefined;
-                const disconnectClauses = toDisconnect?.length ? {
-                    disconnect: toDisconnect.map((id)=>({
-                            id
-                        }))
-                } : undefined;
+                const toDisconnect = discounts
+                    ? oldReservationInvoice.discountIds?.filter((id) => !discounts.connect?.some((d) => d.id === id))
+                    : undefined;
+                const disconnectClauses = toDisconnect?.length
+                    ? {
+                        disconnect: toDisconnect.map((id) => ({ id })),
+                    }
+                    : undefined;
                 update = {
                     ...update,
                     ...rest,
-                    ...discounts || disconnectClauses ? {
-                        discounts: {
-                            ...discounts || {},
-                            ...disconnectClauses || {}
+                    ...(discounts || disconnectClauses
+                        ? {
+                            discounts: {
+                                ...(discounts || {}),
+                                ...(disconnectClauses || {}),
+                            },
                         }
-                    } : {},
+                        : {}),
                     metadata: {
                         ...update.metadata,
-                        couponCode: newParams.couponCode
+                        couponCode: newParams.couponCode,
                     },
                     providerMetadata: {
                         ...update.providerMetadata,
-                        couponCode: newParams.couponCode
-                    }
+                        couponCode: newParams.couponCode,
+                    },
                 };
             }
             if (result.err && result.val.code !== PROBLEM_APPLICABLE_NOT_FOUND) {
                 return result;
             }
-        } else if (oldReservationInvoice.discountIds.length) {
+        }
+        else if (oldReservationInvoice.discountIds.length) {
             // No discounts, so we disconnect all of them
             update = {
                 discounts: {
-                    disconnect: oldReservationInvoice.discountIds.map((id)=>({
-                            id
-                        }))
-                }
+                    disconnect: oldReservationInvoice.discountIds.map((id) => ({
+                        id,
+                    })),
+                },
             };
         }
     }
     let updated = await wrapInResult(biller.updateInvoice(oldReservationInvoice.id, update));
     // If the invoice was locked due to pending status and we're more than 1 minute old, we unlock it
     if (updated.err && updated.val.code === 'invoice_pending') {
-        if (oldReservationInvoice.lockedAt && isAfter(oldReservationInvoice.lockedAt, subMinutes(new Date(), 1)) || !oldReservationInvoice.lockedAt) {
+        if ((oldReservationInvoice.lockedAt &&
+            isAfter(oldReservationInvoice.lockedAt, subMinutes(new Date(), 1))) ||
+            !oldReservationInvoice.lockedAt) {
             updated = await wrapInResult(biller.updateInvoice(oldReservationInvoice.id, {
                 ...update,
                 locked: false,
                 lockedAt: null,
                 lockReason: null,
                 unlockAt: null,
-                status: 'draft'
+                status: 'draft',
             }));
         }
     }
@@ -88,7 +96,7 @@ export const updateReservationInvoiceIfNeeded = async (oldReservationInvoice, ne
     }
     return new Ok(updated.val);
 };
-export const createReservationInvoice = async ({ invoiceId, couponCode, plan, mileagePackage, referralCode, reservationId, paymentIntentId, freeReservation, freeReservationReason, analytics, vehicle, payer, subscribingUser })=>{
+export const createReservationInvoice = async ({ invoiceId, couponCode, plan, mileagePackage, referralCode, reservationId, paymentIntentId, freeReservation, freeReservationReason, analytics, vehicle, payer, subscribingUser, }) => {
     if (freeReservation) {
         // It's a free reservation, so we don't need to add a coupon code
         return await wrapInResult(biller.createInvoice(getInvoiceCreateDetails({
@@ -101,17 +109,21 @@ export const createReservationInvoice = async ({ invoiceId, couponCode, plan, mi
             freeReservation,
             freeReservationReason,
             analytics,
-            reservationId
+            reservationId,
         })));
     }
     let finalCouponCode = couponCode;
     // If we don't have a reservation coupon ID, we apply the referral discount if any
-    const referral = referralCode && await prisma.referral.findUnique({
-        where: {
-            id: referralCode
-        }
-    });
-    if (!finalCouponCode && referral && referral.discountToReceiverCouponId && referral.discountToReceiverCouponApplicationName === 'reservationFee') {
+    const referral = referralCode &&
+        (await prisma.referral.findUnique({
+            where: {
+                id: referralCode,
+            },
+        }));
+    if (!finalCouponCode &&
+        referral &&
+        referral.discountToReceiverCouponId &&
+        referral.discountToReceiverCouponApplicationName === 'reservationFee') {
         const referralCoupon = await loadCoupon(referral.discountToReceiverCouponId);
         if (referralCoupon) {
             finalCouponCode = referralCoupon.code;
@@ -130,20 +142,18 @@ export const createReservationInvoice = async ({ invoiceId, couponCode, plan, mi
             freeReservation,
             freeReservationReason,
             analytics,
-            reservationId
+            reservationId,
         }),
         lines: [
             {
                 amount: reservationAmount,
                 description: `Reservation fee for ${vehicleName(vehicle)}`,
-                chargingFor: 'reservationFee'
-            }
-        ]
+                chargingFor: 'reservationFee',
+            },
+        ],
     };
     if (finalCouponCode) {
-        log.debug({
-            finalCouponCode
-        }, 'Applying coupon code to invoice');
+        log.debug({ finalCouponCode }, 'Applying coupon code to invoice');
         const withCoupon = await coupons.applyCouponToUnsavedInvoice(finalCouponCode, invoiceCreateDetails, 'reservationFee', {
             subscriptionPlans: plan,
             subscriptionMileagePackages: mileagePackage,
@@ -151,25 +161,24 @@ export const createReservationInvoice = async ({ invoiceId, couponCode, plan, mi
             vehicleMake: vehicle.make,
             userId: subscribingUser.id,
             businessId: payer.object === 'business' ? payer.id : undefined,
-            vehicleType: vehicle.type
+            vehicleType: vehicle.type,
         });
-        if (withCoupon.err && withCoupon.val.code !== PROBLEM_APPLICABLE_NOT_FOUND) {
+        if (withCoupon.err &&
+            withCoupon.val.code !== PROBLEM_APPLICABLE_NOT_FOUND) {
             return withCoupon;
         }
-        log.debug({
-            couponUpdates: withCoupon.val
-        }, 'Coupon applied to invoice');
+        log.debug({ couponUpdates: withCoupon.val }, 'Coupon applied to invoice');
         if (withCoupon.ok) {
             invoiceCreateDetails = {
                 ...withCoupon.val,
                 metadata: {
                     ...withCoupon.val.metadata,
-                    couponCode: finalCouponCode
+                    couponCode: finalCouponCode,
                 },
                 providerMetadata: {
                     ...withCoupon.val.providerMetadata,
-                    couponCode: finalCouponCode
-                }
+                    couponCode: finalCouponCode,
+                },
             };
         }
     }
@@ -177,15 +186,15 @@ export const createReservationInvoice = async ({ invoiceId, couponCode, plan, mi
         ...invoiceCreateDetails,
         providerMetadata: {
             ...invoiceCreateDetails.providerMetadata,
-            invoiceId: invoiceCreateDetails.id
-        }
+            invoiceId: invoiceCreateDetails.id,
+        },
     }));
     if (result.err) {
         return result;
     }
     return new Ok(result.val);
 };
-const getInvoiceCreateDetails = ({ invoiceId, payer, date, reservationDiscountId, vehicle, plan, mileagePackage, couponCode, paymentIntentId, freeReservation, freeReservationReason, analytics, reservationId })=>{
+const getInvoiceCreateDetails = ({ invoiceId, payer, date, reservationDiscountId, vehicle, plan, mileagePackage, couponCode, paymentIntentId, freeReservation, freeReservationReason, analytics, reservationId, }) => {
     return {
         id: invoiceId || generateId('Invoice'),
         taxPercentage: 0,
@@ -201,13 +210,15 @@ const getInvoiceCreateDetails = ({ invoiceId, payer, date, reservationDiscountId
         description: 'Reservation fee for a FLUX subscription',
         footer: `Invoice for a FLUX subscription reservation. Due by ${format(date ?? new Date())}`,
         invoiceUrl: `${config.appUrl}/invoice-preview/${invoiceId}`,
-        ...reservationDiscountId ? {
-            discounts: {
-                connect: {
-                    id: reservationDiscountId
-                }
+        ...(reservationDiscountId
+            ? {
+                discounts: {
+                    connect: {
+                        id: reservationDiscountId,
+                    },
+                },
             }
-        } : {},
+            : {}),
         lines: [],
         subscriptionDetails: {
             vehicleId: vehicle.id,
@@ -216,7 +227,7 @@ const getInvoiceCreateDetails = ({ invoiceId, payer, date, reservationDiscountId
             variant: vehicle.variant,
             year: vehicle.year,
             plan: plan,
-            mileagePackage: mileagePackage
+            mileagePackage: mileagePackage,
         },
         // Legacy field:
         stripePaymentIntentId: paymentIntentId,
@@ -226,18 +237,14 @@ const getInvoiceCreateDetails = ({ invoiceId, payer, date, reservationDiscountId
             mileagePackage,
             vehicleId: vehicle.id,
             vehicleName: vehicleName(vehicle),
-            ...reservationId ? {
-                reservationId
-            } : {},
-            ...couponCode ? {
-                couponCode
-            } : {}
+            ...(reservationId ? { reservationId } : {}),
+            ...(couponCode ? { couponCode } : {}),
         },
         autoRetry: {
             enabled: false,
             interval: 0,
             maxAttempts: 0,
-            attempts: 0
+            attempts: 0,
         },
         metadata: {
             purpose: PURPOSE_RESERVATION,
@@ -246,10 +253,11 @@ const getInvoiceCreateDetails = ({ invoiceId, payer, date, reservationDiscountId
             plan,
             mileagePackage,
             couponCode,
-            ...freeReservation && freeReservationReason ? {
-                freeReservationReason
-            } : {},
-            analytics
-        }
+            ...(freeReservation && freeReservationReason
+                ? { freeReservationReason }
+                : {}),
+            analytics,
+        },
     };
 };
+//# sourceMappingURL=invoice.js.map

package/dist/reservation/payer.js

@@ -1,7 +1,7 @@
 import { prisma } from '@driveflux/db';
-import { makeProblem, PROBLEM_CONDITION_FAILED, PROBLEM_NOT_FOUND } from '@driveflux/problem';
+import { makeProblem, PROBLEM_CONDITION_FAILED, PROBLEM_NOT_FOUND, } from '@driveflux/problem';
 import { Err, Ok } from '@driveflux/result';
-export const getPayer = async ({ subscribingUser, asBusiness })=>{
+export const getPayer = async ({ subscribingUser, asBusiness, }) => {
     let business = null;
     let payer = subscribingUser;
     if (asBusiness) {
@@ -11,8 +11,8 @@ export const getPayer = async ({ subscribingUser, asBusiness })=>{
         // load business
         business = await prisma.business.findUnique({
             where: {
-                id: subscribingUser.businessId
-            }
+                id: subscribingUser.businessId,
+            },
         });
         if (!business) {
             return new Err(makeProblem(PROBLEM_NOT_FOUND, `The business ${subscribingUser.businessId} was not found.`));
@@ -26,7 +26,7 @@ export const getPayer = async ({ subscribingUser, asBusiness })=>{
     }
     return new Ok(payer);
 };
-const checkPayerObjectSanity = (subscriber)=>{
+const checkPayerObjectSanity = (subscriber) => {
     if (!subscriber.email) {
         return new Err(makeProblem(PROBLEM_CONDITION_FAILED, `Subscriber ${subscriber.id} has no email. Please add a verified email first.`));
     }
@@ -35,3 +35,4 @@ const checkPayerObjectSanity = (subscriber)=>{
     }
     return new Ok(true);
 };
+//# sourceMappingURL=payer.js.map

package/dist/reservation/payment-intent-sync.js

@@ -3,18 +3,20 @@ import { makeProblem, PROBLEM_EXTERNAL } from '@driveflux/problem';
 import { Err, Ok } from '@driveflux/result';
 import { createScopedLogger } from '../create-logger.js';
 const log = createScopedLogger('reservation:payment-intent-sync');
-export const ensurePaymentIntentIdIsSynced = async (invoice, paymentIntentId)=>{
+export const ensurePaymentIntentIdIsSynced = async (invoice, paymentIntentId) => {
     const stripe = biller.getPaymentProvider('stripe').getStripe();
     try {
         await stripe.paymentIntents.update(paymentIntentId, {
             metadata: {
                 ...invoice.providerMetadata,
-                invoiceId: invoice.id
-            }
+                invoiceId: invoice.id,
+            },
         });
         return new Ok(true);
-    } catch (error) {
+    }
+    catch (error) {
         log.error(error, 'Error updating payment intent metadata');
         return new Err(makeProblem(PROBLEM_EXTERNAL, 'Error updating payment intent metadata'));
     }
 };
+//# sourceMappingURL=payment-intent-sync.js.map

package/dist/reservation/reserve.js

@@ -7,14 +7,14 @@ import { fetchOrCreateReservation } from './fetch-or-create.js';
 import { getPayer } from './payer.js';
 import { ensurePaymentIntentIdIsSynced } from './payment-intent-sync.js';
 import { getVehicle } from './vehicle.js';
-const processBody = (body)=>{
+const processBody = (body) => {
     // Switch mileage package
     if (body.plan === 'plan1' || body.plan === 'planWeekly') {
         body.mileagePackage = 'unlimited';
     }
     return body;
 };
-export const reserveVehicle = async (vehicleId, unprocessed)=>{
+export const reserveVehicle = async (vehicleId, unprocessed) => {
     const body = processBody(unprocessed);
     // Agree to terms if not done yet
     body.subscribingUser = await handleAgreeToTerms(body);
@@ -45,7 +45,7 @@ export const reserveVehicle = async (vehicleId, unprocessed)=>{
     const reservationResult = await fetchOrCreateReservation({
         vehicle,
         payer,
-        body
+        body,
     });
     if (reservationResult.err) {
         return reservationResult;
@@ -61,3 +61,4 @@ export const reserveVehicle = async (vehicleId, unprocessed)=>{
     }
     return new Ok(reservation);
 };
+//# sourceMappingURL=reserve.js.map

package/dist/reservation/types.js

@@ -1 +1,2 @@
-export { };
+export {};
+//# sourceMappingURL=types.js.map