@voyantjs/checkout 0.1.0

package/LICENSE

@@ -0,0 +1,109 @@
+# Functional Source License, Version 1.1, Apache 2.0 Future License
+
+## Abbreviation
+
+FSL-1.1-Apache-2.0
+
+## Notice
+
+Copyright 2026 PixelMakers Studio SRL
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly
+display and redistribute the Software for any Permitted Purpose identified
+below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing
+Use means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe
+our patents, the license grant above includes a license under our patents.
+If you make a claim against any party that the Software infringes or
+contributes to the infringement of any patent, then your patent license to
+the Software ends immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives
+of the Software.
+
+If you redistribute any copies, modifications or derivatives of the
+Software, you must include a copy of or a link to these Terms and Conditions
+and not remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A
+PARTICULAR PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO
+THE SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL
+DAMAGES, EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin
+of the Software, you have no right under these Terms and Conditions to use
+our trademarks, trade names, service marks or product names.
+
+---
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software
+under the Apache License, Version 2.0 that is effective on the second
+anniversary of the date we make the Software available. On or after that
+date, you may use the Software under the Apache License, Version 2.0, in
+which case the following will apply:
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not
+use this file except in compliance with the License.
+
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+License for the specific language governing permissions and limitations
+under the License.

package/README.md

@@ -0,0 +1,24 @@
+# @voyantjs/checkout
+
+Optional checkout and collection orchestration for Voyant.
+
+This package sits above `@voyantjs/finance` and `@voyantjs/notifications`. It does not implement payment providers. Instead, it decides which booking schedule or invoice to collect, creates the right finance record, and optionally sends the corresponding notification.
+
+## What it does
+
+- previews a booking collection plan
+- creates bank-transfer collection documents (`proforma` by default)
+- creates card collection `payment_sessions`
+- supports schedule-backed or invoice-backed card collection
+- optionally sends invoice or payment-session notifications
+
+## Routes
+
+- `POST /v1/checkout/bookings/:bookingId/collection-plan`
+- `POST /v1/checkout/bookings/:bookingId/initiate-collection`
+
+## Notes
+
+- payment-provider plugins like Netopia remain optional
+- email-provider choice remains app-owned
+- projects can override the default collection policy when mounting the routes

package/dist/src/index.d.ts

@@ -0,0 +1,6 @@
+export { createCheckoutRoutes } from "./routes.js";
+export { initiateCheckoutCollection, previewCheckoutCollection, resolvePaymentSessionTarget, } from "./service.js";
+export type { CheckoutCollectionPlan, CheckoutPolicyOptions, InitiatedCheckoutCollection, } from "./service.js";
+export { checkoutCollectionMethodSchema, checkoutCollectionStageSchema, checkoutInvoiceDocumentTypeSchema, checkoutPaymentSessionTargetSchema, initiateCheckoutCollectionSchema, previewCheckoutCollectionSchema, } from "./validation.js";
+export type { InitiateCheckoutCollectionInput, PreviewCheckoutCollectionInput, } from "./validation.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAClD,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,2BAA2B,GAC5B,MAAM,cAAc,CAAA;AACrB,YAAY,EACV,sBAAsB,EACtB,qBAAqB,EACrB,2BAA2B,GAC5B,MAAM,cAAc,CAAA;AACrB,OAAO,EACL,8BAA8B,EAC9B,6BAA6B,EAC7B,iCAAiC,EACjC,kCAAkC,EAClC,gCAAgC,EAChC,+BAA+B,GAChC,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACV,+BAA+B,EAC/B,8BAA8B,GAC/B,MAAM,iBAAiB,CAAA"}

package/dist/src/index.js

@@ -0,0 +1,3 @@
+export { createCheckoutRoutes } from "./routes.js";
+export { initiateCheckoutCollection, previewCheckoutCollection, resolvePaymentSessionTarget, } from "./service.js";
+export { checkoutCollectionMethodSchema, checkoutCollectionStageSchema, checkoutInvoiceDocumentTypeSchema, checkoutPaymentSessionTargetSchema, initiateCheckoutCollectionSchema, previewCheckoutCollectionSchema, } from "./validation.js";

package/dist/src/routes.d.ts

@@ -0,0 +1,355 @@
+import type { NotificationProvider } from "@voyantjs/notifications";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type CheckoutPolicyOptions } from "./service.js";
+type Env = {
+    Bindings: Record<string, unknown>;
+    Variables: {
+        db: PostgresJsDatabase;
+        userId?: string;
+    };
+};
+export declare function createCheckoutRoutes(options?: {
+    policy?: CheckoutPolicyOptions;
+    providers?: ReadonlyArray<NotificationProvider>;
+    resolveProviders?: (bindings: Record<string, unknown>) => ReadonlyArray<NotificationProvider>;
+}): import("hono/hono-base").HonoBase<Env, {
+    "/v1/checkout/bookings/:bookingId/collection-plan": {
+        $post: {
+            input: {
+                param: {
+                    bookingId: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    bookingId: string;
+                };
+            };
+            output: {
+                data: {
+                    bookingId: string;
+                    method: "card" | "bank_transfer";
+                    stage: "initial" | "reminder" | "manual";
+                    paymentSessionTarget: "schedule" | "invoice" | null;
+                    documentType: "proforma" | "invoice" | null;
+                    willCreateDefaultPaymentPlan: boolean;
+                    selectedSchedule: {
+                        id: string;
+                        status: "cancelled" | "expired" | "pending" | "paid" | "due" | "waived";
+                        notes: string | null;
+                        createdAt: string;
+                        updatedAt: string;
+                        bookingId: string;
+                        bookingItemId: string | null;
+                        currency: string;
+                        dueDate: string;
+                        scheduleType: "other" | "deposit" | "installment" | "balance" | "hold";
+                        amountCents: number;
+                    } | null;
+                    selectedInvoice: {
+                        id: string;
+                        status: "draft" | "sent" | "partially_paid" | "paid" | "overdue" | "void";
+                        notes: string | null;
+                        createdAt: string;
+                        updatedAt: string;
+                        personId: string | null;
+                        organizationId: string | null;
+                        baseCurrency: string | null;
+                        bookingId: string;
+                        invoiceNumber: string;
+                        invoiceType: "invoice" | "proforma" | "credit_note";
+                        seriesId: string | null;
+                        sequence: number | null;
+                        templateId: string | null;
+                        taxRegimeId: string | null;
+                        language: string | null;
+                        currency: string;
+                        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;
+                    } | null;
+                    amountCents: number;
+                    currency: string;
+                    recommendedAction: "create_bank_transfer_document" | "create_payment_session" | "create_invoice_then_payment_session" | "none";
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {
+                param: {
+                    bookingId: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        };
+    };
+} & {
+    "/v1/checkout/bookings/:bookingId/initiate-collection": {
+        $post: {
+            input: {
+                param: {
+                    bookingId: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    bookingId: string;
+                };
+            };
+            output: {
+                data: {
+                    plan: {
+                        bookingId: string;
+                        method: "card" | "bank_transfer";
+                        stage: "initial" | "reminder" | "manual";
+                        paymentSessionTarget: "schedule" | "invoice" | null;
+                        documentType: "proforma" | "invoice" | null;
+                        willCreateDefaultPaymentPlan: boolean;
+                        selectedSchedule: {
+                            id: string;
+                            status: "cancelled" | "expired" | "pending" | "paid" | "due" | "waived";
+                            notes: string | null;
+                            createdAt: string;
+                            updatedAt: string;
+                            bookingId: string;
+                            bookingItemId: string | null;
+                            currency: string;
+                            dueDate: string;
+                            scheduleType: "other" | "deposit" | "installment" | "balance" | "hold";
+                            amountCents: number;
+                        } | null;
+                        selectedInvoice: {
+                            id: string;
+                            status: "draft" | "sent" | "partially_paid" | "paid" | "overdue" | "void";
+                            notes: string | null;
+                            createdAt: string;
+                            updatedAt: string;
+                            personId: string | null;
+                            organizationId: string | null;
+                            baseCurrency: string | null;
+                            bookingId: string;
+                            invoiceNumber: string;
+                            invoiceType: "invoice" | "proforma" | "credit_note";
+                            seriesId: string | null;
+                            sequence: number | null;
+                            templateId: string | null;
+                            taxRegimeId: string | null;
+                            language: string | null;
+                            currency: string;
+                            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;
+                        } | null;
+                        amountCents: number;
+                        currency: string;
+                        recommendedAction: "create_bank_transfer_document" | "create_payment_session" | "create_invoice_then_payment_session" | "none";
+                    };
+                    invoice: {
+                        id: string;
+                        status: "draft" | "sent" | "partially_paid" | "paid" | "overdue" | "void";
+                        notes: string | null;
+                        createdAt: string;
+                        updatedAt: string;
+                        personId: string | null;
+                        organizationId: string | null;
+                        baseCurrency: string | null;
+                        bookingId: string;
+                        invoiceNumber: string;
+                        invoiceType: "invoice" | "proforma" | "credit_note";
+                        seriesId: string | null;
+                        sequence: number | null;
+                        templateId: string | null;
+                        taxRegimeId: string | null;
+                        language: string | null;
+                        currency: string;
+                        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;
+                    } | null;
+                    paymentSession: {
+                        id: string;
+                        status: "cancelled" | "expired" | "pending" | "failed" | "paid" | "requires_redirect" | "processing" | "authorized";
+                        notes: string | null;
+                        createdAt: string;
+                        updatedAt: string;
+                        expiredAt: string | null;
+                        cancelledAt: string | null;
+                        completedAt: string | null;
+                        bookingId: string | null;
+                        metadata: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
+                        expiresAt: string | null;
+                        provider: string | null;
+                        targetType: "other" | "booking" | "order" | "invoice" | "booking_payment_schedule" | "booking_guarantee";
+                        targetId: string | null;
+                        orderId: string | null;
+                        currency: string;
+                        invoiceId: string | null;
+                        amountCents: number;
+                        bookingPaymentScheduleId: string | null;
+                        paymentInstrumentId: string | null;
+                        bookingGuaranteeId: string | null;
+                        paymentAuthorizationId: string | null;
+                        paymentCaptureId: string | null;
+                        paymentMethod: "other" | "voucher" | "wallet" | "bank_transfer" | "credit_card" | "debit_card" | "cash" | "cheque" | "direct_bill" | null;
+                        paymentId: string | null;
+                        providerSessionId: string | null;
+                        providerPaymentId: string | null;
+                        externalReference: string | null;
+                        idempotencyKey: string | null;
+                        clientReference: string | null;
+                        payerPersonId: string | null;
+                        payerOrganizationId: string | null;
+                        payerEmail: string | null;
+                        payerName: string | null;
+                        redirectUrl: string | null;
+                        returnUrl: string | null;
+                        cancelUrl: string | null;
+                        callbackUrl: string | null;
+                        failedAt: string | null;
+                        failureCode: string | null;
+                        failureMessage: string | null;
+                        providerPayload: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
+                    } | null;
+                    invoiceNotification: {
+                        id: string;
+                        status: "cancelled" | "pending" | "failed" | "sent";
+                        createdAt: string;
+                        updatedAt: string;
+                        personId: string | null;
+                        organizationId: string | null;
+                        bookingId: string | null;
+                        metadata: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
+                        channel: "email" | "sms";
+                        provider: string;
+                        targetType: "other" | "booking" | "invoice" | "booking_payment_schedule" | "booking_guarantee" | "payment_session" | "person" | "organization";
+                        targetId: string | null;
+                        templateId: string | null;
+                        invoiceId: string | null;
+                        failedAt: string | null;
+                        errorMessage: string | null;
+                        fromAddress: string | null;
+                        templateSlug: string | null;
+                        paymentSessionId: string | null;
+                        providerMessageId: string | null;
+                        toAddress: string;
+                        subject: string | null;
+                        htmlBody: string | null;
+                        textBody: string | null;
+                        payloadData: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
+                        scheduledFor: string | null;
+                        sentAt: string | null;
+                    } | null;
+                    paymentSessionNotification: {
+                        id: string;
+                        status: "cancelled" | "pending" | "failed" | "sent";
+                        createdAt: string;
+                        updatedAt: string;
+                        personId: string | null;
+                        organizationId: string | null;
+                        bookingId: string | null;
+                        metadata: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
+                        channel: "email" | "sms";
+                        provider: string;
+                        targetType: "other" | "booking" | "invoice" | "booking_payment_schedule" | "booking_guarantee" | "payment_session" | "person" | "organization";
+                        targetId: string | null;
+                        templateId: string | null;
+                        invoiceId: string | null;
+                        failedAt: string | null;
+                        errorMessage: string | null;
+                        fromAddress: string | null;
+                        templateSlug: string | null;
+                        paymentSessionId: string | null;
+                        providerMessageId: string | null;
+                        toAddress: string;
+                        subject: string | null;
+                        htmlBody: string | null;
+                        textBody: string | null;
+                        payloadData: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
+                        scheduledFor: string | null;
+                        sentAt: string | null;
+                    } | null;
+                };
+            };
+            outputFormat: "json";
+            status: 201;
+        } | {
+            input: {
+                param: {
+                    bookingId: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 409;
+        };
+    };
+}, "/", "/v1/checkout/bookings/:bookingId/initiate-collection">;
+export {};
+//# sourceMappingURL=routes.d.ts.map

package/dist/src/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/routes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,OAAO,EAGL,KAAK,qBAAqB,EAC3B,MAAM,cAAc,CAAA;AAMrB,KAAK,GAAG,GAAG;IACT,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACjC,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,wBAAgB,oBAAoB,CAAC,OAAO,GAAE;IAC5C,MAAM,CAAC,EAAE,qBAAqB,CAAA;IAC9B,SAAS,CAAC,EAAE,aAAa,CAAC,oBAAoB,CAAC,CAAA;IAC/C,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,aAAa,CAAC,oBAAoB,CAAC,CAAA;CACzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEA+CL"}

package/dist/src/routes.js

@@ -0,0 +1,37 @@
+import { createNotificationService } from "@voyantjs/notifications";
+import { Hono } from "hono";
+import { initiateCheckoutCollection, previewCheckoutCollection, } from "./service.js";
+import { initiateCheckoutCollectionSchema, previewCheckoutCollectionSchema, } from "./validation.js";
+export function createCheckoutRoutes(options = {}) {
+    return new Hono()
+        .post("/v1/checkout/bookings/:bookingId/collection-plan", async (c) => {
+        try {
+            const plan = await previewCheckoutCollection(c.get("db"), c.req.param("bookingId"), previewCheckoutCollectionSchema.parse(await c.req.json().catch(() => ({}))), options.policy);
+            if (!plan) {
+                return c.json({ error: "Booking not found" }, 404);
+            }
+            return c.json({ data: plan });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Failed to preview checkout collection";
+            return c.json({ error: message }, 400);
+        }
+    })
+        .post("/v1/checkout/bookings/:bookingId/initiate-collection", async (c) => {
+        try {
+            const dispatcher = createNotificationService(options.resolveProviders?.(c.env) ?? options.providers ?? []);
+            const result = await initiateCheckoutCollection(c.get("db"), c.req.param("bookingId"), initiateCheckoutCollectionSchema.parse(await c.req.json()), options.policy, dispatcher);
+            if (!result) {
+                return c.json({ error: "Booking not found" }, 404);
+            }
+            return c.json({ data: result }, 201);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Failed to initiate checkout collection";
+            if (message.includes("Booking not found")) {
+                return c.json({ error: message }, 404);
+            }
+            return c.json({ error: message }, 409);
+        }
+    });
+}

package/dist/src/service.d.ts

@@ -0,0 +1,42 @@
+import { bookingPaymentSchedules, invoices, type PaymentSession } from "@voyantjs/finance";
+import type { NotificationDelivery, NotificationService } from "@voyantjs/notifications";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { InitiateCheckoutCollectionInput, PreviewCheckoutCollectionInput } from "./validation.js";
+export interface CheckoutPolicyOptions {
+    defaultCardCollectionTarget?: "schedule" | "invoice";
+    defaultReminderCardCollectionTarget?: "schedule" | "invoice";
+    defaultBankTransferDocumentType?: "proforma" | "invoice";
+    defaultPaymentPlan?: {
+        depositMode: "none" | "percentage" | "fixed_amount";
+        depositValue: number;
+        balanceDueDaysBeforeStart: number;
+        clearExistingPending: boolean;
+        createGuarantee: boolean;
+        guaranteeType: "deposit" | "credit_card" | "preauth" | "card_on_file" | "bank_transfer" | "voucher" | "agency_letter";
+        notes?: string | null;
+    };
+}
+export interface CheckoutCollectionPlan {
+    bookingId: string;
+    method: "card" | "bank_transfer";
+    stage: "initial" | "reminder" | "manual";
+    paymentSessionTarget: "schedule" | "invoice" | null;
+    documentType: "proforma" | "invoice" | null;
+    willCreateDefaultPaymentPlan: boolean;
+    selectedSchedule: typeof bookingPaymentSchedules.$inferSelect | null;
+    selectedInvoice: typeof invoices.$inferSelect | null;
+    amountCents: number;
+    currency: string;
+    recommendedAction: "create_bank_transfer_document" | "create_payment_session" | "create_invoice_then_payment_session" | "none";
+}
+export interface InitiatedCheckoutCollection {
+    plan: CheckoutCollectionPlan;
+    invoice: typeof invoices.$inferSelect | null;
+    paymentSession: PaymentSession | null;
+    invoiceNotification: NotificationDelivery | null;
+    paymentSessionNotification: NotificationDelivery | null;
+}
+export declare function resolvePaymentSessionTarget(method: "card" | "bank_transfer", stage: "initial" | "reminder" | "manual", override: "schedule" | "invoice" | undefined, options: CheckoutPolicyOptions): "invoice" | "schedule";
+export declare function previewCheckoutCollection(db: PostgresJsDatabase, bookingId: string, input: PreviewCheckoutCollectionInput, options?: CheckoutPolicyOptions): Promise<CheckoutCollectionPlan | null>;
+export declare function initiateCheckoutCollection(db: PostgresJsDatabase, bookingId: string, input: InitiateCheckoutCollectionInput, options?: CheckoutPolicyOptions, dispatcher?: NotificationService): Promise<InitiatedCheckoutCollection | null>;
+//# sourceMappingURL=service.d.ts.map

package/dist/src/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/service.ts"],"names":[],"mappings":"AACA,OAAO,EACL,uBAAuB,EAIvB,QAAQ,EACR,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,yBAAyB,CAAA;AAGhC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,KAAK,EACV,+BAA+B,EAC/B,8BAA8B,EAC/B,MAAM,iBAAiB,CAAA;AAExB,MAAM,WAAW,qBAAqB;IACpC,2BAA2B,CAAC,EAAE,UAAU,GAAG,SAAS,CAAA;IACpD,mCAAmC,CAAC,EAAE,UAAU,GAAG,SAAS,CAAA;IAC5D,+BAA+B,CAAC,EAAE,UAAU,GAAG,SAAS,CAAA;IACxD,kBAAkB,CAAC,EAAE;QACnB,WAAW,EAAE,MAAM,GAAG,YAAY,GAAG,cAAc,CAAA;QACnD,YAAY,EAAE,MAAM,CAAA;QACpB,yBAAyB,EAAE,MAAM,CAAA;QACjC,oBAAoB,EAAE,OAAO,CAAA;QAC7B,eAAe,EAAE,OAAO,CAAA;QACxB,aAAa,EAAE,SAAS,GAAG,aAAa,GAAG,SAAS,GAAG,cAAc,GAAG,eAAe,GAAG,SAAS,GAAG,eAAe,CAAA;QACrH,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KACtB,CAAA;CACF;AAUD,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,GAAG,eAAe,CAAA;IAChC,KAAK,EAAE,SAAS,GAAG,UAAU,GAAG,QAAQ,CAAA;IACxC,oBAAoB,EAAE,UAAU,GAAG,SAAS,GAAG,IAAI,CAAA;IACnD,YAAY,EAAE,UAAU,GAAG,SAAS,GAAG,IAAI,CAAA;IAC3C,4BAA4B,EAAE,OAAO,CAAA;IACrC,gBAAgB,EAAE,OAAO,uBAAuB,CAAC,YAAY,GAAG,IAAI,CAAA;IACpE,eAAe,EAAE,OAAO,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAA;IACpD,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;IAChB,iBAAiB,EACb,+BAA+B,GAC/B,wBAAwB,GACxB,qCAAqC,GACrC,MAAM,CAAA;CACX;AAED,MAAM,WAAW,2BAA2B;IAC1C,IAAI,EAAE,sBAAsB,CAAA;IAC5B,OAAO,EAAE,OAAO,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAA;IAC5C,cAAc,EAAE,cAAc,GAAG,IAAI,CAAA;IACrC,mBAAmB,EAAE,oBAAoB,GAAG,IAAI,CAAA;IAChD,0BAA0B,EAAE,oBAAoB,GAAG,IAAI,CAAA;CACxD;AAyBD,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,MAAM,GAAG,eAAe,EAChC,KAAK,EAAE,SAAS,GAAG,UAAU,GAAG,QAAQ,EACxC,QAAQ,EAAE,UAAU,GAAG,SAAS,GAAG,SAAS,EAC5C,OAAO,EAAE,qBAAqB,0BAM/B;AAoJD,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,kBAAkB,EACtB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,8BAA8B,EACrC,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAmDxC;AAkED,wBAAsB,0BAA0B,CAC9C,EAAE,EAAE,kBAAkB,EACtB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,+BAA+B,EACtC,OAAO,GAAE,qBAA0B,EACnC,UAAU,CAAC,EAAE,mBAAmB,GAC/B,OAAO,CAAC,2BAA2B,GAAG,IAAI,CAAC,CA4F7C"}

package/dist/src/service.js

@@ -0,0 +1,276 @@
+import { bookingItems, bookingParticipants, bookings } from "@voyantjs/bookings";
+import { bookingPaymentSchedules, financeService, invoiceLineItems, invoiceNumberSeries, invoices, } from "@voyantjs/finance";
+import { notificationsService } from "@voyantjs/notifications";
+import { and, asc, desc, eq, gt, inArray } from "drizzle-orm";
+const OUTSTANDING_SCHEDULE_STATUSES = [
+    "pending",
+    "due",
+];
+const OUTSTANDING_INVOICE_STATUSES = [
+    "draft",
+    "sent",
+    "partially_paid",
+    "overdue",
+];
+function defaultPaymentPlan(options) {
+    return {
+        depositMode: options.defaultPaymentPlan?.depositMode ?? "percentage",
+        depositValue: options.defaultPaymentPlan?.depositValue ?? 30,
+        balanceDueDaysBeforeStart: options.defaultPaymentPlan?.balanceDueDaysBeforeStart ?? 30,
+        clearExistingPending: options.defaultPaymentPlan?.clearExistingPending ?? true,
+        createGuarantee: options.defaultPaymentPlan?.createGuarantee ?? false,
+        guaranteeType: options.defaultPaymentPlan?.guaranteeType ?? "deposit",
+        notes: options.defaultPaymentPlan?.notes ?? null,
+    };
+}
+export function resolvePaymentSessionTarget(method, stage, override, options) {
+    if (method === "bank_transfer")
+        return "invoice";
+    if (override)
+        return override;
+    if (stage === "reminder")
+        return options.defaultReminderCardCollectionTarget ?? "schedule";
+    return options.defaultCardCollectionTarget ?? "schedule";
+}
+function resolveDocumentType(method, target, options) {
+    if (method === "bank_transfer") {
+        return options.defaultBankTransferDocumentType ?? "proforma";
+    }
+    if (target === "invoice") {
+        return "invoice";
+    }
+    return null;
+}
+function fallbackInvoiceNumber(bookingNumber, documentType, amountCents) {
+    const stamp = Date.now().toString(36).toUpperCase();
+    const suffix = documentType === "proforma" ? "PF" : "INV";
+    return `${bookingNumber}-${suffix}-${amountCents}-${stamp}`;
+}
+function lineDescription(booking, schedule, stage) {
+    if (!schedule) {
+        return `Booking ${booking.bookingNumber}`;
+    }
+    const kind = schedule.scheduleType === "deposit" ? "deposit" : schedule.scheduleType;
+    if (stage === "reminder") {
+        return `Booking ${booking.bookingNumber} ${kind} reminder`;
+    }
+    return `Booking ${booking.bookingNumber} ${kind}`;
+}
+async function loadBookingContext(db, bookingId) {
+    const [booking] = await db.select().from(bookings).where(eq(bookings.id, bookingId)).limit(1);
+    if (!booking)
+        return null;
+    const [items, participants, schedules, outstandingInvoices] = await Promise.all([
+        db.select().from(bookingItems).where(eq(bookingItems.bookingId, bookingId)).orderBy(bookingItems.createdAt),
+        db
+            .select()
+            .from(bookingParticipants)
+            .where(eq(bookingParticipants.bookingId, bookingId))
+            .orderBy(desc(bookingParticipants.isPrimary), bookingParticipants.createdAt),
+        db
+            .select()
+            .from(bookingPaymentSchedules)
+            .where(and(eq(bookingPaymentSchedules.bookingId, bookingId), inArray(bookingPaymentSchedules.status, OUTSTANDING_SCHEDULE_STATUSES)))
+            .orderBy(asc(bookingPaymentSchedules.dueDate), asc(bookingPaymentSchedules.createdAt)),
+        db
+            .select()
+            .from(invoices)
+            .where(and(eq(invoices.bookingId, bookingId), inArray(invoices.status, OUTSTANDING_INVOICE_STATUSES), gt(invoices.balanceDueCents, 0)))
+            .orderBy(desc(invoices.createdAt)),
+    ]);
+    return {
+        booking,
+        items,
+        participants,
+        schedules,
+        outstandingInvoices,
+    };
+}
+async function ensurePaymentPlanIfNeeded(db, bookingId, existingSchedules, input, options) {
+    if (existingSchedules.length > 0 || !input.ensureDefaultPaymentPlan) {
+        return existingSchedules;
+    }
+    const created = await financeService.applyDefaultBookingPaymentPlan(db, bookingId, {
+        ...defaultPaymentPlan(options),
+        ...(input.paymentPlan ?? {}),
+    });
+    return created ?? [];
+}
+async function allocateDocumentNumber(db, bookingNumber, documentType, amountCents) {
+    const [series] = await db
+        .select()
+        .from(invoiceNumberSeries)
+        .where(eq(invoiceNumberSeries.scope, documentType))
+        .orderBy(desc(invoiceNumberSeries.active), asc(invoiceNumberSeries.createdAt))
+        .limit(1);
+    if (!series) {
+        return fallbackInvoiceNumber(bookingNumber, documentType, amountCents);
+    }
+    const allocated = await financeService.allocateInvoiceNumber(db, series.id);
+    if (allocated.status === "allocated") {
+        return allocated.formattedNumber;
+    }
+    return fallbackInvoiceNumber(bookingNumber, documentType, amountCents);
+}
+function pickSchedule(schedules, scheduleId) {
+    if (scheduleId) {
+        return schedules.find((schedule) => schedule.id === scheduleId) ?? null;
+    }
+    return schedules[0] ?? null;
+}
+function pickInvoice(outstandingInvoices, invoiceId) {
+    if (invoiceId) {
+        return outstandingInvoices.find((invoice) => invoice.id === invoiceId) ?? null;
+    }
+    return outstandingInvoices[0] ?? null;
+}
+export async function previewCheckoutCollection(db, bookingId, input, options = {}) {
+    const context = await loadBookingContext(db, bookingId);
+    if (!context)
+        return null;
+    const schedules = await ensurePaymentPlanIfNeeded(db, bookingId, context.schedules, input, options);
+    const paymentSessionTarget = resolvePaymentSessionTarget(input.method, input.stage, input.paymentSessionTarget, options);
+    const documentType = resolveDocumentType(input.method, paymentSessionTarget, options);
+    const selectedSchedule = pickSchedule(schedules, input.scheduleId);
+    const selectedInvoice = pickInvoice(context.outstandingInvoices, input.invoiceId);
+    let amountCents = 0;
+    if (paymentSessionTarget === "invoice") {
+        amountCents = selectedInvoice?.balanceDueCents ?? selectedSchedule?.amountCents ?? context.booking.sellAmountCents ?? 0;
+    }
+    else if (paymentSessionTarget === "schedule") {
+        amountCents = selectedSchedule?.amountCents ?? context.booking.sellAmountCents ?? 0;
+    }
+    let recommendedAction = "none";
+    if (input.method === "bank_transfer") {
+        recommendedAction = "create_bank_transfer_document";
+    }
+    else if (paymentSessionTarget === "invoice") {
+        recommendedAction = selectedInvoice ? "create_payment_session" : "create_invoice_then_payment_session";
+    }
+    else if (paymentSessionTarget === "schedule") {
+        recommendedAction = "create_payment_session";
+    }
+    return {
+        bookingId,
+        method: input.method,
+        stage: input.stage,
+        paymentSessionTarget,
+        documentType,
+        willCreateDefaultPaymentPlan: context.schedules.length === 0 && schedules.length > 0,
+        selectedSchedule,
+        selectedInvoice,
+        amountCents,
+        currency: context.booking.sellCurrency,
+        recommendedAction,
+    };
+}
+async function createCollectionInvoice(db, context, plan, notes) {
+    const amountCents = plan.amountCents;
+    const issueDate = new Date().toISOString().slice(0, 10);
+    const dueDate = plan.selectedSchedule?.dueDate ?? issueDate;
+    const documentType = plan.documentType ?? "invoice";
+    const invoiceNumber = await allocateDocumentNumber(db, context.booking.bookingNumber, documentType, amountCents);
+    const [invoice] = await db
+        .insert(invoices)
+        .values({
+        invoiceNumber,
+        bookingId: context.booking.id,
+        personId: context.booking.personId,
+        organizationId: context.booking.organizationId,
+        invoiceType: documentType,
+        status: "sent",
+        currency: context.booking.sellCurrency,
+        baseCurrency: context.booking.baseCurrency,
+        fxRateSetId: null,
+        subtotalCents: amountCents,
+        baseSubtotalCents: context.booking.baseSellAmountCents,
+        taxCents: 0,
+        baseTaxCents: null,
+        totalCents: amountCents,
+        baseTotalCents: context.booking.baseSellAmountCents,
+        paidCents: 0,
+        basePaidCents: 0,
+        balanceDueCents: amountCents,
+        baseBalanceDueCents: context.booking.baseSellAmountCents,
+        commissionAmountCents: null,
+        issueDate,
+        dueDate,
+        notes: notes ?? plan.selectedSchedule?.notes ?? null,
+    })
+        .returning();
+    if (!invoice) {
+        throw new Error("Failed to create collection invoice");
+    }
+    await db.insert(invoiceLineItems).values({
+        invoiceId: invoice.id,
+        bookingItemId: plan.selectedSchedule?.bookingItemId ?? null,
+        description: lineDescription(context.booking, plan.selectedSchedule, plan.stage),
+        quantity: 1,
+        unitPriceCents: amountCents,
+        totalCents: amountCents,
+        taxRate: null,
+        sortOrder: 0,
+    });
+    return invoice;
+}
+export async function initiateCheckoutCollection(db, bookingId, input, options = {}, dispatcher) {
+    const context = await loadBookingContext(db, bookingId);
+    if (!context)
+        return null;
+    const plan = await previewCheckoutCollection(db, bookingId, input, options);
+    if (!plan)
+        return null;
+    if (plan.amountCents <= 0) {
+        throw new Error("No outstanding amount available for collection");
+    }
+    let invoice = plan.selectedInvoice;
+    let paymentSession = null;
+    let invoiceNotification = null;
+    let paymentSessionNotification = null;
+    if (input.method === "bank_transfer") {
+        invoice = await createCollectionInvoice(db, context, plan, input.notes ?? null);
+        if (dispatcher && input.invoiceNotification) {
+            invoiceNotification = await notificationsService.sendInvoiceNotification(db, dispatcher, invoice.id, input.invoiceNotification);
+        }
+    }
+    else if (plan.paymentSessionTarget === "invoice") {
+        if (!invoice) {
+            invoice = await createCollectionInvoice(db, context, { ...plan, documentType: "invoice" }, input.notes ?? null);
+        }
+        paymentSession = await financeService.createPaymentSessionFromInvoice(db, invoice.id, {
+            ...(input.paymentSession ?? {}),
+            notes: input.notes ?? input.paymentSession?.notes ?? null,
+        });
+        if (!paymentSession) {
+            throw new Error("Failed to create payment session from invoice");
+        }
+        if (dispatcher && input.invoiceNotification) {
+            invoiceNotification = await notificationsService.sendInvoiceNotification(db, dispatcher, invoice.id, input.invoiceNotification);
+        }
+        if (dispatcher && input.paymentSessionNotification) {
+            paymentSessionNotification = await notificationsService.sendPaymentSessionNotification(db, dispatcher, paymentSession.id, input.paymentSessionNotification);
+        }
+    }
+    else {
+        if (!plan.selectedSchedule) {
+            throw new Error("No outstanding payment schedule available for collection");
+        }
+        paymentSession = await financeService.createPaymentSessionFromBookingSchedule(db, plan.selectedSchedule.id, {
+            ...(input.paymentSession ?? {}),
+            notes: input.notes ?? input.paymentSession?.notes ?? null,
+        });
+        if (!paymentSession) {
+            throw new Error("Failed to create payment session from booking schedule");
+        }
+        if (dispatcher && input.paymentSessionNotification) {
+            paymentSessionNotification = await notificationsService.sendPaymentSessionNotification(db, dispatcher, paymentSession.id, input.paymentSessionNotification);
+        }
+    }
+    return {
+        plan,
+        invoice: invoice ?? null,
+        paymentSession,
+        invoiceNotification,
+        paymentSessionNotification,
+    };
+}

package/dist/src/validation.d.ts

@@ -0,0 +1,193 @@
+import { z } from "zod";
+export declare const checkoutCollectionMethodSchema: z.ZodEnum<{
+    bank_transfer: "bank_transfer";
+    card: "card";
+}>;
+export declare const checkoutCollectionStageSchema: z.ZodEnum<{
+    manual: "manual";
+    initial: "initial";
+    reminder: "reminder";
+}>;
+export declare const checkoutPaymentSessionTargetSchema: z.ZodEnum<{
+    invoice: "invoice";
+    schedule: "schedule";
+}>;
+export declare const checkoutInvoiceDocumentTypeSchema: z.ZodEnum<{
+    invoice: "invoice";
+    proforma: "proforma";
+}>;
+export declare const previewCheckoutCollectionSchema: z.ZodObject<{
+    method: z.ZodEnum<{
+        bank_transfer: "bank_transfer";
+        card: "card";
+    }>;
+    stage: z.ZodDefault<z.ZodEnum<{
+        manual: "manual";
+        initial: "initial";
+        reminder: "reminder";
+    }>>;
+    scheduleId: z.ZodOptional<z.ZodString>;
+    invoiceId: z.ZodOptional<z.ZodString>;
+    ensureDefaultPaymentPlan: z.ZodDefault<z.ZodBoolean>;
+    paymentSessionTarget: z.ZodOptional<z.ZodEnum<{
+        invoice: "invoice";
+        schedule: "schedule";
+    }>>;
+    paymentPlan: z.ZodOptional<z.ZodObject<{
+        depositMode: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            percentage: "percentage";
+            none: "none";
+            fixed_amount: "fixed_amount";
+        }>>>;
+        depositValue: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        depositDueDate: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+        balanceDueDaysBeforeStart: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        clearExistingPending: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        createGuarantee: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        guaranteeType: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            other: "other";
+            voucher: "voucher";
+            bank_transfer: "bank_transfer";
+            credit_card: "credit_card";
+            deposit: "deposit";
+            preauth: "preauth";
+            card_on_file: "card_on_file";
+            agency_letter: "agency_letter";
+        }>>>;
+        notes: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const initiateCheckoutCollectionSchema: z.ZodObject<{
+    method: z.ZodEnum<{
+        bank_transfer: "bank_transfer";
+        card: "card";
+    }>;
+    stage: z.ZodDefault<z.ZodEnum<{
+        manual: "manual";
+        initial: "initial";
+        reminder: "reminder";
+    }>>;
+    scheduleId: z.ZodOptional<z.ZodString>;
+    invoiceId: z.ZodOptional<z.ZodString>;
+    ensureDefaultPaymentPlan: z.ZodDefault<z.ZodBoolean>;
+    paymentSessionTarget: z.ZodOptional<z.ZodEnum<{
+        invoice: "invoice";
+        schedule: "schedule";
+    }>>;
+    paymentPlan: z.ZodOptional<z.ZodObject<{
+        depositMode: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            percentage: "percentage";
+            none: "none";
+            fixed_amount: "fixed_amount";
+        }>>>;
+        depositValue: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        depositDueDate: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+        balanceDueDaysBeforeStart: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        clearExistingPending: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        createGuarantee: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        guaranteeType: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            other: "other";
+            voucher: "voucher";
+            bank_transfer: "bank_transfer";
+            credit_card: "credit_card";
+            deposit: "deposit";
+            preauth: "preauth";
+            card_on_file: "card_on_file";
+            agency_letter: "agency_letter";
+        }>>>;
+        notes: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+    }, z.core.$strip>>;
+    paymentSession: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        provider: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        paymentMethod: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+            other: "other";
+            voucher: "voucher";
+            wallet: "wallet";
+            bank_transfer: "bank_transfer";
+            credit_card: "credit_card";
+            debit_card: "debit_card";
+            cash: "cash";
+            cheque: "cheque";
+            direct_bill: "direct_bill";
+        }>>>;
+        payerPersonId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        payerOrganizationId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        payerEmail: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        payerName: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        externalReference: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        idempotencyKey: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        clientReference: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        returnUrl: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        cancelUrl: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        callbackUrl: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        expiresAt: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        notes: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        providerPayload: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        metadata: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        provider: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        paymentMethod: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+            other: "other";
+            voucher: "voucher";
+            wallet: "wallet";
+            bank_transfer: "bank_transfer";
+            credit_card: "credit_card";
+            debit_card: "debit_card";
+            cash: "cash";
+            cheque: "cheque";
+            direct_bill: "direct_bill";
+        }>>>;
+        payerPersonId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        payerOrganizationId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        payerEmail: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        payerName: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        externalReference: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        idempotencyKey: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        clientReference: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        returnUrl: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        cancelUrl: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        callbackUrl: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        expiresAt: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        notes: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        providerPayload: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        metadata: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strip>]>>;
+    paymentSessionNotification: z.ZodOptional<z.ZodObject<{
+        templateId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        templateSlug: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        channel: z.ZodDefault<z.ZodEnum<{
+            email: "email";
+            sms: "sms";
+        }>>;
+        provider: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        to: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        from: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        subject: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        html: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        text: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        data: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        metadata: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        scheduledFor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>;
+    invoiceNotification: z.ZodOptional<z.ZodObject<{
+        templateId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        templateSlug: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        channel: z.ZodDefault<z.ZodEnum<{
+            email: "email";
+            sms: "sms";
+        }>>;
+        provider: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        to: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        from: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        subject: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        html: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        text: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        data: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        metadata: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        scheduledFor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>;
+    notes: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export type PreviewCheckoutCollectionInput = z.infer<typeof previewCheckoutCollectionSchema>;
+export type InitiateCheckoutCollectionInput = z.infer<typeof initiateCheckoutCollectionSchema>;
+//# sourceMappingURL=validation.d.ts.map

package/dist/src/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/validation.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,8BAA8B;;;EAAoC,CAAA;AAC/E,eAAO,MAAM,6BAA6B;;;;EAA4C,CAAA;AACtF,eAAO,MAAM,kCAAkC;;;EAAkC,CAAA;AACjF,eAAO,MAAM,iCAAiC;;;EAAkC,CAAA;AAIhF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQ1C,CAAA;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO3C,CAAA;AAEF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAC5F,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA"}

package/dist/src/validation.js

@@ -0,0 +1,25 @@
+import { applyDefaultBookingPaymentPlanSchema, createPaymentSessionFromInvoiceSchema, createPaymentSessionFromScheduleSchema, } from "@voyantjs/finance";
+import { sendInvoiceNotificationSchema, sendPaymentSessionNotificationSchema, } from "@voyantjs/notifications";
+import { z } from "zod";
+export const checkoutCollectionMethodSchema = z.enum(["card", "bank_transfer"]);
+export const checkoutCollectionStageSchema = z.enum(["initial", "reminder", "manual"]);
+export const checkoutPaymentSessionTargetSchema = z.enum(["schedule", "invoice"]);
+export const checkoutInvoiceDocumentTypeSchema = z.enum(["proforma", "invoice"]);
+const planOverrideSchema = applyDefaultBookingPaymentPlanSchema.partial();
+export const previewCheckoutCollectionSchema = z.object({
+    method: checkoutCollectionMethodSchema,
+    stage: checkoutCollectionStageSchema.default("initial"),
+    scheduleId: z.string().optional(),
+    invoiceId: z.string().optional(),
+    ensureDefaultPaymentPlan: z.boolean().default(true),
+    paymentSessionTarget: checkoutPaymentSessionTargetSchema.optional(),
+    paymentPlan: planOverrideSchema.optional(),
+});
+export const initiateCheckoutCollectionSchema = previewCheckoutCollectionSchema.extend({
+    paymentSession: z
+        .union([createPaymentSessionFromScheduleSchema, createPaymentSessionFromInvoiceSchema])
+        .optional(),
+    paymentSessionNotification: sendPaymentSessionNotificationSchema.optional(),
+    invoiceNotification: sendInvoiceNotificationSchema.optional(),
+    notes: z.string().optional().nullable(),
+});

package/dist/tests/unit/service.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=service.test.d.ts.map

package/dist/tests/unit/service.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.test.d.ts","sourceRoot":"","sources":["../../../tests/unit/service.test.ts"],"names":[],"mappings":""}

package/dist/tests/unit/service.test.js

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { resolvePaymentSessionTarget } from "../../src/service.js";
+describe("resolvePaymentSessionTarget", () => {
+    it("always uses invoice collection for bank transfer", () => {
+        expect(resolvePaymentSessionTarget("bank_transfer", "initial", undefined, {})).toBe("invoice");
+        expect(resolvePaymentSessionTarget("bank_transfer", "reminder", "schedule", {})).toBe("invoice");
+    });
+    it("uses stage-aware defaults for card collection", () => {
+        expect(resolvePaymentSessionTarget("card", "initial", undefined, {})).toBe("schedule");
+        expect(resolvePaymentSessionTarget("card", "reminder", undefined, {
+            defaultReminderCardCollectionTarget: "invoice",
+        })).toBe("invoice");
+    });
+    it("honors explicit overrides", () => {
+        expect(resolvePaymentSessionTarget("card", "initial", "invoice", {})).toBe("invoice");
+        expect(resolvePaymentSessionTarget("card", "reminder", "schedule", {})).toBe("schedule");
+    });
+});

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@voyantjs/checkout",
+  "version": "0.1.0",
+  "license": "FSL-1.1-Apache-2.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./routes": {
+      "types": "./dist/routes.d.ts",
+      "import": "./dist/routes.js"
+    },
+    "./service": {
+      "types": "./dist/service.d.ts",
+      "import": "./dist/service.js"
+    },
+    "./validation": {
+      "types": "./dist/validation.d.ts",
+      "import": "./dist/validation.js"
+    }
+  },
+  "dependencies": {
+    "drizzle-orm": "^0.45.2",
+    "hono": "^4.12.10",
+    "zod": "^4.3.6",
+    "@voyantjs/bookings": "0.1.0",
+    "@voyantjs/finance": "0.1.0",
+    "@voyantjs/core": "0.1.0",
+    "@voyantjs/hono": "0.1.0",
+    "@voyantjs/notifications": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2",
+    "@voyantjs/voyant-typescript-config": "0.1.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/",
+    "test": "vitest run",
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts"
+}