@voyant-travel/finance 0.119.5

package/dist/service-supplier-payments.d.ts

@@ -0,0 +1,69 @@
+import type { CreateSupplierPaymentInput, FinanceServiceRuntime, PostgresJsDatabase, SupplierPaymentListQuery, UpdateSupplierPaymentInput } from "./service-shared.js";
+export declare const financeSupplierPaymentService: {
+    listSupplierPayments(db: PostgresJsDatabase, query: SupplierPaymentListQuery): Promise<{
+        data: {
+            id: string;
+            bookingId: string | null;
+            supplierId: string | null;
+            bookingSupplierStatusId: string | null;
+            supplierInvoiceId: string | null;
+            amountCents: number;
+            currency: string;
+            baseCurrency: string | null;
+            baseAmountCents: number | null;
+            fxRateSetId: string | null;
+            paymentMethod: "other" | "bank_transfer" | "credit_card" | "voucher" | "debit_card" | "cash" | "cheque" | "wallet" | "direct_bill";
+            paymentInstrumentId: string | null;
+            status: "failed" | "pending" | "completed" | "refunded";
+            referenceNumber: string | null;
+            paymentDate: string;
+            notes: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    createSupplierPayment(db: PostgresJsDatabase, data: CreateSupplierPaymentInput, runtime?: FinanceServiceRuntime): Promise<{
+        currency: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        status: "failed" | "pending" | "completed" | "refunded";
+        bookingId: string | null;
+        amountCents: number;
+        notes: string | null;
+        paymentMethod: "other" | "bank_transfer" | "credit_card" | "voucher" | "debit_card" | "cash" | "cheque" | "wallet" | "direct_bill";
+        baseCurrency: string | null;
+        fxRateSetId: string | null;
+        supplierId: string | null;
+        paymentInstrumentId: string | null;
+        referenceNumber: string | null;
+        baseAmountCents: number | null;
+        paymentDate: string;
+        supplierInvoiceId: string | null;
+        bookingSupplierStatusId: string | null;
+    } | null>;
+    updateSupplierPayment(db: PostgresJsDatabase, id: string, data: UpdateSupplierPaymentInput, runtime?: FinanceServiceRuntime): Promise<{
+        id: string;
+        bookingId: string | null;
+        supplierId: string | null;
+        bookingSupplierStatusId: string | null;
+        supplierInvoiceId: string | null;
+        amountCents: number;
+        currency: string;
+        baseCurrency: string | null;
+        baseAmountCents: number | null;
+        fxRateSetId: string | null;
+        paymentMethod: "other" | "bank_transfer" | "credit_card" | "voucher" | "debit_card" | "cash" | "cheque" | "wallet" | "direct_bill";
+        paymentInstrumentId: string | null;
+        status: "failed" | "pending" | "completed" | "refunded";
+        referenceNumber: string | null;
+        paymentDate: string;
+        notes: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+};
+//# sourceMappingURL=service-supplier-payments.d.ts.map

package/dist/service-supplier-payments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-supplier-payments.d.ts","sourceRoot":"","sources":["../src/service-supplier-payments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,0BAA0B,EAC1B,qBAAqB,EACrB,kBAAkB,EAClB,wBAAwB,EACxB,0BAA0B,EAC3B,MAAM,qBAAqB,CAAA;AAoB5B,eAAO,MAAM,6BAA6B;6BACT,kBAAkB,SAAS,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;8BAuE5E,kBAAkB,QAChB,0BAA0B,YACvB,qBAAqB;;;;;;;;;;;;;;;;;;;;8BA2D1B,kBAAkB,MAClB,MAAM,QACJ,0BAA0B,YACvB,qBAAqB;;;;;;;;;;;;;;;;;;;;CA6CjC,CAAA"}

package/dist/service-supplier-payments.js

@@ -0,0 +1,136 @@
+import { and, appendActionLedgerMutation, asc, bookings, buildSupplierPaymentCreateActionLedgerInput, buildSupplierPaymentUpdateActionLedgerInput, desc, eq, gte, lte, recomputeSupplierInvoiceBalance, resolveFxMoneyBaseAmount, resolveSupplierPaymentUpdateData, sql, supplierInvoices, supplierPayments, } from "./service-shared.js";
+export const financeSupplierPaymentService = {
+    async listSupplierPayments(db, query) {
+        const conditions = [];
+        if (query.bookingId) {
+            conditions.push(eq(supplierPayments.bookingId, query.bookingId));
+        }
+        if (query.supplierInvoiceId) {
+            conditions.push(eq(supplierPayments.supplierInvoiceId, query.supplierInvoiceId));
+        }
+        if (query.supplierId) {
+            conditions.push(eq(supplierPayments.supplierId, query.supplierId));
+        }
+        if (query.status) {
+            conditions.push(eq(supplierPayments.status, query.status));
+        }
+        if (query.paymentMethod) {
+            conditions.push(eq(supplierPayments.paymentMethod, query.paymentMethod));
+        }
+        if (query.currency) {
+            conditions.push(eq(supplierPayments.currency, query.currency));
+        }
+        if (query.paymentDateFrom) {
+            conditions.push(gte(supplierPayments.paymentDate, query.paymentDateFrom));
+        }
+        if (query.paymentDateTo) {
+            conditions.push(lte(supplierPayments.paymentDate, query.paymentDateTo));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const sortColumn = (() => {
+            switch (query.sortBy) {
+                case "amountCents":
+                    return supplierPayments.amountCents;
+                case "status":
+                    return supplierPayments.status;
+                case "paymentDate":
+                    return supplierPayments.paymentDate;
+                default:
+                    return supplierPayments.createdAt;
+            }
+        })();
+        const sortFn = query.sortDir === "asc" ? asc : desc;
+        const [rows, countResult] = await Promise.all([
+            db
+                .select()
+                .from(supplierPayments)
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(sortFn(sortColumn), desc(supplierPayments.createdAt)),
+            db.select({ count: sql `count(*)::int` }).from(supplierPayments).where(where),
+        ]);
+        return {
+            data: rows,
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async createSupplierPayment(db, data, runtime = {}) {
+        // Derive the reporting base currency from the booking when present, else
+        // from the supplier invoice the payment settles (AP payments may have no
+        // booking). See §5.4.
+        let targetBaseCurrency = null;
+        let fallbackFxRateSetId = null;
+        if (data.bookingId) {
+            const [booking] = await db
+                .select()
+                .from(bookings)
+                .where(eq(bookings.id, data.bookingId))
+                .limit(1);
+            targetBaseCurrency = booking?.baseCurrency ?? null;
+            fallbackFxRateSetId = booking?.fxRateSetId ?? null;
+        }
+        else if (data.supplierInvoiceId) {
+            const [invoice] = await db
+                .select()
+                .from(supplierInvoices)
+                .where(eq(supplierInvoices.id, data.supplierInvoiceId))
+                .limit(1);
+            targetBaseCurrency = invoice?.baseCurrency ?? null;
+            fallbackFxRateSetId = invoice?.fxRateSetId ?? null;
+        }
+        const paymentData = await resolveFxMoneyBaseAmount(db, data, {
+            ...runtime,
+            targetBaseCurrency,
+            fallbackFxRateSetId,
+            date: data.paymentDate,
+        });
+        const row = await db.transaction(async (tx) => {
+            const [created] = await tx
+                .insert(supplierPayments)
+                .values({ ...paymentData, paymentInstrumentId: paymentData.paymentInstrumentId ?? null })
+                .returning();
+            if (created && runtime.actionLedgerContext) {
+                await appendActionLedgerMutation(tx, await buildSupplierPaymentCreateActionLedgerInput(runtime.actionLedgerContext, { payment: created }, { authorizationSource: runtime.actionLedgerAuthorizationSource }));
+            }
+            // Keep the settled invoice's paid/balance/status in sync (§10).
+            if (created?.supplierInvoiceId) {
+                await recomputeSupplierInvoiceBalance(tx, created.supplierInvoiceId);
+            }
+            return created ?? null;
+        });
+        return row;
+    },
+    async updateSupplierPayment(db, id, data, runtime = {}) {
+        const [existing] = await db
+            .select()
+            .from(supplierPayments)
+            .where(eq(supplierPayments.id, id))
+            .limit(1);
+        if (!existing)
+            return null;
+        const updateData = await resolveSupplierPaymentUpdateData(db, id, data, runtime);
+        if (!updateData)
+            return null;
+        const row = await db.transaction(async (tx) => {
+            const [updated] = await tx
+                .update(supplierPayments)
+                .set({ ...updateData, updatedAt: new Date() })
+                .where(eq(supplierPayments.id, id))
+                .returning();
+            if (updated && runtime.actionLedgerContext) {
+                await appendActionLedgerMutation(tx, buildSupplierPaymentUpdateActionLedgerInput(runtime.actionLedgerContext, { payment: updated, changes: updateData }, { authorizationSource: runtime.actionLedgerAuthorizationSource }));
+            }
+            // Recompute both the previously-linked and newly-linked invoices so a
+            // re-pointed or status-changed payment leaves balances consistent (§10).
+            const affected = new Set([existing.supplierInvoiceId, updated?.supplierInvoiceId].filter((value) => Boolean(value)));
+            for (const invoiceId of affected) {
+                await recomputeSupplierInvoiceBalance(tx, invoiceId);
+            }
+            return updated ?? null;
+        });
+        return row ?? null;
+    },
+};

package/dist/service-vouchers-migration.d.ts

@@ -0,0 +1,44 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+export interface VoucherMigrationOptions {
+    /**
+     * When true, report what would happen without writing. Defaults to false.
+     */
+    dryRun?: boolean;
+    /**
+     * Per-row hook for progress reporting. Not called on skipped rows.
+     */
+    onRowMigrated?: (info: {
+        paymentInstrumentId: string;
+        voucherCode: string;
+    }) => void;
+}
+export interface VoucherMigrationSkip {
+    paymentInstrumentId: string;
+    reason: "already_migrated" | "missing_code" | "missing_currency" | "missing_amount" | "duplicate_code_collision";
+}
+export interface VoucherMigrationResult {
+    candidates: number;
+    migrated: number;
+    skipped: VoucherMigrationSkip[];
+    dryRun: boolean;
+}
+/**
+ * Backfill the `vouchers` table from legacy voucher rows in
+ * `payment_instruments`. A legacy voucher is a row with `instrumentType =
+ * 'voucher'` whose code lives in one of `metadata.code`, `external_token`, or
+ * `direct_bill_reference`, and whose balance lives in
+ * `metadata.remainingAmountCents` (falling back to `metadata.amountCents` when
+ * no redemption has touched the row).
+ *
+ * The migration is idempotent: rows whose code already exists in the new
+ * `vouchers` table are skipped so re-running the script after a partial run
+ * (or after issuing new vouchers via the first-class API) is safe.
+ *
+ * Why skip rather than update: the new table treats `code` as a primary lookup
+ * key and the legacy path has already been read-only-fallback since #256
+ * landed, so any voucher that exists in both tables is by definition already
+ * migrated. Picking one source of truth avoids clobbering balances the
+ * operator may have adjusted through the new redemption flow.
+ */
+export declare function migrateVouchersFromPaymentInstruments(db: PostgresJsDatabase, options?: VoucherMigrationOptions): Promise<VoucherMigrationResult>;
+//# sourceMappingURL=service-vouchers-migration.d.ts.map

package/dist/service-vouchers-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-vouchers-migration.d.ts","sourceRoot":"","sources":["../src/service-vouchers-migration.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAsCjE,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB;;OAEG;IACH,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,mBAAmB,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAA;CACrF;AAED,MAAM,WAAW,oBAAoB;IACnC,mBAAmB,EAAE,MAAM,CAAA;IAC3B,MAAM,EACF,kBAAkB,GAClB,cAAc,GACd,kBAAkB,GAClB,gBAAgB,GAChB,0BAA0B,CAAA;CAC/B;AAED,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,oBAAoB,EAAE,CAAA;IAC/B,MAAM,EAAE,OAAO,CAAA;CAChB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,qCAAqC,CACzD,EAAE,EAAE,kBAAkB,EACtB,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,sBAAsB,CAAC,CA6GjC"}

package/dist/service-vouchers-migration.js

@@ -0,0 +1,148 @@
+import { eq, sql } from "drizzle-orm";
+import { paymentInstruments, vouchers } from "./schema.js";
+/**
+ * Pulls a (possibly nested, array-wrapped, or null) value out of a JSONB
+ * metadata column. Keeps the narrow runtime checks local so callers can stay
+ * declarative about the shape they expect.
+ */
+function asRecord(metadata) {
+    if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+        return null;
+    }
+    return metadata;
+}
+function asString(record, key) {
+    const value = record?.[key];
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function asNumber(record, key) {
+    const value = record?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asStringArray(record, key) {
+    const value = record?.[key];
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((entry) => typeof entry === "string" && entry.length > 0);
+}
+function asDate(value) {
+    if (!value)
+        return null;
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+/**
+ * Backfill the `vouchers` table from legacy voucher rows in
+ * `payment_instruments`. A legacy voucher is a row with `instrumentType =
+ * 'voucher'` whose code lives in one of `metadata.code`, `external_token`, or
+ * `direct_bill_reference`, and whose balance lives in
+ * `metadata.remainingAmountCents` (falling back to `metadata.amountCents` when
+ * no redemption has touched the row).
+ *
+ * The migration is idempotent: rows whose code already exists in the new
+ * `vouchers` table are skipped so re-running the script after a partial run
+ * (or after issuing new vouchers via the first-class API) is safe.
+ *
+ * Why skip rather than update: the new table treats `code` as a primary lookup
+ * key and the legacy path has already been read-only-fallback since #256
+ * landed, so any voucher that exists in both tables is by definition already
+ * migrated. Picking one source of truth avoids clobbering balances the
+ * operator may have adjusted through the new redemption flow.
+ */
+export async function migrateVouchersFromPaymentInstruments(db, options = {}) {
+    const dryRun = options.dryRun ?? false;
+    const skipped = [];
+    let migrated = 0;
+    const candidates = await db
+        .select()
+        .from(paymentInstruments)
+        .where(eq(paymentInstruments.instrumentType, "voucher"));
+    for (const instrument of candidates) {
+        const metadata = asRecord(instrument.metadata);
+        const code = asString(metadata, "code") ?? instrument.externalToken ?? instrument.directBillReference;
+        if (!code) {
+            skipped.push({ paymentInstrumentId: instrument.id, reason: "missing_code" });
+            continue;
+        }
+        const currency = asString(metadata, "currency");
+        if (!currency || currency.length !== 3) {
+            skipped.push({ paymentInstrumentId: instrument.id, reason: "missing_currency" });
+            continue;
+        }
+        const initialAmountCents = asNumber(metadata, "amountCents");
+        if (initialAmountCents === null || initialAmountCents <= 0) {
+            skipped.push({ paymentInstrumentId: instrument.id, reason: "missing_amount" });
+            continue;
+        }
+        const remainingAmountCents = asNumber(metadata, "remainingAmountCents") ?? initialAmountCents;
+        const [existing] = await db
+            .select({ id: vouchers.id })
+            .from(vouchers)
+            // agent-quality: raw-sql reviewed -- owner: finance; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            .where(sql `lower(${vouchers.code}) = ${code.toLowerCase()}`)
+            .limit(1);
+        if (existing) {
+            skipped.push({ paymentInstrumentId: instrument.id, reason: "already_migrated" });
+            continue;
+        }
+        const expiresAt = asDate(asString(metadata, "expiresAt"));
+        // OpenTravel uses `effectiveDate`; some legacy payloads also wrote
+        // `validFrom` directly. Check both so existing rows aren't silently
+        // dropped.
+        const validFrom = asDate(asString(metadata, "validFrom")) ?? asDate(asString(metadata, "effectiveDate"));
+        const seriesCode = asString(metadata, "seriesCode");
+        const bookingIds = asStringArray(metadata, "bookingIds");
+        const sourceBookingId = asString(metadata, "bookingId") ?? bookingIds[0] ?? null;
+        // Collapse the legacy status/balance pair onto the new enum. If there's no
+        // balance left, treat as already spent; otherwise follow the instrument's
+        // own active/inactive flag.
+        const status = remainingAmountCents <= 0 ? "redeemed" : instrument.status === "active" ? "active" : "void";
+        if (dryRun) {
+            migrated++;
+            options.onRowMigrated?.({ paymentInstrumentId: instrument.id, voucherCode: code });
+            continue;
+        }
+        try {
+            await db.insert(vouchers).values({
+                code,
+                seriesCode,
+                status,
+                currency: currency.toUpperCase(),
+                initialAmountCents,
+                remainingAmountCents: Math.max(0, remainingAmountCents),
+                issuedToPersonId: instrument.personId ?? null,
+                issuedToOrganizationId: instrument.organizationId ?? null,
+                // We don't know the original source (refund vs gift vs promo) from the
+                // legacy shape, so mark everything as `manual` — operators can reclassify
+                // later via PATCH /vouchers/:id.
+                sourceType: "manual",
+                sourceBookingId,
+                notes: instrument.notes ?? null,
+                validFrom,
+                expiresAt,
+                createdAt: instrument.createdAt,
+                updatedAt: instrument.updatedAt,
+            });
+            migrated++;
+            options.onRowMigrated?.({ paymentInstrumentId: instrument.id, voucherCode: code });
+        }
+        catch (error) {
+            // Unique-index collision is the only realistic insert failure here
+            // (another concurrent migration or a race with a manual issuance). Record
+            // it as a skip rather than aborting the batch so a retry finishes the
+            // rest.
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes("uidx_vouchers_code") || message.includes("duplicate key")) {
+                skipped.push({ paymentInstrumentId: instrument.id, reason: "duplicate_code_collision" });
+                continue;
+            }
+            throw error;
+        }
+    }
+    return {
+        candidates: candidates.length,
+        migrated,
+        skipped,
+        dryRun,
+    };
+}

package/dist/service-vouchers.d.ts

@@ -0,0 +1,157 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import type { insertVoucherSchema, redeemVoucherSchema, updateVoucherSchema, voucherListQuerySchema } from "./validation-vouchers.js";
+type CreateVoucherInput = z.infer<typeof insertVoucherSchema>;
+type UpdateVoucherInput = z.infer<typeof updateVoucherSchema>;
+type RedeemVoucherInput = z.infer<typeof redeemVoucherSchema>;
+type VoucherListQuery = z.infer<typeof voucherListQuerySchema>;
+/**
+ * Raised by the voucher service. Code + message; route handlers map to HTTP.
+ * Reasons the route layer cares about:
+ *  - `code_in_use`        — supplied code collides with an existing voucher
+ *  - `voucher_not_found`  — id-not-found / code-not-found read path
+ *  - `voucher_inactive`   — redeem attempted against non-active status
+ *  - `voucher_not_started`— validFrom is set and hasn't happened yet
+ *  - `voucher_expired`    — expiresAt has passed
+ *  - `insufficient_balance` — requested amount > remainingAmountCents
+ */
+export declare class VoucherServiceError extends Error {
+    readonly code: "code_in_use" | "voucher_not_found" | "voucher_inactive" | "voucher_not_started" | "voucher_expired" | "insufficient_balance";
+    constructor(code: "code_in_use" | "voucher_not_found" | "voucher_inactive" | "voucher_not_started" | "voucher_expired" | "insufficient_balance", message?: string);
+}
+export declare const vouchersService: {
+    list(db: PostgresJsDatabase, query: VoucherListQuery): Promise<{
+        data: {
+            id: string;
+            code: string;
+            seriesCode: string | null;
+            status: "expired" | "active" | "void" | "redeemed";
+            currency: string;
+            initialAmountCents: number;
+            remainingAmountCents: number;
+            issuedToPersonId: string | null;
+            issuedToOrganizationId: string | null;
+            sourceType: "manual" | "refund" | "cancellation_credit" | "gift" | "promo";
+            sourceBookingId: string | null;
+            sourcePaymentId: string | null;
+            validFrom: Date | null;
+            expiresAt: Date | null;
+            notes: string | null;
+            issuedByUserId: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getById(db: PostgresJsDatabase, id: string): Promise<{
+        redemptions: {
+            id: string;
+            voucherId: string;
+            bookingId: string;
+            paymentId: string | null;
+            amountCents: number;
+            createdAt: Date;
+            createdByUserId: string | null;
+        }[];
+        id: string;
+        code: string;
+        seriesCode: string | null;
+        status: "expired" | "active" | "void" | "redeemed";
+        currency: string;
+        initialAmountCents: number;
+        remainingAmountCents: number;
+        issuedToPersonId: string | null;
+        issuedToOrganizationId: string | null;
+        sourceType: "manual" | "refund" | "cancellation_credit" | "gift" | "promo";
+        sourceBookingId: string | null;
+        sourcePaymentId: string | null;
+        validFrom: Date | null;
+        expiresAt: Date | null;
+        notes: string | null;
+        issuedByUserId: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    create(db: PostgresJsDatabase, input: CreateVoucherInput, issuedByUserId?: string): Promise<{
+        id: string;
+        status: "expired" | "active" | "void" | "redeemed";
+        createdAt: Date;
+        expiresAt: Date | null;
+        notes: string | null;
+        updatedAt: Date;
+        currency: string;
+        code: string;
+        seriesCode: string | null;
+        initialAmountCents: number;
+        remainingAmountCents: number;
+        issuedToPersonId: string | null;
+        issuedToOrganizationId: string | null;
+        sourceType: "manual" | "refund" | "cancellation_credit" | "gift" | "promo";
+        sourceBookingId: string | null;
+        sourcePaymentId: string | null;
+        validFrom: Date | null;
+        issuedByUserId: string | null;
+    } | null>;
+    update(db: PostgresJsDatabase, id: string, input: UpdateVoucherInput): Promise<{
+        id: string;
+        code: string;
+        seriesCode: string | null;
+        status: "expired" | "active" | "void" | "redeemed";
+        currency: string;
+        initialAmountCents: number;
+        remainingAmountCents: number;
+        issuedToPersonId: string | null;
+        issuedToOrganizationId: string | null;
+        sourceType: "manual" | "refund" | "cancellation_credit" | "gift" | "promo";
+        sourceBookingId: string | null;
+        sourcePaymentId: string | null;
+        validFrom: Date | null;
+        expiresAt: Date | null;
+        notes: string | null;
+        issuedByUserId: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    /**
+     * Apply a voucher against a booking. Runs in a transaction so
+     * `remainingAmountCents` and the redemption row either both land or neither.
+     * Guards: voucher must exist, be active, not expired, and have enough
+     * balance for the requested amount. When remaining hits zero the voucher
+     * flips to `status = 'redeemed'`.
+     */
+    redeem(db: PostgresJsDatabase, voucherId: string, input: RedeemVoucherInput, userId?: string): Promise<{
+        voucher: {
+            id: string;
+            code: string;
+            seriesCode: string | null;
+            status: "expired" | "active" | "void" | "redeemed";
+            currency: string;
+            initialAmountCents: number;
+            remainingAmountCents: number;
+            issuedToPersonId: string | null;
+            issuedToOrganizationId: string | null;
+            sourceType: "manual" | "refund" | "cancellation_credit" | "gift" | "promo";
+            sourceBookingId: string | null;
+            sourcePaymentId: string | null;
+            validFrom: Date | null;
+            expiresAt: Date | null;
+            notes: string | null;
+            issuedByUserId: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        };
+        redemption: {
+            id: string;
+            createdAt: Date;
+            bookingId: string;
+            amountCents: number;
+            paymentId: string | null;
+            voucherId: string;
+            createdByUserId: string | null;
+        } | null;
+    }>;
+};
+export {};
+//# sourceMappingURL=service-vouchers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-vouchers.d.ts","sourceRoot":"","sources":["../src/service-vouchers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAG5B,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,sBAAsB,EACvB,MAAM,0BAA0B,CAAA;AAEjC,KAAK,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC7D,KAAK,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC7D,KAAK,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC7D,KAAK,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE9D;;;;;;;;;GASG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAE1C,QAAQ,CAAC,IAAI,EACT,aAAa,GACb,mBAAmB,GACnB,kBAAkB,GAClB,qBAAqB,GACrB,iBAAiB,GACjB,sBAAsB;gBANjB,IAAI,EACT,aAAa,GACb,mBAAmB,GACnB,kBAAkB,GAClB,qBAAqB,GACrB,iBAAiB,GACjB,sBAAsB,EAC1B,OAAO,CAAC,EAAE,MAAM;CAKnB;AAsBD,eAAO,MAAM,eAAe;aACX,kBAAkB,SAAS,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;gBAuCxC,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAW/B,kBAAkB,SAAS,kBAAkB,mBAAmB,MAAM;;;;;;;;;;;;;;;;;;;;eAiCtE,kBAAkB,MAAM,MAAM,SAAS,kBAAkB;;;;;;;;;;;;;;;;;;;;IA0B1E;;;;;;OAMG;eAEG,kBAAkB,aACX,MAAM,SACV,kBAAkB,WAChB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0ClB,CAAA"}