includio-cms 0.36.8 → 0.37.0

package/dist/booking/server/participants.js

@@ -0,0 +1,92 @@
+import { eq } from 'drizzle-orm';
+import { getBookingDb, requireBookingConfig } from './db.js';
+import { bookingItemsTable, bookingPersonsTable, bookingItemPersonsTable } from '../../db-postgres/schema/booking/index.js';
+import { resolveParticipantFields } from '../config.js';
+import { canFill, validateAgainstSchema } from '../participant-fields/index.js';
+import { resolveEntry } from '../../core/server/entries/operations/resolveEntry.js';
+/** Thrown when a write violates field types/min/max/option. Missing required is soft. */
+export class ParticipantValidationError extends Error {
+    errors;
+    constructor(errors) {
+        super(errors.map((e) => e.message).join('; '));
+        this.errors = errors;
+        this.name = 'ParticipantValidationError';
+    }
+}
+/** Resolve the participant-field schema for a booking item's catalog entry. */
+export async function resolveItemSchema(tripRef) {
+    const cfg = requireBookingConfig();
+    if (typeof cfg.participantFields !== 'function' || !cfg.catalogCollection) {
+        return resolveParticipantFields(cfg, {});
+    }
+    const entry = await resolveEntry({ id: tripRef, status: 'published' });
+    return resolveParticipantFields(cfg, (entry ?? {}));
+}
+/** A field is identity (stored once on the person) when it carries an identity role. */
+function isIdentityField(f) {
+    return f.role === 'name' || f.role === 'birthDate';
+}
+/**
+ * Merge a partial patch into a person's assignment, scoped to fields the
+ * `scope` audience may fill. Identity fields (role name/birthDate) are written
+ * once to the person row (shared across trips); the rest to this trip's
+ * assignment. Validates types/min/max/option (hard reject); missing required is
+ * allowed (soft status, surfaced in the UI elsewhere).
+ *
+ * @param assignmentId - `booking_item_persons.id` (the person-on-this-trip row).
+ */
+export async function saveParticipantData(assignmentId, incoming, scope) {
+    const db = getBookingDb();
+    const [assignment] = await db
+        .select()
+        .from(bookingItemPersonsTable)
+        .where(eq(bookingItemPersonsTable.id, assignmentId));
+    if (!assignment)
+        throw new Error('Participant not found');
+    const [item] = await db
+        .select()
+        .from(bookingItemsTable)
+        .where(eq(bookingItemsTable.id, assignment.itemId));
+    if (!item)
+        throw new Error('Booking item not found');
+    const [person] = await db
+        .select()
+        .from(bookingPersonsTable)
+        .where(eq(bookingPersonsTable.id, assignment.personId));
+    if (!person)
+        throw new Error('Person not found');
+    const fields = await resolveItemSchema(item.tripRef);
+    const editable = new Set(fields.filter((f) => canFill(f, scope)).map((f) => f.key));
+    const identityKeys = new Set(fields.filter(isIdentityField).map((f) => f.key));
+    // Drop any key the audience is not allowed to write; split identity vs per-trip.
+    const identityPatch = {};
+    const tripPatch = {};
+    for (const [k, v] of Object.entries(incoming)) {
+        if (!editable.has(k))
+            continue;
+        if (identityKeys.has(k))
+            identityPatch[k] = v;
+        else
+            tripPatch[k] = v;
+    }
+    const mergedPerson = { ...person.data, ...identityPatch };
+    const mergedAssignment = { ...assignment.data, ...tripPatch };
+    // Validate the full combined record (identity + per-trip) against the schema.
+    const combined = { ...mergedPerson, ...mergedAssignment };
+    const hard = validateAgainstSchema(combined, fields).filter((e) => e.code !== 'required');
+    if (hard.length > 0) {
+        throw new ParticipantValidationError(hard.map((e) => ({ key: e.key, message: e.message })));
+    }
+    if (Object.keys(identityPatch).length > 0) {
+        await db
+            .update(bookingPersonsTable)
+            .set({ data: mergedPerson, updatedAt: new Date() })
+            .where(eq(bookingPersonsTable.id, person.id));
+    }
+    if (Object.keys(tripPatch).length > 0) {
+        await db
+            .update(bookingItemPersonsTable)
+            .set({ data: mergedAssignment, updatedAt: new Date() })
+            .where(eq(bookingItemPersonsTable.id, assignmentId));
+    }
+}

package/dist/booking/server/payments.d.ts

@@ -0,0 +1,34 @@
+import type { PaymentEvent } from '../../shop/types.js';
+import type { PaymentKind } from '../ledger.js';
+/**
+ * Create the deposit payment for a freshly-created booking: ask the first
+ * configured adapter for a payment (charging only the deposit amount via an
+ * `OrderRef` with `totalGross = depositAmount`), and record a pending ledger row
+ * keyed by the provider ref. Returns the redirect for the storefront.
+ */
+export declare function createDepositPayment(bookingId: string): Promise<{
+    redirectUrl: string | null;
+    status: 'redirect' | 'manual' | 'error';
+    providerRef: string | null;
+}>;
+/**
+ * Apply a provider webhook event to the ledger, idempotently. Locks the payment
+ * row (and its booking) `FOR UPDATE` so a concurrent duplicate webhook can't
+ * double-apply: the second caller sees a settled row and no-ops. Recomputes the
+ * booking totals + derived status and clears the draft hold on first deposit.
+ */
+export declare function applyWebhookPayment(event: PaymentEvent): Promise<{
+    applied: boolean;
+    bookingId: string | null;
+    kind: PaymentKind | null;
+}>;
+/**
+ * Generate an installment/balance payment link for an arbitrary amount (staff or
+ * portal). Records a pending ledger row keyed by the provider ref; the webhook
+ * settles it later.
+ */
+export declare function createInstallmentPayment(bookingId: string, amount: number): Promise<{
+    paymentLink: string | null;
+}>;
+/** Record a manual cash payment (staff). Settles immediately and recomputes status. */
+export declare function recordCash(bookingId: string, amount: number): Promise<void>;

package/dist/booking/server/payments.js

@@ -0,0 +1,207 @@
+import { eq } from 'drizzle-orm';
+import { randomUUID } from 'node:crypto';
+import { getBookingDb, requireBookingConfig } from './db.js';
+import { bookingsTable, bookingPaymentsTable } from '../../db-postgres/schema/booking/index.js';
+import { applyPaymentEvent } from '../webhook-logic.js';
+import { deriveStatus } from '../state-machine.js';
+import { netOf } from '../totals.js';
+import { buildPaymentContext } from '../payment-context.js';
+/**
+ * Create the deposit payment for a freshly-created booking: ask the first
+ * configured adapter for a payment (charging only the deposit amount via an
+ * `OrderRef` with `totalGross = depositAmount`), and record a pending ledger row
+ * keyed by the provider ref. Returns the redirect for the storefront.
+ */
+export async function createDepositPayment(bookingId) {
+    const config = requireBookingConfig();
+    const db = getBookingDb();
+    const [booking] = await db.select().from(bookingsTable).where(eq(bookingsTable.id, bookingId));
+    if (!booking)
+        throw new Error(`Booking ${bookingId} not found`);
+    const adapter = config.payment[0];
+    if (!adapter || config.depositAmount <= 0) {
+        return { redirectUrl: null, status: 'manual', providerRef: null };
+    }
+    const ref = {
+        id: booking.id,
+        number: booking.number,
+        totalGross: config.depositAmount,
+        currency: config.currency,
+        customerEmail: String(booking.customer.email ?? '')
+    };
+    const baseCtx = buildPaymentContext({
+        accessToken: booking.accessToken,
+        language: booking.language,
+        customer: booking.customer,
+        portalUrlTemplate: config.portalUrlTemplate
+    });
+    const ctx = {
+        ...baseCtx,
+        // Deposit lands on the checkout return page (e.g. thank-you) when configured;
+        // otherwise falls back to the portal like other payments.
+        continueUrl: config.checkoutReturnUrl ?? baseCtx.continueUrl,
+        // PayU's extOrderId must be unique per POS — a booking pays more than once
+        // (deposit + balance), so vary it per attempt while keeping the number visible.
+        externalId: `${booking.number}-${randomUUID().slice(0, 8)}`
+    };
+    const result = await adapter.createPayment(ref, ctx);
+    await db.insert(bookingPaymentsTable).values({
+        bookingId: booking.id,
+        kind: 'deposit',
+        amount: config.depositAmount,
+        status: 'pending',
+        providerRef: result.providerRef ?? null,
+        paymentLink: result.redirectUrl ?? null,
+        createdBy: 'system'
+    });
+    return {
+        redirectUrl: result.redirectUrl ?? null,
+        status: result.status,
+        providerRef: result.providerRef ?? null
+    };
+}
+/**
+ * Apply a provider webhook event to the ledger, idempotently. Locks the payment
+ * row (and its booking) `FOR UPDATE` so a concurrent duplicate webhook can't
+ * double-apply: the second caller sees a settled row and no-ops. Recomputes the
+ * booking totals + derived status and clears the draft hold on first deposit.
+ */
+export async function applyWebhookPayment(event) {
+    const config = requireBookingConfig();
+    const db = getBookingDb();
+    if (!event.providerRef)
+        return { applied: false, bookingId: null, kind: null };
+    return db.transaction(async (tx) => {
+        const [payment] = await tx
+            .select()
+            .from(bookingPaymentsTable)
+            .where(eq(bookingPaymentsTable.providerRef, event.providerRef))
+            .for('update');
+        if (!payment)
+            return { applied: false, bookingId: null, kind: null };
+        const [booking] = await tx
+            .select()
+            .from(bookingsTable)
+            .where(eq(bookingsTable.id, payment.bookingId))
+            .for('update');
+        if (!booking)
+            return { applied: false, bookingId: null, kind: null };
+        const others = (await tx
+            .select()
+            .from(bookingPaymentsTable)
+            .where(eq(bookingPaymentsTable.bookingId, booking.id)))
+            .filter((p) => p.id !== payment.id)
+            .map((p) => ({ amount: p.amount, status: p.status, kind: p.kind }));
+        const r = applyPaymentEvent({
+            event,
+            payment: { status: payment.status, amount: payment.amount },
+            otherPayments: others,
+            gross: netOf(booking.totals),
+            depositRequired: config.depositAmount,
+            currentStatus: booking.status
+        });
+        if (r.alreadyApplied)
+            return { applied: false, bookingId: booking.id, kind: payment.kind };
+        await tx
+            .update(bookingPaymentsTable)
+            .set({
+            status: r.newPaymentStatus,
+            paidAt: r.newPaymentStatus === 'paid' ? new Date() : null,
+            updatedAt: new Date()
+        })
+            .where(eq(bookingPaymentsTable.id, payment.id));
+        await tx
+            .update(bookingsTable)
+            .set({
+            status: r.newStatus,
+            totals: {
+                ...booking.totals,
+                paid: r.newTotalsPaid,
+                balance: Math.max(0, netOf(booking.totals) - r.newTotalsPaid)
+            },
+            holdExpiresAt: r.clearHold ? null : booking.holdExpiresAt,
+            updatedAt: new Date()
+        })
+            .where(eq(bookingsTable.id, booking.id));
+        return { applied: r.newPaymentStatus === 'paid', bookingId: booking.id, kind: payment.kind };
+    });
+}
+/**
+ * Generate an installment/balance payment link for an arbitrary amount (staff or
+ * portal). Records a pending ledger row keyed by the provider ref; the webhook
+ * settles it later.
+ */
+export async function createInstallmentPayment(bookingId, amount) {
+    const config = requireBookingConfig();
+    const db = getBookingDb();
+    const [booking] = await db.select().from(bookingsTable).where(eq(bookingsTable.id, bookingId));
+    if (!booking)
+        throw new Error('Booking not found');
+    const adapter = config.payment[0];
+    if (!adapter)
+        throw new Error('No payment adapter configured');
+    const ctx = {
+        ...buildPaymentContext({
+            accessToken: booking.accessToken,
+            language: booking.language,
+            customer: booking.customer,
+            portalUrlTemplate: config.portalUrlTemplate
+        }),
+        // PayU's extOrderId must be unique per POS — a booking pays more than once
+        // (deposit + balance), so vary it per attempt while keeping the number visible.
+        externalId: `${booking.number}-${randomUUID().slice(0, 8)}`
+    };
+    const result = await adapter.createPayment({
+        id: booking.id,
+        number: booking.number,
+        totalGross: amount,
+        currency: config.currency,
+        customerEmail: String(booking.customer.email ?? '')
+    }, ctx);
+    await db.insert(bookingPaymentsTable).values({
+        bookingId,
+        kind: 'installment',
+        amount,
+        status: 'pending',
+        providerRef: result.providerRef ?? null,
+        paymentLink: result.redirectUrl ?? null,
+        createdBy: 'staff'
+    });
+    return { paymentLink: result.redirectUrl ?? null };
+}
+/** Record a manual cash payment (staff). Settles immediately and recomputes status. */
+export async function recordCash(bookingId, amount) {
+    const config = requireBookingConfig();
+    const db = getBookingDb();
+    await db.transaction(async (tx) => {
+        const [b] = await tx
+            .select()
+            .from(bookingsTable)
+            .where(eq(bookingsTable.id, bookingId))
+            .for('update');
+        if (!b)
+            throw new Error('Booking not found');
+        await tx.insert(bookingPaymentsTable).values({
+            bookingId,
+            kind: 'cash',
+            amount,
+            status: 'paid',
+            createdBy: 'staff',
+            paidAt: new Date()
+        });
+        const paid = b.totals.paid + amount;
+        await tx
+            .update(bookingsTable)
+            .set({
+            totals: { ...b.totals, paid, balance: Math.max(0, netOf(b.totals) - paid) },
+            status: deriveStatus({
+                gross: netOf(b.totals),
+                paid,
+                depositRequired: config.depositAmount,
+                current: b.status
+            }),
+            updatedAt: new Date()
+        })
+            .where(eq(bookingsTable.id, bookingId));
+    });
+}

package/dist/booking/server/portal-session.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Bezstanowa sesja portalu (2. czynnik: telefon) + normalizacja numeru.
+ * Czyste funkcje — bez dostępu do zegara/env (wstrzykiwane), testowalne wprost.
+ * Sesja = podpisane HMAC cookie `"<expSec>.<hmac>"`; token w linku pozostaje
+ * 1. czynnikiem, numer telefonu = 2.
+ */
+/** Numer do porównania: same cyfry, ostatnie 9. */
+export declare function normalizePhone(raw: string): string;
+/** True gdy oba numery mają identyczną, pełną (9-cyfrową) końcówkę. */
+export declare function phonesMatch(a: string, b: string): boolean;
+/** Wartość cookie sesji portalu: `"<expSec>.<hmac>"`. */
+export declare function signSession(token: string, issuedAtSec: number, ttlSec: number, secret: string): string;
+/** Poprawny podpis dla tokenu i nie wygasł (`nowSec < exp`). Stałoczasowe porównanie. */
+export declare function verifySession(cookieValue: string, token: string, nowSec: number, secret: string): boolean;
+/** Nazwa cookie per-rezerwacja (hash tokenu — nie wycieka tokenu w nazwie). */
+export declare function portalCookieName(token: string): string;

package/dist/booking/server/portal-session.js

@@ -0,0 +1,42 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+/**
+ * Bezstanowa sesja portalu (2. czynnik: telefon) + normalizacja numeru.
+ * Czyste funkcje — bez dostępu do zegara/env (wstrzykiwane), testowalne wprost.
+ * Sesja = podpisane HMAC cookie `"<expSec>.<hmac>"`; token w linku pozostaje
+ * 1. czynnikiem, numer telefonu = 2.
+ */
+/** Numer do porównania: same cyfry, ostatnie 9. */
+export function normalizePhone(raw) {
+    return (raw ?? '').replace(/\D+/g, '').slice(-9);
+}
+/** True gdy oba numery mają identyczną, pełną (9-cyfrową) końcówkę. */
+export function phonesMatch(a, b) {
+    const na = normalizePhone(a);
+    return na.length === 9 && na === normalizePhone(b);
+}
+function hmac(secret, payload) {
+    return createHmac('sha256', secret).update(payload).digest('base64url');
+}
+/** Wartość cookie sesji portalu: `"<expSec>.<hmac>"`. */
+export function signSession(token, issuedAtSec, ttlSec, secret) {
+    const exp = issuedAtSec + ttlSec;
+    return `${exp}.${hmac(secret, `${token}.${exp}`)}`;
+}
+/** Poprawny podpis dla tokenu i nie wygasł (`nowSec < exp`). Stałoczasowe porównanie. */
+export function verifySession(cookieValue, token, nowSec, secret) {
+    if (!cookieValue || !secret)
+        return false;
+    const dot = cookieValue.indexOf('.');
+    if (dot <= 0)
+        return false;
+    const exp = Number(cookieValue.slice(0, dot));
+    if (!Number.isFinite(exp) || nowSec >= exp)
+        return false;
+    const sig = Buffer.from(cookieValue.slice(dot + 1));
+    const expected = Buffer.from(hmac(secret, `${token}.${exp}`));
+    return sig.length === expected.length && timingSafeEqual(sig, expected);
+}
+/** Nazwa cookie per-rezerwacja (hash tokenu — nie wycieka tokenu w nazwie). */
+export function portalCookieName(token) {
+    return 'pz_portal_' + createHmac('sha256', 'portal-cookie').update(token).digest('hex').slice(0, 16);
+}

package/dist/booking/server/portal.d.ts

@@ -0,0 +1,207 @@
+import { bookingsTable, bookingItemsTable } from '../../db-postgres/schema/booking/index.js';
+import { type PaymentEntry } from '../ledger.js';
+import { type BookingEditChanges } from './bookings.js';
+import { type FieldDef } from '../participant-fields/index.js';
+import { type FlatParticipant } from '../participants-view.js';
+type BookingRow = typeof bookingsTable.$inferSelect;
+type ItemRow = typeof bookingItemsTable.$inferSelect;
+/**
+ * Pure: shape a portal-safe DTO. Explicitly whitelists fields — `staffNotes`,
+ * `deletedBy`, and other internals never reach the customer.
+ */
+export declare function toPortalView(booking: BookingRow, items: ItemRow[], participants: FlatParticipant[], payments: Array<PaymentEntry & {
+    paidAt?: Date | null;
+}>, schemaByItem?: Record<string, FieldDef[]>): {
+    number: string;
+    status: import("../state-machine.js").BookingStatus;
+    currency: string;
+    customer: Record<string, unknown>;
+    totals: import("../../db-postgres/schema/booking/index.js").BookingTotals;
+    balanceDueAt: Date | null;
+    items: {
+        participantFields: FieldDef[];
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        bookingId: string;
+        tripRef: string;
+        departureDate: Date | null;
+        participantsCount: number;
+        unitPriceSnapshot: number;
+        subtotalSnapshot: number | null;
+        appliedDiscounts: import("../pricing.js").AppliedRule[];
+    }[];
+    participants: FlatParticipant[];
+    payments: {
+        amount: number;
+        status: import("../ledger.js").PaymentStatus;
+        kind: import("../ledger.js").PaymentKind | undefined;
+        paidAt: Date | null;
+    }[];
+    ledger: import("../ledger.js").LedgerSummary;
+};
+/** Resolve a booking by its unguessable portal access token (active only). */
+export declare function resolveByToken(token: string): Promise<BookingRow | null>;
+/** Drugi czynnik: zwraca booking gdy podany numer pasuje do `customer.phone`. */
+export declare function verifyPhone(token: string, phone: string): Promise<BookingRow | null>;
+export interface BookingStatusItem {
+    tripRef: string;
+    departureDate: string | null;
+    unitPrice: number;
+}
+export interface BookingStatus {
+    number: string;
+    status: string;
+    currency: string;
+    totals: {
+        gross: number;
+        paid: number;
+        balance: number;
+    };
+    items: BookingStatusItem[];
+    /** Payment link of a still-pending deposit (drives a „Zapłać zadatek" CTA), or null. */
+    depositLink: string | null;
+}
+export declare function bookingStatusByToken(token: string): Promise<BookingStatus | null>;
+/** Portal view: booking + items + participants + ledger (no staff data). */
+export declare function portalView(token: string): Promise<{
+    number: string;
+    status: import("../state-machine.js").BookingStatus;
+    currency: string;
+    customer: Record<string, unknown>;
+    totals: import("../../db-postgres/schema/booking/index.js").BookingTotals;
+    balanceDueAt: Date | null;
+    items: {
+        participantFields: FieldDef[];
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        bookingId: string;
+        tripRef: string;
+        departureDate: Date | null;
+        participantsCount: number;
+        unitPriceSnapshot: number;
+        subtotalSnapshot: number | null;
+        appliedDiscounts: import("../pricing.js").AppliedRule[];
+    }[];
+    participants: FlatParticipant[];
+    payments: {
+        amount: number;
+        status: import("../ledger.js").PaymentStatus;
+        kind: import("../ledger.js").PaymentKind | undefined;
+        paidAt: Date | null;
+    }[];
+    ledger: import("../ledger.js").LedgerSummary;
+} | null>;
+/** Portal self-service edit (actor:'portal' guards). Throws → handler maps to 409/400. */
+export declare function portalEdit(token: string, changes: BookingEditChanges): Promise<{
+    number: string;
+    status: import("../state-machine.js").BookingStatus;
+    currency: string;
+    customer: Record<string, unknown>;
+    totals: import("../../db-postgres/schema/booking/index.js").BookingTotals;
+    balanceDueAt: Date | null;
+    items: {
+        participantFields: FieldDef[];
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        bookingId: string;
+        tripRef: string;
+        departureDate: Date | null;
+        participantsCount: number;
+        unitPriceSnapshot: number;
+        subtotalSnapshot: number | null;
+        appliedDiscounts: import("../pricing.js").AppliedRule[];
+    }[];
+    participants: FlatParticipant[];
+    payments: {
+        amount: number;
+        status: import("../ledger.js").PaymentStatus;
+        kind: import("../ledger.js").PaymentKind | undefined;
+        paidAt: Date | null;
+    }[];
+    ledger: import("../ledger.js").LedgerSummary;
+} | null>;
+/** Portal: create an installment/balance payment link. */
+export declare function portalPay(token: string, amount: number): Promise<{
+    paymentLink: string | null;
+} | null>;
+/**
+ * Portal self-service: customer fills their own participant data. Verifies the
+ * assignment belongs to the token's booking (no cross-booking writes), then
+ * saves with `'customer'` scope (staff-only fields are dropped, not an error).
+ * Throws {@link ParticipantValidationError} on type/min/max/option violations.
+ *
+ * @param assignmentId - `booking_item_persons.id` (person-on-this-trip row).
+ */
+export declare function portalUpdateParticipant(token: string, assignmentId: string, data: Record<string, unknown>): Promise<{
+    number: string;
+    status: import("../state-machine.js").BookingStatus;
+    currency: string;
+    customer: Record<string, unknown>;
+    totals: import("../../db-postgres/schema/booking/index.js").BookingTotals;
+    balanceDueAt: Date | null;
+    items: {
+        participantFields: FieldDef[];
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        bookingId: string;
+        tripRef: string;
+        departureDate: Date | null;
+        participantsCount: number;
+        unitPriceSnapshot: number;
+        subtotalSnapshot: number | null;
+        appliedDiscounts: import("../pricing.js").AppliedRule[];
+    }[];
+    participants: FlatParticipant[];
+    payments: {
+        amount: number;
+        status: import("../ledger.js").PaymentStatus;
+        kind: import("../ledger.js").PaymentKind | undefined;
+        paidAt: Date | null;
+    }[];
+    ledger: import("../ledger.js").LedgerSummary;
+} | null>;
+/**
+ * Self-service dobieranie wycieczki: doczytaj obecny stan, scal z `additions`
+ * (tylko istniejące osoby), przelicz przez `editBooking` (full-replace → recompute
+ * tym samym silnikiem per-uczestnik co koszyk). Saldo rośnie; dopłata istniejącym
+ * flow. `assignments` w additions = lista `booking_persons.id`. Kotwica nowej
+ * pozycji (`departureDate`) = `customer.arrivalDate`.
+ */
+export declare function portalAddTrips(token: string, additions: Array<{
+    tripRef: string;
+    unitPrice: number;
+    assignments: string[];
+}>): Promise<{
+    number: string;
+    status: import("../state-machine.js").BookingStatus;
+    currency: string;
+    customer: Record<string, unknown>;
+    totals: import("../../db-postgres/schema/booking/index.js").BookingTotals;
+    balanceDueAt: Date | null;
+    items: {
+        participantFields: FieldDef[];
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        bookingId: string;
+        tripRef: string;
+        departureDate: Date | null;
+        participantsCount: number;
+        unitPriceSnapshot: number;
+        subtotalSnapshot: number | null;
+        appliedDiscounts: import("../pricing.js").AppliedRule[];
+    }[];
+    participants: FlatParticipant[];
+    payments: {
+        amount: number;
+        status: import("../ledger.js").PaymentStatus;
+        kind: import("../ledger.js").PaymentKind | undefined;
+        paidAt: Date | null;
+    }[];
+    ledger: import("../ledger.js").LedgerSummary;
+} | null>;
+export {};