@voyantjs/storefront 0.47.0 → 0.50.0

package/dist/service-departures.js

@@ -29,18 +29,36 @@ function centsToAmount(cents) {
     }
     return Number((cents / 100).toFixed(2));
 }
+function amountToCents(amount) {
+    return Math.round(amount * 100);
+}
+function convertCents(cents, rate) {
+    if (cents == null) {
+        return null;
+    }
+    return rate == null ? cents : Math.round(cents * rate);
+}
+function convertedAmount(cents, rate) {
+    return centsToAmount(convertCents(cents, rate));
+}
 function getPreferredCurrency(context) {
     return context.catalog?.currencyCode ?? context.product?.sellCurrency ?? "EUR";
 }
-function selectTierAmount(unitRule, tiers, quantity) {
+function selectUnitTier(unitRule, tiers, quantity) {
     if (!unitRule) {
         return null;
     }
-    const tier = tiers
+    return (tiers
         .filter((row) => row.optionUnitPriceRuleId === unitRule.id &&
         quantity >= row.minQuantity &&
         (row.maxQuantity == null || quantity <= row.maxQuantity))
-        .sort((a, b) => a.sortOrder - b.sortOrder)[0];
+        .sort((a, b) => a.sortOrder - b.sortOrder)[0] ?? null);
+}
+function selectTierAmount(unitRule, tiers, quantity) {
+    if (!unitRule) {
+        return null;
+    }
+    const tier = selectUnitTier(unitRule, tiers, quantity);
     return tier?.sellAmountCents ?? unitRule.sellAmountCents ?? null;
 }
 function findNamedUnit(units, matcher) {
@@ -455,53 +473,318 @@ function computeFallbackLineItems(args) {
         lineItems,
     };
 }
-async function applyExtraLineItems(args) {
-    if (args.extras.length === 0) {
-        return { lineItems: args.lineItems, total: args.total };
-    }
+function buildResolvedLineItems(components, conversionRate) {
+    return components.map((component) => {
+        const total = convertedAmount(component.sellAmountCents, conversionRate) ?? 0;
+        const quantity = Math.max(1, component.quantity);
+        return {
+            name: component.title,
+            total,
+            quantity,
+            unitPrice: Number((total / quantity).toFixed(2)),
+        };
+    });
+}
+function buildRequestedUnitRows(args) {
+    return args.requestedUnits.map((request) => {
+        const unit = request.unitId ? args.context.units.find((row) => row.id === request.unitId) : null;
+        const unitRule = request.unitId
+            ? args.context.unitRules.find((row) => row.unitId === request.unitId)
+            : args.context.unitRules[0];
+        const tier = selectUnitTier(unitRule, args.context.tiers, request.quantity);
+        const component = args.components.find((row) => row.kind === "unit" && request.requestRef && row.requestRef === request.requestRef) ??
+            args.components.find((row) => row.kind === "unit" && request.unitId && row.unitId === request.unitId);
+        const quantity = Math.max(1, request.quantity);
+        const total = component != null
+            ? (convertedAmount(component.sellAmountCents, args.conversionRate) ?? 0)
+            : Number(((convertedAmount(tier?.sellAmountCents ?? unitRule?.sellAmountCents, args.conversionRate) ?? 0) * quantity).toFixed(2));
+        const unitAmount = Number((total / quantity).toFixed(2));
+        return {
+            unitId: request.unitId ?? null,
+            requestRef: request.requestRef ?? request.unitId ?? null,
+            name: unit?.name ?? args.context.option?.name ?? "Traveler",
+            unitType: unit?.unitType ?? null,
+            quantity,
+            pricingMode: component?.pricingMode ?? unitRule?.pricingMode ?? null,
+            unitPrice: unitAmount,
+            total,
+            currencyCode: args.currencyCode,
+            tierId: component?.tierId ?? tier?.id ?? null,
+        };
+    });
+}
+function buildRoomRows(args) {
+    return args.rooms.map((room) => {
+        const unit = args.context.units.find((row) => row.id === room.unitId);
+        const unitRule = args.context.unitRules.find((row) => row.unitId === room.unitId);
+        const pax = Math.max(1, room.occupancy * room.quantity);
+        const quantity = unitRule?.pricingMode === "per_person" ? pax : Math.max(1, room.quantity);
+        const tier = selectUnitTier(unitRule, args.context.tiers, pax);
+        const component = args.components.find((row) => row.kind === "unit" && row.requestRef === room.requestRef) ??
+            args.components.find((row) => row.kind === "unit" && row.unitId === room.unitId);
+        const total = component != null
+            ? (convertedAmount(component.sellAmountCents, args.conversionRate) ?? 0)
+            : Number(((convertedAmount(tier?.sellAmountCents ?? unitRule?.sellAmountCents, args.conversionRate) ?? 0) * quantity).toFixed(2));
+        const unitAmount = Number((total / quantity).toFixed(2));
+        return {
+            unitId: room.unitId,
+            name: unit?.name ?? room.unitId,
+            occupancy: room.occupancy,
+            quantity: room.quantity,
+            pax,
+            pricingMode: component?.pricingMode ?? unitRule?.pricingMode ?? null,
+            unitPrice: unitAmount,
+            total,
+            currencyCode: args.currencyCode,
+            tierId: component?.tierId ?? tier?.id ?? null,
+        };
+    });
+}
+async function buildExtraImpacts(args) {
+    const selectedQuantityByExtraId = new Map(args.extras.map((extra) => [extra.extraId, extra.quantity]));
     const extras = await args.db
         .select({
         id: productExtras.id,
         name: productExtras.name,
+        selectionType: productExtras.selectionType,
         pricingMode: productExtras.pricingMode,
         pricedPerPerson: productExtras.pricedPerPerson,
+        defaultQuantity: productExtras.defaultQuantity,
+        minQuantity: productExtras.minQuantity,
     })
         .from(productExtras)
-        .where(and(eq(productExtras.productId, args.productId), eq(productExtras.active, true), inArray(productExtras.id, args.extras.map((extra) => extra.extraId))));
+        .where(and(eq(productExtras.productId, args.productId), eq(productExtras.active, true)))
+        .orderBy(asc(productExtras.sortOrder), asc(productExtras.name));
     const ruleByExtraId = new Map(args.context.extraRules
         .filter((rule) => rule.productExtraId)
         .map((rule) => [rule.productExtraId, rule]));
-    let total = args.total;
-    const lineItems = [...args.lineItems];
-    for (const extraSelection of args.extras) {
-        const extra = extras.find((row) => row.id === extraSelection.extraId);
-        if (!extra) {
-            continue;
-        }
-        const rule = ruleByExtraId.get(extraSelection.extraId);
+    return extras.map((extra) => {
+        const rule = ruleByExtraId.get(extra.id);
+        const selectedQuantity = selectedQuantityByExtraId.get(extra.id);
+        const required = extra.selectionType === "required";
+        const selected = selectedQuantity != null || required;
         const pricingMode = rule?.pricingMode ?? (extra.pricedPerPerson ? "per_person" : extra.pricingMode);
-        const unitAmount = centsToAmount(rule?.sellAmountCents) ?? 0;
-        if (pricingMode === "included" ||
+        const unitAmount = convertedAmount(rule?.sellAmountCents, args.conversionRate) ?? 0;
+        const chargeable = pricingMode === "included" ||
             pricingMode === "free" ||
             pricingMode === "unavailable" ||
-            pricingMode === "on_request") {
-            continue;
-        }
-        const quantity = pricingMode === "per_person"
-            ? Math.max(1, args.paxTotal * Math.max(1, extraSelection.quantity))
-            : Math.max(1, extraSelection.quantity);
-        const totalAmount = Number((unitAmount * quantity).toFixed(2));
-        total += totalAmount;
-        lineItems.push({
+            pricingMode === "on_request"
+            ? false
+            : selected;
+        const baseQuantity = selected
+            ? (selectedQuantity ?? extra.defaultQuantity ?? extra.minQuantity ?? 1)
+            : 0;
+        const quantity = chargeable && pricingMode === "per_person"
+            ? Math.max(1, args.paxTotal * Math.max(1, baseQuantity))
+            : Math.max(0, baseQuantity);
+        const total = chargeable ? Number((unitAmount * quantity).toFixed(2)) : 0;
+        return {
+            extraId: extra.id,
             name: extra.name,
-            total: totalAmount,
+            required,
+            selectable: extra.selectionType !== "unavailable",
+            selected,
+            pricingMode,
             quantity,
             unitPrice: unitAmount,
-        });
-    }
+            total,
+            currencyCode: args.currencyCode,
+        };
+    });
+}
+async function applyExtraLineItems(args) {
+    const impacts = await buildExtraImpacts(args);
+    const selectedImpacts = impacts.filter((extra) => extra.selected && extra.total > 0);
+    const lineItems = [
+        ...args.lineItems,
+        ...selectedImpacts.map((extra) => ({
+            name: extra.name,
+            total: extra.total,
+            quantity: Math.max(1, extra.quantity),
+            unitPrice: extra.unitPrice,
+        })),
+    ];
+    const total = selectedImpacts.reduce((sum, extra) => sum + extra.total, args.total);
     return {
         lineItems,
         total: Number(total.toFixed(2)),
+        impacts,
+    };
+}
+function computeOfferDiscountCents(offer, basePriceCents) {
+    if (basePriceCents <= 0)
+        return 0;
+    if (offer.discountType === "percentage") {
+        const percent = Number(offer.discountValue);
+        return Number.isFinite(percent) ? Math.round((basePriceCents * percent) / 100) : 0;
+    }
+    const discountCents = Number.parseInt(offer.discountValue, 10);
+    return Number.isFinite(discountCents) ? Math.min(discountCents, basePriceCents) : 0;
+}
+function buildAppliedOfferFromDto(input) {
+    const discountPercent = input.offer.discountType === "percentage" ? Number(input.offer.discountValue) : null;
+    const discountAmountCents = input.offer.discountType === "fixed_amount"
+        ? Number.parseInt(input.offer.discountValue, 10)
+        : null;
+    return {
+        offerId: input.offer.id,
+        offerName: input.offer.name,
+        discountAppliedCents: input.discountAppliedCents,
+        discountedPriceCents: Math.max(0, input.basePriceCents - input.discountAppliedCents),
+        currency: input.currencyCode,
+        discountKind: input.offer.discountType,
+        discountPercent: Number.isFinite(discountPercent) ? discountPercent : null,
+        discountAmountCents: Number.isFinite(discountAmountCents) ? discountAmountCents : null,
+        appliedCode: null,
+        stackable: input.offer.stackable,
+    };
+}
+function evaluateAvailableOfferImpacts(input) {
+    const candidates = input.offers.map((offer) => {
+        const standaloneDiscount = computeOfferDiscountCents(offer, input.basePriceCents);
+        const reason = offer.minTravelers != null && input.paxTotal < offer.minTravelers
+            ? "min_pax"
+            : offer.discountType === "fixed_amount" && offer.currency !== input.currencyCode
+                ? "currency"
+                : standaloneDiscount <= 0
+                    ? "no_discount"
+                    : null;
+        return { offer, standaloneDiscount, reason };
+    });
+    const applicable = candidates.filter((candidate) => candidate.reason == null);
+    const stackable = applicable
+        .filter((candidate) => candidate.offer.stackable)
+        .sort((a, b) => (a.offer.id < b.offer.id ? -1 : a.offer.id > b.offer.id ? 1 : 0));
+    const nonStackable = applicable.filter((candidate) => !candidate.offer.stackable);
+    let bestNonStackable = null;
+    for (const candidate of nonStackable) {
+        if (bestNonStackable == null ||
+            candidate.standaloneDiscount > bestNonStackable.standaloneDiscount) {
+            bestNonStackable = candidate;
+        }
+    }
+    let runningBase = input.basePriceCents;
+    const selectedStackable = stackable
+        .map((candidate) => {
+        const discount = computeOfferDiscountCents(candidate.offer, runningBase);
+        runningBase = Math.max(0, runningBase - discount);
+        return { ...candidate, selectedDiscount: discount };
+    })
+        .filter((candidate) => candidate.selectedDiscount > 0);
+    const stackableDiscount = input.basePriceCents - runningBase;
+    const selected = bestNonStackable && bestNonStackable.standaloneDiscount >= stackableDiscount
+        ? [{ ...bestNonStackable, selectedDiscount: bestNonStackable.standaloneDiscount }]
+        : selectedStackable;
+    const selectedByOfferId = new Map(selected.map((candidate) => [candidate.offer.id, candidate]));
+    const applied = selected.map((candidate) => buildAppliedOfferFromDto({
+        offer: candidate.offer,
+        discountAppliedCents: candidate.selectedDiscount,
+        basePriceCents: input.basePriceCents,
+        currencyCode: input.currencyCode,
+    }));
+    const discountTotalCents = applied.reduce((sum, offer) => sum + offer.discountAppliedCents, 0);
+    const eligibleButNotSelected = applicable.filter((candidate) => !selectedByOfferId.has(candidate.offer.id));
+    const conflict = eligibleButNotSelected.length > 0
+        ? {
+            policy: selected.every((candidate) => candidate.offer.stackable)
+                ? "stackable_compose"
+                : "best_discount_wins",
+            autoAppliedOfferIds: selected
+                .filter((candidate) => candidate.offer.slug == null)
+                .map((candidate) => candidate.offer.id),
+            manualOfferId: null,
+            selectedOfferIds: selected.map((candidate) => candidate.offer.id),
+            message: selected.every((candidate) => candidate.offer.stackable)
+                ? "Stackable offers compose when they beat the best standalone discount."
+                : "The best discount wins when non-stackable offers compete.",
+        }
+        : null;
+    return {
+        available: candidates.map((candidate) => {
+            const selectedCandidate = selectedByOfferId.get(candidate.offer.id);
+            const selectedDiscount = selectedCandidate?.selectedDiscount ?? 0;
+            const conflictReason = candidate.reason == null && !selectedCandidate && selected.length > 0 ? "conflict" : null;
+            const discountAppliedCents = selectedCandidate?.selectedDiscount ?? candidate.standaloneDiscount;
+            return {
+                offer: candidate.offer,
+                status: selectedCandidate ? "applied" : conflictReason ? "conflict" : "not_applicable",
+                reason: candidate.reason ?? conflictReason,
+                selected: Boolean(selectedCandidate),
+                discountAppliedCents,
+                discountedPriceCents: Math.max(0, input.basePriceCents -
+                    (selectedCandidate ? selectedDiscount : candidate.standaloneDiscount)),
+            };
+        }),
+        applied,
+        conflict,
+        discountTotalCents,
+    };
+}
+async function buildOfferPreview(input) {
+    const availableOffers = (await input.resolvers?.listApplicableOffers?.({
+        productId: input.productId,
+        departureId: input.departureId,
+        locale: input.locale,
+    })) ?? [];
+    const autoPreview = evaluateAvailableOfferImpacts({
+        offers: availableOffers,
+        basePriceCents: input.basePriceCents,
+        currencyCode: input.currencyCode,
+        paxTotal: input.paxTotal,
+    });
+    const target = {
+        productId: input.productId,
+        departureId: input.departureId,
+        pax: input.paxTotal,
+        audience: "customer",
+        market: input.market,
+        basePriceCents: input.basePriceCents,
+        currency: input.currencyCode,
+        ...(input.locale ? { locale: input.locale } : {}),
+    };
+    const requested = [];
+    for (const offer of input.requestedOffers) {
+        requested.push({
+            kind: "slug",
+            value: offer.slug,
+            result: (await input.resolvers?.applyOffer?.({
+                slug: offer.slug,
+                body: target,
+            })) ?? null,
+        });
+    }
+    if (input.offerCode) {
+        requested.push({
+            kind: "code",
+            value: input.offerCode,
+            result: (await input.resolvers?.redeemOffer?.({
+                body: { ...target, code: input.offerCode },
+            })) ?? null,
+        });
+    }
+    const bestRequested = requested
+        .map((entry) => entry.result)
+        .filter((result) => Boolean(result))
+        .filter((result) => result.status === "applied" || result.status === "conflict")
+        .sort((a, b) => b.pricing.discountAppliedCents - a.pricing.discountAppliedCents)[0];
+    const applied = bestRequested && bestRequested.pricing.discountAppliedCents > autoPreview.discountTotalCents
+        ? bestRequested.appliedOffers
+        : autoPreview.applied;
+    const conflict = bestRequested && bestRequested.pricing.discountAppliedCents > autoPreview.discountTotalCents
+        ? bestRequested.conflict
+        : autoPreview.conflict;
+    const discountTotalCents = bestRequested && bestRequested.pricing.discountAppliedCents > autoPreview.discountTotalCents
+        ? bestRequested.pricing.discountAppliedCents
+        : autoPreview.discountTotalCents;
+    return {
+        available: autoPreview.available,
+        requested,
+        applied,
+        conflict,
+        discountTotal: centsToAmount(discountTotalCents) ?? 0,
+        discountTotalCents,
+        totalAfterDiscount: centsToAmount(Math.max(0, input.basePriceCents - discountTotalCents)) ?? 0,
+        currencyCode: input.currencyCode,
     };
 }
 async function buildDeparture(db, slot, defaultItineraryByProduct, meetingPointByProduct) {
@@ -704,7 +987,7 @@ export async function getStorefrontProductAvailabilitySummary(db, productId, que
         offset: query.offset,
     };
 }
-export async function previewStorefrontDeparturePrice(db, departureId, input) {
+export async function previewStorefrontDeparturePrice(db, departureId, input, offerResolvers) {
     const [slot] = await listSlots(db, { slotId: departureId, limit: 1 });
     if (!slot) {
         return null;
@@ -713,8 +996,9 @@ export async function previewStorefrontDeparturePrice(db, departureId, input) {
     const adults = Math.max(0, input.pax?.adults ?? 1);
     const children = Math.max(0, input.pax?.children ?? 0);
     const infants = Math.max(0, input.pax?.infants ?? 0);
-    const rooms = input.rooms.map((room) => ({
+    const rooms = input.rooms.map((room, index) => ({
         unitId: room.unitId,
+        requestRef: `${room.unitId}:${index}`,
         occupancy: room.occupancy,
         quantity: room.quantity,
     }));
@@ -725,7 +1009,7 @@ export async function previewStorefrontDeparturePrice(db, departureId, input) {
     const requestedUnits = rooms.length > 0
         ? rooms.map((room) => ({
             unitId: room.unitId,
-            requestRef: room.unitId,
+            requestRef: room.requestRef,
             quantity: Math.max(1, room.occupancy * room.quantity),
         }))
         : buildTravelerRequestedUnits({
@@ -743,16 +1027,13 @@ export async function previewStorefrontDeparturePrice(db, departureId, input) {
         limit: 25,
     });
     const candidate = resolved.data.find((row) => row.slot.id === departureId && (!slot.optionId || row.option.id === slot.optionId)) ?? resolved.data[0];
+    const conversionRate = candidate?.pricing.fx?.rateDecimal != null ? Number(candidate.pricing.fx.rateDecimal) : null;
+    const components = candidate ? candidate.pricing.components : [];
     const seeded = candidate
         ? {
             currencyCode: candidate.pricing.currencyCode,
             total: Number((candidate.pricing.sellAmountCents / 100).toFixed(2)),
-            lineItems: candidate.pricing.components.map((component) => ({
-                name: component.title,
-                total: Number((component.sellAmountCents / 100).toFixed(2)),
-                quantity: Math.max(1, component.quantity),
-                unitPrice: Number((component.sellAmountCents / 100 / Math.max(1, component.quantity)).toFixed(2)),
-            })),
+            lineItems: buildResolvedLineItems(components, conversionRate),
             notes: candidate.sellability.onRequest ? "on_request" : null,
         }
         : {
@@ -765,25 +1046,108 @@ export async function previewStorefrontDeparturePrice(db, departureId, input) {
             }),
             notes: null,
         };
+    const roomPaxTotal = rooms.reduce((sum, room) => sum + Math.max(1, room.occupancy * room.quantity), 0);
+    const travelerPaxTotal = Math.max(1, adults + children + infants);
+    const paxTotal = rooms.length > 0 ? Math.max(1, roomPaxTotal) : travelerPaxTotal;
     const withExtras = await applyExtraLineItems({
         db,
         productId: slot.productId,
         context,
-        paxTotal: Math.max(1, adults + children + infants),
+        paxTotal,
         extras,
+        currencyCode: seeded.currencyCode,
+        conversionRate,
         lineItems: seeded.lineItems,
         total: seeded.total,
     });
+    const unitRows = rooms.length > 0
+        ? []
+        : buildRequestedUnitRows({
+            context,
+            requestedUnits,
+            components,
+            currencyCode: seeded.currencyCode,
+            conversionRate,
+        });
+    const roomRows = buildRoomRows({
+        context,
+        rooms,
+        components,
+        currencyCode: seeded.currencyCode,
+        conversionRate,
+    });
+    const subtotal = withExtras.total;
+    const offers = await buildOfferPreview({
+        resolvers: offerResolvers,
+        productId: slot.productId,
+        departureId: slot.id,
+        basePriceCents: amountToCents(subtotal),
+        currencyCode: seeded.currencyCode,
+        paxTotal,
+        requestedOffers: input.offers,
+        offerCode: input.offerCode,
+        locale: input.locale,
+        market: input.market,
+    });
+    const total = offers.totalAfterDiscount;
+    const extrasTotal = withExtras.impacts.reduce((sum, extra) => sum + extra.total, 0);
+    const basePrice = Number((subtotal - extrasTotal).toFixed(2));
     return {
         departureId: slot.id,
         productId: slot.productId,
         optionId: slot.optionId,
         currencyCode: seeded.currencyCode,
-        basePrice: seeded.lineItems[0]?.total ?? 0,
+        basePrice,
         taxAmount: 0,
-        total: withExtras.total,
+        total,
         notes: seeded.notes,
         lineItems: withExtras.lineItems,
+        allocation: {
+            slot: {
+                id: slot.id,
+                productId: slot.productId,
+                optionId: slot.optionId,
+                dateLocal: normalizeLocalDate(slot.dateLocal),
+                startAt: normalizeIso(slot.startsAt),
+                endAt: normalizeIso(slot.endsAt),
+                timezone: slot.timezone,
+                status: buildDepartureStatus(slot, context),
+                availabilityState: buildAvailabilityState({
+                    status: buildDepartureStatus(slot, context),
+                    remaining: slot.remainingPax ?? slot.remainingResources ?? null,
+                    capacity: slot.unlimited ? null : (slot.initialPax ?? slot.remainingPax ?? null),
+                    pastCutoff: slot.pastCutoff,
+                    tooEarly: slot.tooEarly,
+                }),
+                capacity: slot.unlimited ? null : (slot.initialPax ?? slot.remainingPax ?? null),
+                remaining: slot.remainingPax ?? slot.remainingResources ?? null,
+                pastCutoff: slot.pastCutoff,
+                tooEarly: slot.tooEarly,
+            },
+            pax: {
+                adults,
+                children,
+                infants,
+                total: paxTotal,
+            },
+            requestedUnits: unitRows,
+            rooms: roomRows,
+        },
+        units: unitRows,
+        rooms: roomRows,
+        extras: withExtras.impacts,
+        offers,
+        totals: {
+            currencyCode: seeded.currencyCode,
+            base: basePrice,
+            extras: Number(extrasTotal.toFixed(2)),
+            subtotal,
+            discount: offers.discountTotal,
+            tax: 0,
+            total,
+            perPerson: Number((total / paxTotal).toFixed(2)),
+            perBooking: total,
+        },
     };
 }
 export async function getStorefrontProductExtensions(db, productId, optionId) {

package/dist/service-intake.d.ts

@@ -0,0 +1,40 @@
+import { CUSTOMER_SIGNAL_CREATED_EVENT } from "@voyantjs/crm/events";
+import type { StorefrontRequestContext } from "./service.js";
+import type { StorefrontIntakeResponse, StorefrontLeadIntakeInput, StorefrontNewsletterSubscribeInput, StorefrontNewsletterSubscribeResponse } from "./validation.js";
+export { CUSTOMER_SIGNAL_CREATED_EVENT };
+export interface StorefrontIntakeGuardDecision {
+    allowed: boolean;
+    status?: 400 | 403 | 429;
+    error?: string;
+}
+export type StorefrontIntakeGuard = (input: {
+    kind: "lead";
+    body: StorefrontLeadIntakeInput;
+    context: StorefrontRequestContext;
+} | {
+    kind: "newsletter";
+    body: StorefrontNewsletterSubscribeInput;
+    context: StorefrontRequestContext;
+}) => Promise<StorefrontIntakeGuardDecision | undefined> | StorefrontIntakeGuardDecision | undefined;
+export type StorefrontNewsletterDoubleOptInHook = (input: {
+    email: string;
+    personId: string;
+    signalId: string;
+    sourceSubmissionId: string;
+    body: StorefrontNewsletterSubscribeInput;
+    context: StorefrontRequestContext;
+}) => Promise<void> | void;
+export interface StorefrontIntakeOptions {
+    guard?: StorefrontIntakeGuard;
+    requestNewsletterDoubleOptIn?: StorefrontNewsletterDoubleOptInHook;
+}
+export declare function createStorefrontLeadSignal(input: {
+    body: StorefrontLeadIntakeInput;
+    context: StorefrontRequestContext;
+}): Promise<StorefrontIntakeResponse>;
+export declare function subscribeStorefrontNewsletter(input: {
+    body: StorefrontNewsletterSubscribeInput;
+    context: StorefrontRequestContext;
+    requestDoubleOptIn?: StorefrontNewsletterDoubleOptInHook;
+}): Promise<StorefrontNewsletterSubscribeResponse>;
+//# sourceMappingURL=service-intake.d.ts.map

package/dist/service-intake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-intake.d.ts","sourceRoot":"","sources":["../src/service-intake.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,6BAA6B,EAA6B,MAAM,sBAAsB,CAAA;AAI/F,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAA;AAC5D,OAAO,KAAK,EACV,wBAAwB,EAExB,yBAAyB,EACzB,kCAAkC,EAClC,qCAAqC,EACtC,MAAM,iBAAiB,CAAA;AAExB,OAAO,EAAE,6BAA6B,EAAE,CAAA;AAExC,MAAM,WAAW,6BAA6B;IAC5C,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAA;IACxB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,MAAM,qBAAqB,GAAG,CAClC,KAAK,EACD;IACE,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,yBAAyB,CAAA;IAC/B,OAAO,EAAE,wBAAwB,CAAA;CAClC,GACD;IACE,IAAI,EAAE,YAAY,CAAA;IAClB,IAAI,EAAE,kCAAkC,CAAA;IACxC,OAAO,EAAE,wBAAwB,CAAA;CAClC,KACF,OAAO,CAAC,6BAA6B,GAAG,SAAS,CAAC,GAAG,6BAA6B,GAAG,SAAS,CAAA;AAEnG,MAAM,MAAM,mCAAmC,GAAG,CAAC,KAAK,EAAE;IACxD,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,IAAI,EAAE,kCAAkC,CAAA;IACxC,OAAO,EAAE,wBAAwB,CAAA;CAClC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;AAE1B,MAAM,WAAW,uBAAuB;IACtC,KAAK,CAAC,EAAE,qBAAqB,CAAA;IAC7B,4BAA4B,CAAC,EAAE,mCAAmC,CAAA;CACnE;AA+GD,wBAAsB,0BAA0B,CAAC,KAAK,EAAE;IACtD,IAAI,EAAE,yBAAyB,CAAA;IAC/B,OAAO,EAAE,wBAAwB,CAAA;CAClC,GAAG,OAAO,CAAC,wBAAwB,CAAC,CA8DpC;AAED,wBAAsB,6BAA6B,CAAC,KAAK,EAAE;IACzD,IAAI,EAAE,kCAAkC,CAAA;IACxC,OAAO,EAAE,wBAAwB,CAAA;IACjC,kBAAkB,CAAC,EAAE,mCAAmC,CAAA;CACzD,GAAG,OAAO,CAAC,qCAAqC,CAAC,CA6FjD"}