@voyant-travel/finance 0.119.5

package/dist/service-invoice-core.d.ts

@@ -0,0 +1,405 @@
+import type { CreateInvoiceInput, FinanceServiceRuntime, InvoiceListQuery, PostgresJsDatabase, UpdateInvoiceInput, VoidInvoiceInput } from "./service-shared.js";
+export declare const financeInvoiceCoreService: {
+    listInvoices(db: PostgresJsDatabase, query: InvoiceListQuery): Promise<{
+        data: {
+            bookingPaymentScheduleIds: string[];
+            id: string;
+            invoiceNumber: string;
+            invoiceType: "invoice" | "proforma" | "credit_note";
+            convertedFromInvoiceId: string | null;
+            seriesId: string | null;
+            sequence: number | null;
+            templateId: string | null;
+            taxRegimeId: string | null;
+            language: string | null;
+            bookingId: string;
+            personId: string | null;
+            organizationId: string | null;
+            status: "void" | "paid" | "draft" | "pending_external_allocation" | "issued" | "partially_paid" | "overdue";
+            currency: string;
+            baseCurrency: string | null;
+            fxRateSetId: string | null;
+            subtotalCents: number;
+            baseSubtotalCents: number | null;
+            taxCents: number;
+            baseTaxCents: number | null;
+            totalCents: number;
+            baseTotalCents: number | null;
+            paidCents: number;
+            basePaidCents: number | null;
+            balanceDueCents: number;
+            baseBalanceDueCents: number | null;
+            commissionPercent: number | null;
+            commissionAmountCents: number | null;
+            issueDate: string;
+            dueDate: string;
+            notes: string | null;
+            voidedAt: Date | null;
+            voidReason: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    createInvoice(db: PostgresJsDatabase, data: CreateInvoiceInput): Promise<{
+        subtotalCents: number;
+        currency: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        taxRegimeId: string | null;
+        taxCents: number;
+        totalCents: number;
+        status: "void" | "paid" | "draft" | "pending_external_allocation" | "issued" | "partially_paid" | "overdue";
+        bookingId: string;
+        notes: string | null;
+        templateId: string | null;
+        dueDate: string;
+        invoiceNumber: string;
+        invoiceType: "invoice" | "proforma" | "credit_note";
+        convertedFromInvoiceId: string | null;
+        seriesId: string | null;
+        sequence: number | null;
+        language: string | null;
+        personId: string | null;
+        organizationId: string | null;
+        baseCurrency: string | null;
+        fxRateSetId: string | null;
+        baseSubtotalCents: number | null;
+        baseTaxCents: number | null;
+        baseTotalCents: number | null;
+        paidCents: number;
+        basePaidCents: number | null;
+        balanceDueCents: number;
+        baseBalanceDueCents: number | null;
+        commissionPercent: number | null;
+        commissionAmountCents: number | null;
+        issueDate: string;
+        voidedAt: Date | null;
+        voidReason: string | null;
+    } | undefined>;
+    getInvoiceById(db: PostgresJsDatabase, id: string): Promise<{
+        convertedToInvoiceId: string | null;
+        convertedToInvoiceNumber: string | null;
+        id: string;
+        invoiceNumber: string;
+        invoiceType: "invoice" | "proforma" | "credit_note";
+        convertedFromInvoiceId: string | null;
+        seriesId: string | null;
+        sequence: number | null;
+        templateId: string | null;
+        taxRegimeId: string | null;
+        language: string | null;
+        bookingId: string;
+        personId: string | null;
+        organizationId: string | null;
+        status: "void" | "paid" | "draft" | "pending_external_allocation" | "issued" | "partially_paid" | "overdue";
+        currency: string;
+        baseCurrency: string | null;
+        fxRateSetId: string | null;
+        subtotalCents: number;
+        baseSubtotalCents: number | null;
+        taxCents: number;
+        baseTaxCents: number | null;
+        totalCents: number;
+        baseTotalCents: number | null;
+        paidCents: number;
+        basePaidCents: number | null;
+        balanceDueCents: number;
+        baseBalanceDueCents: number | null;
+        commissionPercent: number | null;
+        commissionAmountCents: number | null;
+        issueDate: string;
+        dueDate: string;
+        notes: string | null;
+        voidedAt: Date | null;
+        voidReason: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    updateInvoice(db: PostgresJsDatabase, id: string, data: UpdateInvoiceInput, runtime?: FinanceServiceRuntime): Promise<{
+        id: string;
+        invoiceNumber: string;
+        invoiceType: "invoice" | "proforma" | "credit_note";
+        convertedFromInvoiceId: string | null;
+        seriesId: string | null;
+        sequence: number | null;
+        templateId: string | null;
+        taxRegimeId: string | null;
+        language: string | null;
+        bookingId: string;
+        personId: string | null;
+        organizationId: string | null;
+        status: "void" | "paid" | "draft" | "pending_external_allocation" | "issued" | "partially_paid" | "overdue";
+        currency: string;
+        baseCurrency: string | null;
+        fxRateSetId: string | null;
+        subtotalCents: number;
+        baseSubtotalCents: number | null;
+        taxCents: number;
+        baseTaxCents: number | null;
+        totalCents: number;
+        baseTotalCents: number | null;
+        paidCents: number;
+        basePaidCents: number | null;
+        balanceDueCents: number;
+        baseBalanceDueCents: number | null;
+        commissionPercent: number | null;
+        commissionAmountCents: number | null;
+        issueDate: string;
+        dueDate: string;
+        notes: string | null;
+        voidedAt: Date | null;
+        voidReason: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteInvoice(db: PostgresJsDatabase, id: string, runtime?: FinanceServiceRuntime): Promise<{
+        status: "not_found";
+    } | {
+        status: "not_draft";
+    } | {
+        status: "deleted";
+    }>;
+    voidInvoice(db: PostgresJsDatabase, id: string, input?: VoidInvoiceInput, runtime?: FinanceServiceRuntime): Promise<{
+        status: "not_found";
+        invoice?: undefined;
+    } | {
+        status: "already_void";
+        invoice: {
+            id: string;
+            invoiceNumber: string;
+            invoiceType: "invoice" | "proforma" | "credit_note";
+            convertedFromInvoiceId: string | null;
+            seriesId: string | null;
+            sequence: number | null;
+            templateId: string | null;
+            taxRegimeId: string | null;
+            language: string | null;
+            bookingId: string;
+            personId: string | null;
+            organizationId: string | null;
+            status: "void" | "paid" | "draft" | "pending_external_allocation" | "issued" | "partially_paid" | "overdue";
+            currency: string;
+            baseCurrency: string | null;
+            fxRateSetId: string | null;
+            subtotalCents: number;
+            baseSubtotalCents: number | null;
+            taxCents: number;
+            baseTaxCents: number | null;
+            totalCents: number;
+            baseTotalCents: number | null;
+            paidCents: number;
+            basePaidCents: number | null;
+            balanceDueCents: number;
+            baseBalanceDueCents: number | null;
+            commissionPercent: number | null;
+            commissionAmountCents: number | null;
+            issueDate: string;
+            dueDate: string;
+            notes: string | null;
+            voidedAt: Date | null;
+            voidReason: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        };
+    } | {
+        status: "draft";
+        invoice: {
+            id: string;
+            invoiceNumber: string;
+            invoiceType: "invoice" | "proforma" | "credit_note";
+            convertedFromInvoiceId: string | null;
+            seriesId: string | null;
+            sequence: number | null;
+            templateId: string | null;
+            taxRegimeId: string | null;
+            language: string | null;
+            bookingId: string;
+            personId: string | null;
+            organizationId: string | null;
+            status: "void" | "paid" | "draft" | "pending_external_allocation" | "issued" | "partially_paid" | "overdue";
+            currency: string;
+            baseCurrency: string | null;
+            fxRateSetId: string | null;
+            subtotalCents: number;
+            baseSubtotalCents: number | null;
+            taxCents: number;
+            baseTaxCents: number | null;
+            totalCents: number;
+            baseTotalCents: number | null;
+            paidCents: number;
+            basePaidCents: number | null;
+            balanceDueCents: number;
+            baseBalanceDueCents: number | null;
+            commissionPercent: number | null;
+            commissionAmountCents: number | null;
+            issueDate: string;
+            dueDate: string;
+            notes: string | null;
+            voidedAt: Date | null;
+            voidReason: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        };
+    } | {
+        status: "invalid_status";
+        invoice: {
+            id: string;
+            invoiceNumber: string;
+            invoiceType: "invoice" | "proforma" | "credit_note";
+            convertedFromInvoiceId: string | null;
+            seriesId: string | null;
+            sequence: number | null;
+            templateId: string | null;
+            taxRegimeId: string | null;
+            language: string | null;
+            bookingId: string;
+            personId: string | null;
+            organizationId: string | null;
+            status: "void" | "paid" | "draft" | "pending_external_allocation" | "issued" | "partially_paid" | "overdue";
+            currency: string;
+            baseCurrency: string | null;
+            fxRateSetId: string | null;
+            subtotalCents: number;
+            baseSubtotalCents: number | null;
+            taxCents: number;
+            baseTaxCents: number | null;
+            totalCents: number;
+            baseTotalCents: number | null;
+            paidCents: number;
+            basePaidCents: number | null;
+            balanceDueCents: number;
+            baseBalanceDueCents: number | null;
+            commissionPercent: number | null;
+            commissionAmountCents: number | null;
+            issueDate: string;
+            dueDate: string;
+            notes: string | null;
+            voidedAt: Date | null;
+            voidReason: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        };
+    } | {
+        status: "has_payments";
+        invoice: {
+            id: string;
+            invoiceNumber: string;
+            invoiceType: "invoice" | "proforma" | "credit_note";
+            convertedFromInvoiceId: string | null;
+            seriesId: string | null;
+            sequence: number | null;
+            templateId: string | null;
+            taxRegimeId: string | null;
+            language: string | null;
+            bookingId: string;
+            personId: string | null;
+            organizationId: string | null;
+            status: "void" | "paid" | "draft" | "pending_external_allocation" | "issued" | "partially_paid" | "overdue";
+            currency: string;
+            baseCurrency: string | null;
+            fxRateSetId: string | null;
+            subtotalCents: number;
+            baseSubtotalCents: number | null;
+            taxCents: number;
+            baseTaxCents: number | null;
+            totalCents: number;
+            baseTotalCents: number | null;
+            paidCents: number;
+            basePaidCents: number | null;
+            balanceDueCents: number;
+            baseBalanceDueCents: number | null;
+            commissionPercent: number | null;
+            commissionAmountCents: number | null;
+            issueDate: string;
+            dueDate: string;
+            notes: string | null;
+            voidedAt: Date | null;
+            voidReason: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        };
+    } | {
+        status: "has_credit_notes";
+        invoice: {
+            id: string;
+            invoiceNumber: string;
+            invoiceType: "invoice" | "proforma" | "credit_note";
+            convertedFromInvoiceId: string | null;
+            seriesId: string | null;
+            sequence: number | null;
+            templateId: string | null;
+            taxRegimeId: string | null;
+            language: string | null;
+            bookingId: string;
+            personId: string | null;
+            organizationId: string | null;
+            status: "void" | "paid" | "draft" | "pending_external_allocation" | "issued" | "partially_paid" | "overdue";
+            currency: string;
+            baseCurrency: string | null;
+            fxRateSetId: string | null;
+            subtotalCents: number;
+            baseSubtotalCents: number | null;
+            taxCents: number;
+            baseTaxCents: number | null;
+            totalCents: number;
+            baseTotalCents: number | null;
+            paidCents: number;
+            basePaidCents: number | null;
+            balanceDueCents: number;
+            baseBalanceDueCents: number | null;
+            commissionPercent: number | null;
+            commissionAmountCents: number | null;
+            issueDate: string;
+            dueDate: string;
+            notes: string | null;
+            voidedAt: Date | null;
+            voidReason: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        };
+    } | {
+        status: "voided";
+        invoice: {
+            id: string;
+            invoiceNumber: string;
+            invoiceType: "invoice" | "proforma" | "credit_note";
+            convertedFromInvoiceId: string | null;
+            seriesId: string | null;
+            sequence: number | null;
+            templateId: string | null;
+            taxRegimeId: string | null;
+            language: string | null;
+            bookingId: string;
+            personId: string | null;
+            organizationId: string | null;
+            status: "void" | "paid" | "draft" | "pending_external_allocation" | "issued" | "partially_paid" | "overdue";
+            currency: string;
+            baseCurrency: string | null;
+            fxRateSetId: string | null;
+            subtotalCents: number;
+            baseSubtotalCents: number | null;
+            taxCents: number;
+            baseTaxCents: number | null;
+            totalCents: number;
+            baseTotalCents: number | null;
+            paidCents: number;
+            basePaidCents: number | null;
+            balanceDueCents: number;
+            baseBalanceDueCents: number | null;
+            commissionPercent: number | null;
+            commissionAmountCents: number | null;
+            issueDate: string;
+            dueDate: string;
+            notes: string | null;
+            voidedAt: Date | null;
+            voidReason: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        };
+    }>;
+};
+//# sourceMappingURL=service-invoice-core.d.ts.map

package/dist/service-invoice-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-invoice-core.d.ts","sourceRoot":"","sources":["../src/service-invoice-core.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,EAEhB,kBAAkB,EAClB,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,qBAAqB,CAAA;AA4B5B,eAAO,MAAM,yBAAyB;qBACb,kBAAkB,SAAS,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAmH1C,kBAAkB,QAAQ,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAI3C,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAqBjD,kBAAkB,MAClB,MAAM,QACJ,kBAAkB,YACf,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAwCR,kBAAkB,MAAM,MAAM,YAAW,qBAAqB;;;;;;;oBA8ChF,kBAAkB,MAClB,MAAM,UACH,gBAAgB,YACd,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0IjC,CAAA"}

package/dist/service-invoice-core.js

@@ -0,0 +1,290 @@
+import { and, appendActionLedgerMutation, asc, buildInvoiceDeleteActionLedgerInput, buildInvoiceUpdateActionLedgerInput, creditNotes, desc, eq, gte, InvoiceNumberConflictError, ilike, inArray, invoiceExternalRefs, invoiceLineItems, invoiceNumberSeries, invoices, isInvoiceNumberUniqueConstraintError, isNotNull, lte, ne, or, payments, readStringMetadata, sql, } from "./service-shared.js";
+export const financeInvoiceCoreService = {
+    async listInvoices(db, query) {
+        const conditions = [];
+        if (query.status) {
+            conditions.push(eq(invoices.status, query.status));
+        }
+        if (query.bookingId) {
+            conditions.push(eq(invoices.bookingId, query.bookingId));
+        }
+        if (query.personId) {
+            conditions.push(eq(invoices.personId, query.personId));
+        }
+        if (query.organizationId) {
+            conditions.push(eq(invoices.organizationId, query.organizationId));
+        }
+        if (query.currency) {
+            conditions.push(eq(invoices.currency, query.currency));
+        }
+        if (query.dueDateFrom) {
+            conditions.push(gte(invoices.dueDate, query.dueDateFrom));
+        }
+        if (query.dueDateTo) {
+            conditions.push(lte(invoices.dueDate, query.dueDateTo));
+        }
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(or(ilike(invoices.invoiceNumber, term), ilike(invoices.notes, term)));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const sortColumn = (() => {
+            switch (query.sortBy) {
+                case "invoiceNumber":
+                    return invoices.invoiceNumber;
+                case "status":
+                    return invoices.status;
+                case "totalCents":
+                    return invoices.totalCents;
+                case "paidCents":
+                    return invoices.paidCents;
+                case "balanceDueCents":
+                    return invoices.balanceDueCents;
+                case "issueDate":
+                    return invoices.issueDate;
+                case "dueDate":
+                    return invoices.dueDate;
+                default:
+                    return invoices.createdAt;
+            }
+        })();
+        const sortFn = query.sortDir === "asc" ? asc : desc;
+        const [rows, countResult] = await Promise.all([
+            db
+                .select()
+                .from(invoices)
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(sortFn(sortColumn), desc(invoices.createdAt)),
+            db.select({ count: sql `count(*)::int` }).from(invoices).where(where),
+        ]);
+        // For each returned invoice, surface the distinct
+        // `bookingPaymentScheduleId`s referenced by its line items so the
+        // booking-detail payment-schedule table can link rows to invoices
+        // without a second roundtrip. Returns `[]` when an invoice covers
+        // booking items directly (no schedule link).
+        const invoiceIds = rows.map((row) => row.id);
+        const scheduleLinks = invoiceIds.length
+            ? await db
+                .select({
+                invoiceId: invoiceLineItems.invoiceId,
+                bookingPaymentScheduleId: invoiceLineItems.bookingPaymentScheduleId,
+            })
+                .from(invoiceLineItems)
+                .where(and(inArray(invoiceLineItems.invoiceId, invoiceIds), isNotNull(invoiceLineItems.bookingPaymentScheduleId)))
+            : [];
+        const scheduleIdsByInvoice = new Map();
+        for (const link of scheduleLinks) {
+            const scheduleId = link.bookingPaymentScheduleId;
+            if (!scheduleId)
+                continue;
+            const existing = scheduleIdsByInvoice.get(link.invoiceId);
+            if (!existing) {
+                scheduleIdsByInvoice.set(link.invoiceId, [scheduleId]);
+            }
+            else if (!existing.includes(scheduleId)) {
+                existing.push(scheduleId);
+            }
+        }
+        const data = rows.map((row) => ({
+            ...row,
+            bookingPaymentScheduleIds: scheduleIdsByInvoice.get(row.id) ?? [],
+        }));
+        return {
+            data,
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async createInvoice(db, data) {
+        const [row] = await db.insert(invoices).values(data).returning();
+        return row;
+    },
+    async getInvoiceById(db, id) {
+        const [row] = await db.select().from(invoices).where(eq(invoices.id, id)).limit(1);
+        if (!row)
+            return null;
+        // Surface the proforma → final-invoice link so the UI can show
+        // "Invoiced" instead of "Void" for proformas that were converted.
+        // The reverse direction (`convertedFromInvoiceId`) already lives on
+        // the row; this looks up the inverse via the unique
+        // `idx_invoices_converted_from` index.
+        const [convertedTo] = await db
+            .select({ id: invoices.id, invoiceNumber: invoices.invoiceNumber })
+            .from(invoices)
+            .where(and(eq(invoices.convertedFromInvoiceId, id), ne(invoices.status, "void")))
+            .limit(1);
+        return {
+            ...row,
+            convertedToInvoiceId: convertedTo?.id ?? null,
+            convertedToInvoiceNumber: convertedTo?.invoiceNumber ?? null,
+        };
+    },
+    async updateInvoice(db, id, data, runtime = {}) {
+        const updateInvoiceRow = (writer) => writer
+            .update(invoices)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(invoices.id, id))
+            .returning();
+        try {
+            const actionLedgerContext = runtime.actionLedgerContext;
+            if (actionLedgerContext) {
+                return await db.transaction(async (tx) => {
+                    const [row] = await updateInvoiceRow(tx);
+                    if (row) {
+                        await appendActionLedgerMutation(tx, buildInvoiceUpdateActionLedgerInput(actionLedgerContext, { invoice: row, changes: data }, { authorizationSource: runtime.actionLedgerAuthorizationSource }));
+                    }
+                    return row ?? null;
+                });
+            }
+            const [row] = await updateInvoiceRow(db);
+            return row ?? null;
+        }
+        catch (error) {
+            if (data.invoiceNumber && isInvoiceNumberUniqueConstraintError(error)) {
+                throw new InvoiceNumberConflictError(data.invoiceNumber);
+            }
+            throw error;
+        }
+    },
+    async deleteInvoice(db, id, runtime = {}) {
+        const actionLedgerContext = runtime.actionLedgerContext;
+        if (actionLedgerContext) {
+            return db.transaction(async (tx) => {
+                const [existing] = await tx.select().from(invoices).where(eq(invoices.id, id)).limit(1);
+                if (!existing) {
+                    return { status: "not_found" };
+                }
+                if (existing.status !== "draft") {
+                    return { status: "not_draft" };
+                }
+                await tx.delete(invoices).where(eq(invoices.id, id));
+                await appendActionLedgerMutation(tx, buildInvoiceDeleteActionLedgerInput(actionLedgerContext, { invoice: existing }, { authorizationSource: runtime.actionLedgerAuthorizationSource }));
+                return { status: "deleted" };
+            });
+        }
+        const [existing] = await db
+            .select({ id: invoices.id, status: invoices.status })
+            .from(invoices)
+            .where(eq(invoices.id, id))
+            .limit(1);
+        if (!existing) {
+            return { status: "not_found" };
+        }
+        if (existing.status !== "draft") {
+            return { status: "not_draft" };
+        }
+        await db.delete(invoices).where(eq(invoices.id, id));
+        return { status: "deleted" };
+    },
+    async voidInvoice(db, id, input = {}, runtime = {}) {
+        const reason = input.reason?.trim() || null;
+        const voidedAt = new Date();
+        const result = await db.transaction(async (tx) => {
+            const [existing] = await tx.select().from(invoices).where(eq(invoices.id, id)).limit(1);
+            if (!existing) {
+                return { status: "not_found" };
+            }
+            if (existing.status === "void") {
+                return { status: "already_void", invoice: existing };
+            }
+            if (existing.status === "draft") {
+                return { status: "draft", invoice: existing };
+            }
+            const voidableStatuses = new Set([
+                "pending_external_allocation",
+                "issued",
+                "partially_paid",
+                "overdue",
+            ]);
+            if (!voidableStatuses.has(existing.status)) {
+                return { status: "invalid_status", invoice: existing };
+            }
+            const [payment] = await tx
+                .select({ id: payments.id })
+                .from(payments)
+                .where(eq(payments.invoiceId, id))
+                .limit(1);
+            if (payment) {
+                return { status: "has_payments", invoice: existing };
+            }
+            const [creditNote] = await tx
+                .select({ id: creditNotes.id })
+                .from(creditNotes)
+                .where(eq(creditNotes.invoiceId, id))
+                .limit(1);
+            if (creditNote) {
+                return { status: "has_credit_notes", invoice: existing };
+            }
+            const changes = {
+                status: "void",
+                voidedAt,
+                voidReason: reason,
+                balanceDueCents: 0,
+                baseBalanceDueCents: existing.baseBalanceDueCents == null ? null : 0,
+                updatedAt: voidedAt,
+            };
+            const actionLedgerChanges = {
+                status: "void",
+                balanceDueCents: changes.balanceDueCents,
+                baseBalanceDueCents: changes.baseBalanceDueCents,
+            };
+            const [invoice] = await tx
+                .update(invoices)
+                .set(changes)
+                .where(eq(invoices.id, id))
+                .returning();
+            if (!invoice) {
+                return { status: "not_found" };
+            }
+            const actionLedgerContext = runtime.actionLedgerContext;
+            if (actionLedgerContext) {
+                await appendActionLedgerMutation(tx, buildInvoiceUpdateActionLedgerInput(actionLedgerContext, { invoice, changes: actionLedgerChanges }, { authorizationSource: runtime.actionLedgerAuthorizationSource }));
+            }
+            return { status: "voided", invoice };
+        });
+        if (result.status === "voided" && runtime.eventBus) {
+            const [smartbillRef] = await db
+                .select()
+                .from(invoiceExternalRefs)
+                .where(and(eq(invoiceExternalRefs.invoiceId, result.invoice.id), eq(invoiceExternalRefs.provider, "smartbill")))
+                .orderBy(desc(invoiceExternalRefs.createdAt))
+                .limit(1);
+            const [externalRef] = smartbillRef
+                ? [smartbillRef]
+                : await db
+                    .select()
+                    .from(invoiceExternalRefs)
+                    .where(eq(invoiceExternalRefs.invoiceId, result.invoice.id))
+                    .orderBy(desc(invoiceExternalRefs.createdAt))
+                    .limit(1);
+            const [series] = result.invoice.seriesId
+                ? await db
+                    .select({ name: invoiceNumberSeries.name })
+                    .from(invoiceNumberSeries)
+                    .where(eq(invoiceNumberSeries.id, result.invoice.seriesId))
+                    .limit(1)
+                : [];
+            const event = {
+                invoiceId: result.invoice.id,
+                invoiceNumber: result.invoice.invoiceNumber,
+                invoiceType: result.invoice.invoiceType,
+                bookingId: result.invoice.bookingId,
+                totalCents: result.invoice.totalCents,
+                currency: result.invoice.currency,
+                reason,
+                voidedAt: result.invoice.voidedAt?.toISOString() ?? voidedAt.toISOString(),
+                externalProvider: externalRef?.provider ?? null,
+                externalNumber: externalRef?.externalNumber ?? null,
+                externalSeriesName: readStringMetadata(externalRef?.metadata, "seriesName") ??
+                    readStringMetadata(externalRef?.metadata, "series") ??
+                    series?.name ??
+                    null,
+            };
+            await runtime.eventBus.emit("invoice.voided", event);
+        }
+        return result;
+    },
+};