@voyantjs/travel-composer-react 0.105.6 → 0.105.8

package/dist/admin/admin-trip-composer-page.js

@@ -0,0 +1,793 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMutation } from "@tanstack/react-query";
+import { useOperatorAdminMessages as useAdminMessages, useAdminNavigate } from "@voyantjs/admin";
+import { emptyPersonPickerValue } from "@voyantjs/bookings-react/components/person-picker-section";
+import { emptyVoucherPickerValue } from "@voyantjs/bookings-react/components/voucher-picker-section";
+import { PersonPickerSection, } from "@voyantjs/bookings-react/ui";
+import { usePerson } from "@voyantjs/crm-react";
+import { formatMessage } from "@voyantjs/i18n";
+import { Button } from "@voyantjs/ui/components/button";
+import { Checkbox } from "@voyantjs/ui/components/checkbox";
+import { CurrencyCombobox } from "@voyantjs/ui/components/currency-combobox";
+import { Label } from "@voyantjs/ui/components/label";
+import { Textarea } from "@voyantjs/ui/components/textarea";
+import { AlertTriangle, Loader2 } from "lucide-react";
+import { useEffect, useMemo, useState } from "react";
+import { addTripComponent, createTrip, getTrip, previewTripCancellation, priceTrip, removeTripComponent, reserveTrip, startTripCheckout, updateTripComponent, } from "../operations.js";
+import { useVoyantTravelComposerContext } from "../provider.js";
+import { AddComponentMenu, CommittedComponentCard, ComponentsEmpty, componentTitleFor, computePlaceholderTotals, Field, findOverlappingComponent, flightPricingFromPending, newPendingComponent, PendingComponentCard, PrimaryAction, Section, StatusAlert, sortComponentsBySchedule, TripPreviewRail, TripTravelersSection, } from "./admin-trip-composer-panels.js";
+const defaultPaymentCurrency = "EUR";
+export function AdminTripComposerPage({ initialTrip = null, }) {
+    const navigateTo = useAdminNavigate();
+    const t = useAdminMessages().trips.adminComposer;
+    const [state, setState] = useState({
+        trip: initialTrip,
+        message: null,
+        error: null,
+    });
+    const [billing, setBilling] = useState(emptyPersonPickerValue);
+    const [travelers, setTravelers] = useState([]);
+    const [notes, setNotes] = useState("");
+    const [pending, setPending] = useState([]);
+    const [committingLocalId, setCommittingLocalId] = useState(null);
+    const [voucher, setVoucher] = useState(emptyVoucherPickerValue);
+    const [createAsDraft, setCreateAsDraft] = useState(false);
+    const [paymentCurrency, setPaymentCurrency] = useState(defaultPaymentCurrency);
+    const [selectedCancellationIds, setSelectedCancellationIds] = useState([]);
+    const [cancellationReason, setCancellationReason] = useState(t.cancellation.defaultReason);
+    const [cancellationPreview, setCancellationPreview] = useState(null);
+    const { baseUrl, fetcher } = useVoyantTravelComposerContext();
+    const client = useMemo(() => ({ baseUrl, fetcher }), [baseUrl, fetcher]);
+    const trip = state.trip;
+    const envelopeId = trip?.envelope.id;
+    const components = useMemo(() => sortComponentsBySchedule((trip?.components ?? []).filter((component) => component.status !== "removed")), [trip?.components]);
+    const selectedCount = selectedCancellationIds.length;
+    const envelopeStatus = trip?.envelope.status;
+    // Once the trip is reserved or further along, removal touches real holds /
+    // bookings — operators must go through cancellation preview. Before that
+    // (`draft` / priced) a component is a no-op blueprint and can be deleted.
+    const trapReserved = envelopeStatus === "reserved" ||
+        envelopeStatus === "reserve_in_progress" ||
+        envelopeStatus === "checkout_started" ||
+        envelopeStatus === "booked";
+    const billingPersonQuery = usePerson(billing.personId || undefined, {
+        enabled: billing.mode === "existing" && Boolean(billing.personId),
+    });
+    const payerName = derivePayerName(billing, billingPersonQuery.data, t);
+    const payerEmail = derivePayerEmail(billing, billingPersonQuery.data);
+    useEffect(() => {
+        setState((current) => ({ ...current, trip: initialTrip }));
+        const travelerParty = initialTrip?.envelope.travelerParty;
+        if (!travelerParty) {
+            setBilling(emptyPersonPickerValue);
+            setTravelers([]);
+            setNotes("");
+            setVoucher(emptyVoucherPickerValue);
+            setCreateAsDraft(false);
+            setPaymentCurrency(defaultPaymentCurrency);
+            return;
+        }
+        setBilling(hydrateBilling(travelerParty));
+        setTravelers(hydrateTravelers(travelerParty));
+        setNotes(initialTrip.envelope.description ?? "");
+        setVoucher(hydrateVoucher(travelerParty));
+        const constraints = initialTrip.envelope.constraints;
+        setCreateAsDraft(booleanFromRecord(constraints, "createAsDraft"));
+        setPaymentCurrency(stringFromRecord(constraints, "paymentCurrency") ||
+            initialTrip.envelope.aggregateCurrency ||
+            defaultPaymentCurrency);
+    }, [initialTrip]);
+    function showError(error) {
+        setState((current) => ({ ...current, error: apiError(error, t), message: null }));
+    }
+    async function ensureTrip() {
+        if (state.trip)
+            return state.trip;
+        assertTripCreationRequirements({ billing, travelers, payerName, payerEmail }, t);
+        const created = await createTrip(client, {
+            description: notes || undefined,
+            travelerParty: {
+                billing: serializeBilling(billing, payerName, payerEmail),
+                travelers,
+                voucher: voucher.picked
+                    ? {
+                        id: voucher.picked.id,
+                        code: voucher.picked.code,
+                        currency: voucher.picked.currency,
+                        remainingAmountCents: voucher.picked.remainingAmountCents,
+                    }
+                    : null,
+            },
+            constraints: {
+                channel: "admin-composer",
+                compositionMode: "cross-vertical",
+                createAsDraft,
+                paymentCurrency,
+            },
+        });
+        setState((current) => ({ ...current, trip: created }));
+        return created;
+    }
+    const commitMutation = useMutation({
+        mutationFn: async (component) => {
+            const currentTrip = await ensureTrip();
+            const input = pendingToAddInput(component, {
+                billing,
+                travelers,
+                payerName,
+                payerEmail,
+                paymentCurrency,
+            }, t);
+            if (!input)
+                throw new Error(t.errors.componentNotReady);
+            await addTripComponent(client, currentTrip.envelope.id, input);
+            return priceTrip(client, currentTrip.envelope.id, {
+                scope: { locale: "en-US", audience: "staff", market: "default", currency: paymentCurrency },
+            });
+        },
+        onSuccess: (result, component) => {
+            setPending((current) => current.filter((p) => p.localId !== component.localId));
+            setState({
+                trip: { envelope: result.envelope, components: result.components },
+                message: t.statusMessages.componentAddedAndPriced,
+                error: failuresToString(result.failures, t),
+            });
+            setCancellationPreview(null);
+            setCommittingLocalId(null);
+        },
+        onError: (error, component) => {
+            const message = apiError(error, t);
+            setPending((current) => current.map((p) => (p.localId === component.localId ? { ...p, commitError: message } : p)));
+            setCommittingLocalId(null);
+        },
+    });
+    const reserveMutation = useMutation({
+        mutationFn: async () => {
+            if (!envelopeId)
+                throw new Error(t.errors.priceTripFirst);
+            assertTripCreationRequirements({ billing, travelers, payerName, payerEmail }, t);
+            const reserved = await reserveTrip(client, envelopeId, {
+                idempotencyKey: `admin-reserve-${envelopeId}`,
+                refreshScope: {
+                    locale: "en-US",
+                    audience: "staff",
+                    market: "default",
+                    currency: paymentCurrency,
+                },
+            });
+            if (reserved.failures.length > 0)
+                return { reserved, checkout: null };
+            const checkout = await startTripCheckout(client, envelopeId, {
+                idempotencyKey: `admin-checkout-${envelopeId}`,
+                intent: "card",
+                request: { initiatedBy: "admin-trip-composer", collectionCurrency: paymentCurrency },
+            });
+            return { reserved, checkout };
+        },
+        onSuccess: ({ reserved, checkout }) => {
+            const trip = checkout
+                ? { envelope: checkout.envelope, components: checkout.components }
+                : { envelope: reserved.envelope, components: reserved.components };
+            setState({
+                trip,
+                message: checkout?.target.paymentSessionId
+                    ? t.statusMessages.tripReservedWithLink
+                    : t.statusMessages.tripReserved,
+                error: failuresToString(reserved.failures, t),
+            });
+            // Keep operators in the trip aggregate after reserve; individual booking
+            // links remain available from each component card.
+            if (reserved.failures.length === 0) {
+                navigateTo("trip.detail", { tripId: reserved.envelope.id });
+            }
+        },
+        onError: (error) => showError(error),
+    });
+    const removeComponentMutation = useMutation({
+        mutationFn: async (componentId) => {
+            if (!envelopeId)
+                throw new Error(t.errors.noTrip);
+            await removeTripComponent(client, componentId);
+            return getTrip(client, envelopeId);
+        },
+        onMutate: (componentId) => {
+            const previousTrip = state.trip;
+            // Optimistically mark the component as removed so the card disappears
+            // immediately. Aggregate totals re-derive from the visible components.
+            if (previousTrip) {
+                setState((current) => ({
+                    ...current,
+                    trip: {
+                        ...previousTrip,
+                        components: previousTrip.components.map((component) => component.id === componentId
+                            ? { ...component, status: "removed" }
+                            : component),
+                    },
+                }));
+            }
+            setSelectedCancellationIds((current) => current.filter((id) => id !== componentId));
+            setCancellationPreview(null);
+            return { previousTrip };
+        },
+        onSuccess: (updatedTrip) => {
+            setState({ trip: updatedTrip, message: t.statusMessages.componentRemoved, error: null });
+        },
+        onError: (error, _componentId, context) => {
+            if (context?.previousTrip) {
+                setState((current) => ({ ...current, trip: context.previousTrip }));
+            }
+            showError(error);
+        },
+    });
+    const updateComponentSetupMutation = useMutation({
+        mutationFn: async ({ componentId, metadata, }) => updateTripComponent(client, componentId, { metadata }),
+        onMutate: ({ componentId, metadata }) => {
+            const previousTrip = state.trip;
+            if (previousTrip) {
+                setState((current) => ({
+                    ...current,
+                    trip: {
+                        ...previousTrip,
+                        components: previousTrip.components.map((component) => component.id === componentId ? { ...component, metadata } : component),
+                    },
+                }));
+            }
+            return { previousTrip };
+        },
+        onSuccess: (updatedComponent) => {
+            setState((current) => current.trip
+                ? {
+                    ...current,
+                    trip: {
+                        ...current.trip,
+                        components: current.trip.components.map((component) => component.id === updatedComponent.id ? updatedComponent : component),
+                    },
+                }
+                : current);
+        },
+        onError: (error, _input, context) => {
+            if (context?.previousTrip) {
+                setState((current) => ({ ...current, trip: context.previousTrip }));
+            }
+            showError(error);
+        },
+    });
+    const cancellationMutation = useMutation({
+        mutationFn: async () => {
+            if (!envelopeId)
+                throw new Error(t.errors.noTripToCancel);
+            return previewTripCancellation(client, envelopeId, {
+                componentIds: selectedCancellationIds,
+                reason: cancellationReason,
+                request: { initiatedBy: "admin" },
+            });
+        },
+        onSuccess: (result) => {
+            setCancellationPreview({
+                refund: result.preview.estimatedRefundAmountCents,
+                penalty: result.preview.estimatedPenaltyAmountCents,
+                staffActionRequired: result.preview.staffActionRequired,
+                warnings: result.preview.warnings,
+            });
+            setState({
+                trip: { envelope: result.envelope, components: result.components },
+                message: t.statusMessages.cancellationPreviewReady,
+                error: null,
+            });
+        },
+        onError: (error) => showError(error),
+    });
+    const isBusy = commitMutation.isPending ||
+        reserveMutation.isPending ||
+        cancellationMutation.isPending ||
+        removeComponentMutation.isPending ||
+        updateComponentSetupMutation.isPending;
+    function handleAddVertical(kind) {
+        setPending((current) => [...current, newPendingComponent(kind)]);
+    }
+    function updatePending(next) {
+        setPending((current) => current.map((p) => (p.localId === next.localId ? next : p)));
+    }
+    function removePending(localId) {
+        setPending((current) => current.filter((p) => p.localId !== localId));
+    }
+    function toggleCancellationSelection(componentId, checked) {
+        setCancellationPreview(null);
+        setSelectedCancellationIds((current) => checked
+            ? [...new Set([...current, componentId])]
+            : current.filter((id) => id !== componentId));
+    }
+    function updateComponentBookingSetup(component, setup) {
+        const metadata = metadataWithComponentBookingSetup(component, setup);
+        updateComponentSetupMutation.mutate({ componentId: component.id, metadata });
+    }
+    function commitPending(component) {
+        const overlap = findOverlappingComponent(component, components);
+        if (overlap) {
+            setPending((current) => current.map((p) => p.localId === component.localId
+                ? {
+                    ...p,
+                    commitError: `These dates overlap with "${componentTitleFor(overlap)}". Adjust the schedule before adding to the trip.`,
+                }
+                : p));
+            return;
+        }
+        setCommittingLocalId(component.localId);
+        setPending((current) => current.map((p) => (p.localId === component.localId ? { ...p, commitError: null } : p)));
+        commitMutation.mutate(component);
+    }
+    return (_jsxs("main", { className: "mx-auto flex w-full max-w-screen-2xl flex-col gap-6 px-4 py-6 sm:px-6 lg:px-8", children: [_jsxs("header", { className: "flex flex-col gap-1", children: [_jsx("h1", { className: "font-semibold text-2xl tracking-tight", children: t.heading }), _jsx("p", { className: "text-muted-foreground text-sm", children: t.subheading })] }), state.error ? (_jsx(StatusAlert, { title: t.requestFailed, message: state.error, tone: "error" })) : null, _jsxs("div", { className: "grid min-h-0 flex-1 gap-6 lg:grid-cols-12", children: [_jsxs("div", { className: "flex min-w-0 flex-col gap-4 lg:col-span-8", children: [_jsx(Section, { title: t.billingSectionTitle, children: _jsx(PersonPickerSection, { value: billing, onChange: setBilling }) }), _jsx(TripTravelersSection, { value: travelers, onChange: setTravelers, billingPersonId: billing.mode === "existing" ? billing.personId || null : null }), _jsxs("div", { className: "flex flex-col gap-3", children: [_jsx("h2", { className: "font-medium text-base", children: t.itinerarySectionTitle }), components.length === 0 && pending.length === 0 ? _jsx(ComponentsEmpty, {}) : null, components.map((component, index) => (_jsx(CommittedComponentCard, { component: component, index: index, selectable: trapReserved, selected: selectedCancellationIds.includes(component.id), onSelectedChange: (checked) => toggleCancellationSelection(component.id, checked), onRemove: trapReserved ? undefined : () => removeComponentMutation.mutate(component.id), removePending: removeComponentMutation.isPending &&
+                                            removeComponentMutation.variables === component.id, bookingSetupEditable: !trapReserved, bookingSetupSaving: updateComponentSetupMutation.isPending &&
+                                            updateComponentSetupMutation.variables?.componentId === component.id, onBookingSetupChange: updateComponentBookingSetup }, component.id))), pending.map((entry) => (_jsx(PendingComponentCard, { pending: entry, onChange: updatePending, onRemove: () => removePending(entry.localId), onCommit: () => commitPending(entry), committing: committingLocalId === entry.localId && commitMutation.isPending, travelers: travelers }, entry.localId))), _jsx(AddComponentMenu, { onAdd: handleAddVertical, disabled: isBusy })] }), trapReserved && selectedCount > 0 ? (_jsxs(Section, { title: formatMessage(selectedCount === 1
+                                    ? t.cancellation.sectionTitleSingular
+                                    : t.cancellation.sectionTitlePlural, { count: selectedCount }), description: t.cancellation.sectionDescription, action: _jsx(Button, { variant: "ghost", size: "sm", onClick: () => {
+                                        setSelectedCancellationIds([]);
+                                        setCancellationPreview(null);
+                                    }, children: t.cancellation.clearSelection }), children: [_jsx(Field, { label: t.cancellation.reasonLabel, children: _jsx(Textarea, { rows: 2, value: cancellationReason, onChange: (event) => setCancellationReason(event.target.value) }) }), _jsxs(Button, { variant: "outline", onClick: () => cancellationMutation.mutate(), disabled: isBusy || !envelopeId, children: [cancellationMutation.isPending ? (_jsx(Loader2, { className: "size-4 animate-spin" })) : (_jsx(AlertTriangle, { className: "size-4" })), t.cancellation.previewButton] }), cancellationPreview ? (_jsxs("div", { className: "space-y-1 rounded-md border bg-muted/30 p-3 text-sm", children: [_jsx(CancellationRow, { label: t.cancellation.estimatedRefund, value: formatMoney(cancellationPreview.refund, paymentCurrency) }), _jsx(CancellationRow, { label: t.cancellation.estimatedPenalty, value: formatMoney(cancellationPreview.penalty, paymentCurrency) }), _jsx(CancellationRow, { label: t.cancellation.staffAction, value: cancellationPreview.staffActionRequired
+                                                    ? t.cancellation.staffActionRequired
+                                                    : t.cancellation.staffActionNotRequired }), cancellationPreview.warnings.length > 0 ? (_jsx("p", { className: "text-amber-600 text-xs", children: cancellationPreview.warnings.join(", ") })) : null] })) : null] })) : null, _jsx(Section, { title: t.internalNotesSectionTitle, description: t.internalNotesSectionDescription, children: _jsx(Field, { label: t.internalNotesLabel, children: _jsx(Textarea, { rows: 3, value: notes, onChange: (event) => setNotes(event.target.value), placeholder: t.internalNotesPlaceholder }) }) }), _jsx(Section, { title: t.paymentSectionTitle, children: _jsx(Field, { label: t.paymentCurrencyLabel, children: _jsx(CurrencyCombobox, { value: paymentCurrency, onChange: (value) => setPaymentCurrency(value ?? defaultPaymentCurrency) }) }) }), _jsx(Section, { title: t.onReserveSectionTitle, description: t.onReserveSectionDescription, children: _jsx(CheckboxRow, { id: "composer-create-as-draft", checked: createAsDraft, onCheckedChange: setCreateAsDraft, label: t.startInDraftLabel, hint: t.startInDraftHint }) }), _jsx(PrimaryAction, { status: trip?.envelope.status, componentCount: components.length, isBusy: isBusy, pricePending: commitMutation.isPending, reservePending: reserveMutation.isPending, onReserve: () => reserveMutation.mutate() })] }), _jsx("aside", { className: "flex flex-col gap-4 lg:col-span-4", children: _jsx(TripPreviewRail, { trip: trip, pendingCount: pending.length, travelers: travelers, billing: billing, billingPersonId: billing.mode === "existing" ? billing.personId || null : null, voucher: voucher, onVoucherChange: setVoucher, paymentCurrency: paymentCurrency }) })] })] }));
+}
+function CheckboxRow({ id, checked, onCheckedChange, label, hint, }) {
+    return (_jsxs("div", { className: "flex items-start gap-2 text-sm", children: [_jsx(Checkbox, { id: id, checked: checked, onCheckedChange: (value) => onCheckedChange(value === true), className: "mt-0.5" }), _jsxs("div", { className: "flex flex-col gap-1", children: [_jsx(Label, { htmlFor: id, className: "cursor-pointer text-sm", children: label }), hint ? _jsx("p", { className: "text-muted-foreground text-xs", children: hint }) : null] })] }));
+}
+function CancellationRow({ label, value }) {
+    return (_jsxs("div", { className: "flex items-center justify-between", children: [_jsx("span", { className: "text-muted-foreground", children: label }), _jsx("span", { children: value })] }));
+}
+function formatMoney(amountCents, currency) {
+    if (amountCents == null)
+        return "-";
+    return (amountCents / 100).toLocaleString(undefined, { style: "currency", currency });
+}
+function metadataWithComponentBookingSetup(component, setup) {
+    const metadata = { ...(readRecord(component.metadata) ?? {}) };
+    const bookingDraft = { ...(readRecord(metadata.bookingDraftV1) ?? {}) };
+    const documentGeneration = {
+        contractDocument: setup.generateContractDocument,
+        invoiceDocument: setup.generateInvoiceDocument,
+    };
+    metadata.bookingSetup = {
+        paymentSchedule: setup.paymentSchedule,
+        documentGeneration,
+    };
+    metadata.bookingDraftV1 = {
+        ...bookingDraft,
+        paymentSchedules: paymentScheduleToRows(setup.paymentSchedule, component.componentCurrency || defaultPaymentCurrency, component.componentTotalAmountCents ?? null),
+        documentGeneration,
+    };
+    return metadata;
+}
+function paymentScheduleToRows(value, scheduleCurrency, totalAmountCents) {
+    if (value.mode === "full") {
+        const installment = value.installments[0];
+        if (!installment?.dueDate || totalAmountCents === null)
+            return [];
+        return [
+            {
+                scheduleType: "balance",
+                status: installment.alreadyPaid ? "paid" : "due",
+                dueDate: installment.dueDate,
+                currency: scheduleCurrency,
+                amountCents: totalAmountCents,
+                notes: paidScheduleNotes(installment.alreadyPaid, installment.paymentDate, installment.paymentMethod, installment.paymentReference),
+            },
+        ];
+    }
+    const rows = [];
+    for (const installment of value.installments) {
+        if (!installment.dueDate || installment.amountCents == null)
+            continue;
+        rows.push({
+            scheduleType: "installment",
+            status: installment.alreadyPaid ? "paid" : "due",
+            dueDate: installment.dueDate,
+            currency: scheduleCurrency,
+            amountCents: installment.amountCents,
+            notes: paidScheduleNotes(installment.alreadyPaid, installment.paymentDate, installment.paymentMethod, installment.paymentReference),
+        });
+    }
+    return rows;
+}
+// Returns a single-line audit note persisted on the booking's payment schedule
+// when the operator marks an installment as already-paid in the composer.
+// Operator-facing free text — kept terse and in English at the data layer so
+// the persisted note stays comparable across deploys / locales.
+function paidScheduleNotes(alreadyPaid, paymentDate, paymentMethod, paymentReference) {
+    if (!alreadyPaid)
+        return null;
+    return [
+        // i18n-literal-ok: persisted audit note, see comment above.
+        "Marked paid in trip composer",
+        paymentDate ? `date: ${paymentDate}` : null,
+        paymentMethod ? `method: ${paymentMethod}` : null,
+        paymentReference.trim() ? `reference: ${paymentReference.trim()}` : null,
+    ]
+        .filter(Boolean)
+        .join("; ");
+}
+function pendingToAddInput(pending, ctx, messages) {
+    const billingPayload = serializeBilling(ctx.billing, ctx.payerName, ctx.payerEmail);
+    const travelersPayload = serializeTravelersForBookingDraft(ctx.travelers, messages);
+    const paxAdult = countAdults(ctx.travelers) || 1;
+    if (pending.kind === "product" || pending.kind === "stay") {
+        if (!pending.catalogEntityId || !pending.catalogSourceKind)
+            return null;
+        const vertical = pending.kind === "stay" ? "accommodations" : "products";
+        const draft = pending.bookingDraft;
+        const configure = {
+            ...(draft?.configure ?? {}),
+            pax: {
+                ...(draft?.configure.pax ?? {}),
+                adult: paxAdult,
+            },
+        };
+        if (pending.startsAt) {
+            configure.departureDate = pending.startsAt.slice(0, 10);
+        }
+        if (pending.startsAt && pending.endsAt) {
+            configure.dateRange = {
+                checkIn: pending.startsAt.slice(0, 10),
+                checkOut: pending.endsAt.slice(0, 10),
+            };
+        }
+        return {
+            kind: "catalog_booking",
+            catalogRef: {
+                entityModule: vertical,
+                entityId: pending.catalogEntityId,
+                sourceKind: pending.catalogSourceKind,
+                ...(pending.catalogSourceConnectionId
+                    ? { sourceConnectionId: pending.catalogSourceConnectionId }
+                    : {}),
+                ...(pending.catalogSourceRef ? { sourceRef: pending.catalogSourceRef } : {}),
+            },
+            metadata: {
+                scheduledStartsAt: pending.startsAt || null,
+                scheduledEndsAt: pending.endsAt || null,
+                catalogItem: {
+                    vertical,
+                    name: pending.catalogEntityName,
+                    thumbnailUrl: pending.catalogThumbnailUrl,
+                    sourceKind: pending.catalogSourceKind,
+                    sourceConnectionId: pending.catalogSourceConnectionId,
+                    sourceRef: pending.catalogSourceRef,
+                },
+                bookingDraftV1: {
+                    ...(draft ?? {}),
+                    entity: draft?.entity ?? {
+                        module: vertical,
+                        id: pending.catalogEntityId,
+                        sourceKind: pending.catalogSourceKind,
+                        ...(pending.catalogSourceConnectionId
+                            ? { sourceConnectionId: pending.catalogSourceConnectionId }
+                            : {}),
+                        ...(pending.catalogSourceRef ? { sourceRef: pending.catalogSourceRef } : {}),
+                    },
+                    configure,
+                    billing: billingPayload,
+                    travelers: travelersPayload,
+                    payment: draft?.payment ?? { intent: "hold" },
+                },
+            },
+        };
+    }
+    if (pending.kind === "flight") {
+        const pricing = flightPricingFromPending(pending);
+        const firstItinerary = pending.selectedOffer?.itineraries[0];
+        const lastItinerary = pending.selectedOffer?.itineraries[pending.selectedOffer.itineraries.length - 1];
+        const firstSegment = firstItinerary?.segments[0];
+        const lastSegment = lastItinerary?.segments[lastItinerary.segments.length - 1];
+        return {
+            kind: "flight_placeholder",
+            description: undefined,
+            estimatedPricing: {
+                currency: pricing.currency,
+                subtotalAmountCents: pricing.subtotalAmountCents,
+                taxAmountCents: pricing.taxAmountCents,
+                totalAmountCents: pricing.totalAmountCents,
+            },
+            metadata: {
+                scheduledStartsAt: firstSegment?.departure.at ?? pending.departDate ?? null,
+                scheduledEndsAt: lastSegment?.arrival.at ?? pending.returnDate ?? null,
+                flightDraft: {
+                    origin: pending.origin,
+                    destination: pending.destination,
+                    departDate: pending.departDate,
+                    returnDate: pending.returnDate || null,
+                    tripType: pending.tripType,
+                    cabin: pending.cabin,
+                    offerId: pending.selectedOffer?.offerId ?? null,
+                    source: pending.selectedOffer?.source ?? null,
+                    selectedOffer: pending.selectedOffer,
+                    ancillaries: {
+                        fareBundle: pending.fareBundlePicks,
+                        baggage: pending.baggagePicks,
+                        assistance: pending.assistancePicks,
+                        extras: pending.extrasPicks,
+                    },
+                    pricing,
+                },
+            },
+        };
+    }
+    if (pending.kind === "cruise") {
+        const amountCents = parseAmountCents(pending.estimatedAmount);
+        return {
+            kind: "manual_placeholder",
+            description: pending.description || undefined,
+            estimatedPricing: pricingFromAmount(amountCents, ctx.paymentCurrency),
+            metadata: {
+                scheduledStartsAt: pending.embarkationDate || null,
+                scheduledEndsAt: null,
+                cruiseDraft: {
+                    cabin: pending.cabin || null,
+                    embarkationDate: pending.embarkationDate || null,
+                },
+            },
+        };
+    }
+    const totals = computePlaceholderTotals(pending.subtotalCents, pending.taxRatePct);
+    return {
+        kind: "manual_placeholder",
+        description: pending.description || undefined,
+        estimatedPricing: {
+            currency: pending.currency,
+            subtotalAmountCents: totals.subtotal,
+            taxAmountCents: totals.tax,
+            totalAmountCents: totals.total,
+        },
+        metadata: {
+            scheduledStartsAt: pending.startsAt || null,
+            scheduledEndsAt: pending.endsAt || null,
+            manualService: {
+                name: pending.name,
+            },
+            taxRatePct: pending.taxRatePct || null,
+            template: pending.kind,
+        },
+    };
+}
+function pricingFromAmount(amountCents, pricingCurrency) {
+    return {
+        currency: pricingCurrency,
+        subtotalAmountCents: amountCents,
+        taxAmountCents: 0,
+        totalAmountCents: amountCents,
+    };
+}
+function parseAmountCents(raw) {
+    const parsed = Number.parseFloat(raw || "0");
+    return Number.isFinite(parsed) && parsed > 0 ? Math.round(parsed * 100) : 0;
+}
+function countAdults(travelers) {
+    return travelers.filter((t) => t.role === "lead" || t.role === "adult").length;
+}
+function serializeBilling(billing, payerNameFallback, payerEmailFallback) {
+    if (billing.mode === "new") {
+        return {
+            buyerType: billing.billTo === "organization" ? "B2B" : "B2C",
+            contact: {
+                firstName: billing.newPerson.firstName.trim(),
+                lastName: billing.newPerson.lastName.trim(),
+                email: billing.newPerson.email.trim(),
+                phone: billing.newPerson.phone || undefined,
+            },
+            address: {},
+        };
+    }
+    // For an existing person we still need a contact block — the booking engine
+    // validates `billing.contact` even when an id is present. Names/emails come
+    // from the resolved person (payerName / payerEmail).
+    const [firstName, ...rest] = (payerNameFallback ?? "").trim().split(/\s+/);
+    return {
+        buyerType: billing.billTo === "organization" ? "B2B" : "B2C",
+        ...(billing.personId ? { personId: billing.personId } : {}),
+        ...(billing.organizationId ? { organizationId: billing.organizationId } : {}),
+        contact: {
+            firstName: firstName || "",
+            lastName: rest.join(" ") || "",
+            email: payerEmailFallback || "",
+        },
+        address: {},
+    };
+}
+function assertTripCreationRequirements(ctx, messages) {
+    const errors = [];
+    const { errors: errorMessages } = messages;
+    if (ctx.billing.mode === "new") {
+        if (!ctx.billing.newPerson.firstName.trim() || !ctx.billing.newPerson.lastName.trim()) {
+            errors.push(errorMessages.requirementBillingName);
+        }
+        if (!isRealTripEmail(ctx.billing.newPerson.email)) {
+            errors.push(errorMessages.requirementBillingEmail);
+        }
+    }
+    else {
+        const hasBillingRecord = ctx.billing.billTo === "organization"
+            ? Boolean(ctx.billing.organizationId)
+            : Boolean(ctx.billing.personId);
+        if (!hasBillingRecord)
+            errors.push(errorMessages.requirementBillingPersonOrOrg);
+        if (!ctx.payerName.trim())
+            errors.push(errorMessages.requirementBillingName);
+        if (!isRealTripEmail(ctx.payerEmail))
+            errors.push(errorMessages.requirementBillingEmail);
+    }
+    if (ctx.travelers.length === 0) {
+        errors.push(errorMessages.requirementAtLeastOneTraveler);
+    }
+    ctx.travelers.forEach((traveler, index) => {
+        if (!traveler.personId && (!traveler.firstName.trim() || !traveler.lastName.trim())) {
+            errors.push(formatMessage(errorMessages.requirementTravelerName, { position: index + 1 }));
+        }
+        if (traveler.email && !isRealTripEmail(traveler.email)) {
+            errors.push(formatMessage(errorMessages.requirementTravelerEmail, { position: index + 1 }));
+        }
+    });
+    if (errors.length > 0) {
+        throw new Error(formatMessage(errorMessages.completeRequirements, { fields: errors.join(", ") }));
+    }
+}
+function isRealTripEmail(value) {
+    const normalized = value?.trim().toLowerCase() ?? "";
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(normalized))
+        return false;
+    return !["noreply@example.com", "tbd@example.com", "traveler@example.com"].includes(normalized);
+}
+function hydrateBilling(travelerParty) {
+    const billing = readRecord(travelerParty.billing);
+    if (!billing)
+        return emptyPersonPickerValue;
+    const contact = readRecord(billing.contact);
+    const personId = stringFromRecord(billing, "personId") ?? "";
+    const organizationId = stringFromRecord(billing, "organizationId") ?? null;
+    const billTo = organizationId || stringFromRecord(billing, "buyerType") === "B2B" ? "organization" : "person";
+    if (personId || organizationId) {
+        return {
+            billTo,
+            mode: "existing",
+            personId,
+            organizationId,
+            newPerson: emptyPersonPickerValue.newPerson,
+        };
+    }
+    return {
+        billTo,
+        mode: "new",
+        personId: "",
+        organizationId,
+        newPerson: {
+            firstName: stringFromRecord(contact, "firstName") ?? "",
+            lastName: stringFromRecord(contact, "lastName") ?? "",
+            email: stringFromRecord(contact, "email") ?? "",
+            phone: stringFromRecord(contact, "phone") ?? "",
+        },
+    };
+}
+function hydrateTravelers(travelerParty) {
+    const travelers = travelerParty.travelers;
+    if (!Array.isArray(travelers))
+        return [];
+    return travelers.filter(readRecord).map((traveler, index) => ({
+        localId: stringFromRecord(traveler, "localId") ?? `tt_existing_${index}`,
+        personId: stringFromRecord(traveler, "personId") ?? null,
+        firstName: stringFromRecord(traveler, "firstName") ?? "",
+        lastName: stringFromRecord(traveler, "lastName") ?? "",
+        email: stringFromRecord(traveler, "email") ?? "",
+        dateOfBirth: stringFromRecord(traveler, "dateOfBirth") ?? null,
+        role: tripTravelerRoleFromStored(stringFromRecord(traveler, "role"), index),
+    }));
+}
+function hydrateVoucher(travelerParty) {
+    const voucher = readRecord(travelerParty.voucher);
+    if (!voucher)
+        return emptyVoucherPickerValue;
+    const id = stringFromRecord(voucher, "id");
+    const code = stringFromRecord(voucher, "code");
+    const currencyCode = stringFromRecord(voucher, "currency");
+    const remainingAmountCents = numberFromRecord(voucher, "remainingAmountCents");
+    if (!id || !code || !currencyCode || remainingAmountCents == null)
+        return emptyVoucherPickerValue;
+    return {
+        code,
+        picked: {
+            id,
+            code,
+            label: null,
+            currency: currencyCode,
+            remainingAmountCents,
+            expiresAt: null,
+        },
+        error: null,
+    };
+}
+function tripTravelerRoleFromStored(value, index) {
+    if (value === "lead" || value === "adult" || value === "child" || value === "infant") {
+        return value;
+    }
+    return index === 0 ? "lead" : "adult";
+}
+// Map our roster shape onto the catalog booking engine's `travelerEntryV1`:
+// drop empty/null fields it can't validate, translate `role` (lead/adult/...)
+// into `band` (adult/child/infant) + `isPrimary`.
+function serializeTravelersForBookingDraft(travelers, messages) {
+    return travelers.map((traveler) => {
+        const band = traveler.role === "child" ? "child" : traveler.role === "infant" ? "infant" : "adult";
+        const firstName = traveler.firstName.trim();
+        const lastName = traveler.lastName.trim();
+        const email = traveler.email.trim();
+        const dateOfBirth = traveler.dateOfBirth?.trim() || "";
+        const entry = {
+            firstName: firstName || messages.travelerFallbackName,
+            lastName: lastName || messages.travelerFallbackLastName,
+            band,
+        };
+        if (email)
+            entry.email = email;
+        if (dateOfBirth)
+            entry.dateOfBirth = dateOfBirth;
+        if (traveler.role === "lead")
+            entry.isPrimary = true;
+        return entry;
+    });
+}
+function failuresToString(failures, messages) {
+    if (!failures || failures.length === 0)
+        return null;
+    if (failures.some((failure) => failure.code === "price_changed")) {
+        return messages.failureMessages.priceChanged;
+    }
+    if (failures.some((failure) => failure.code === "expired")) {
+        return messages.failureMessages.expired;
+    }
+    if (failures.some((failure) => failure.code === "unavailable")) {
+        return messages.failureMessages.unavailable;
+    }
+    return failures.map((failure) => failure.reason).join(", ");
+}
+function apiError(error, messages) {
+    const candidate = error;
+    if (typeof candidate.message === "string")
+        return candidate.message;
+    return error instanceof Error ? error.message : messages.errors.requestFailed;
+}
+function derivePayerName(billing, person, messages) {
+    if (billing.mode === "new") {
+        const name = [billing.newPerson.firstName, billing.newPerson.lastName]
+            .filter((part) => part.trim().length > 0)
+            .join(" ")
+            .trim();
+        return name || billing.newPerson.email.trim() || messages.travelerFallbackName;
+    }
+    if (person) {
+        const name = [person.firstName, person.lastName]
+            .filter((part) => (part ?? "").trim().length > 0)
+            .join(" ")
+            .trim();
+        return name || (person.email ?? "") || messages.travelerFallbackName;
+    }
+    return messages.travelerFallbackName;
+}
+function derivePayerEmail(billing, person) {
+    if (billing.mode === "new") {
+        return billing.newPerson.email.trim();
+    }
+    return person?.email ?? "";
+}
+function readRecord(value) {
+    return isRecord(value) ? value : null;
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function stringFromRecord(record, key) {
+    const value = record?.[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function numberFromRecord(record, key) {
+    const value = record?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function booleanFromRecord(record, key) {
+    return record[key] === true;
+}