@voyantjs/legal 0.6.9 → 0.8.0

package/dist/contracts/service-auto-generate.d.ts

@@ -0,0 +1,129 @@
+import { bookingsService } from "@voyantjs/bookings";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { ContractDocumentGenerator } from "./service-documents.js";
+/**
+ * Event shape emitted by `@voyantjs/bookings` on confirm. Duplicated here so
+ * legal doesn't have to import the bookings service just for the interface —
+ * the concrete `bookingsService` lookup happens inside the handler.
+ */
+export interface BookingConfirmedLikeEvent {
+    bookingId: string;
+    bookingNumber: string;
+    actorId: string | null;
+}
+/**
+ * Variables passed to the contract template at render time. Consumers can
+ * augment via `resolveVariables`; the built-in resolver supplies the fields
+ * the default contract template expects.
+ */
+export interface DefaultContractVariables {
+    contract: {
+        issuedAt: string;
+        date: string;
+    };
+    booking: {
+        id: string;
+        number: string;
+        status: string;
+        currency: string | null;
+        startDate: string | null;
+        endDate: string | null;
+        pax: number | null;
+        internalNotes: string | null;
+        totalAmountCents: number | null;
+    };
+    travelers: Array<{
+        id: string;
+        firstName: string;
+        lastName: string;
+        email: string | null;
+        phone: string | null;
+        isPrimary: boolean;
+        participantType: string;
+    }>;
+    leadTraveler: {
+        id: string;
+        firstName: string;
+        lastName: string;
+        email: string | null;
+        phone: string | null;
+    } | null;
+}
+/**
+ * Hook point so consumers can extend (or replace) the template variables.
+ * Receives the default payload plus the raw booking/travelers so the
+ * consumer can fold in product/person/etc. lookups without re-fetching.
+ */
+export type ResolveContractVariablesFn = (context: {
+    db: PostgresJsDatabase;
+    booking: NonNullable<Awaited<ReturnType<typeof bookingsService.getBookingById>>>;
+    travelers: Awaited<ReturnType<typeof bookingsService.listTravelers>>;
+    defaults: DefaultContractVariables;
+}) => Promise<Record<string, unknown>> | Record<string, unknown>;
+export interface AutoGenerateContractOptions {
+    enabled?: boolean;
+    /**
+     * Slug of the contract template to use. The contract is created against
+     * that template's `currentVersionId`. If the template has no current
+     * version, the handler logs + bails.
+     */
+    templateSlug: string;
+    /**
+     * Scope the contract defaults to when creating. Matches
+     * `contractScopeEnum`; the default `"customer"` is right for the common
+     * operator-issues-to-traveler case.
+     */
+    scope?: "customer" | "supplier" | "partner" | "channel" | "other";
+    /**
+     * When set, the contract tries to allocate a number from the matching
+     * active series on issuance. Without it, the contract issues unnumbered.
+     */
+    seriesName?: string;
+    /**
+     * Language code written onto the contract row. Used by the PDF
+     * renderer to pick the right locale for date/currency filters.
+     */
+    language?: string;
+    /**
+     * Optional variable extender — see `ResolveContractVariablesFn`.
+     */
+    resolveVariables?: ResolveContractVariablesFn;
+}
+export interface AutoGenerateContractRuntime {
+    generator: ContractDocumentGenerator;
+    eventBus?: import("@voyantjs/core").EventBus;
+}
+/**
+ * Core auto-generate handler. Fire this from a `booking.confirmed` subscriber.
+ * On success, the booking now has an issued contract with an attachment
+ * (the PDF / storage object produced by the configured generator) and a
+ * `contract.document.generated` event has been emitted post-commit.
+ *
+ * Failure modes (all surfaced via the returned status):
+ *  - `template_not_found`       — no active template matches the slug
+ *  - `template_version_missing` — template exists but has no published version
+ *  - `booking_not_found`        — booking disappeared between confirm + fire
+ *  - `contract_create_failed`   — insert returned null
+ *  - `document_<…>`             — pass-through of generateContractDocument statuses
+ *
+ * Callers (the subscriber wrapper) log these and move on — per the EventBus
+ * contract, handler throws are swallowed anyway; returning a discriminated
+ * status keeps tests honest.
+ */
+export declare function autoGenerateContractForBooking(db: PostgresJsDatabase, event: BookingConfirmedLikeEvent, options: AutoGenerateContractOptions, runtime: AutoGenerateContractRuntime): Promise<{
+    status: "ok";
+    contractId: string;
+    attachmentId: string;
+} | {
+    status: "template_not_found";
+} | {
+    status: "template_version_missing";
+} | {
+    status: "booking_not_found";
+} | {
+    status: "contract_create_failed";
+} | {
+    status: "document_failed";
+    reason: string;
+}>;
+//# sourceMappingURL=service-auto-generate.d.ts.map

package/dist/contracts/service-auto-generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-auto-generate.d.ts","sourceRoot":"","sources":["../../src/contracts/service-auto-generate.ts"],"names":[],"mappings":"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"}

package/dist/contracts/service-auto-generate.js

@@ -0,0 +1,122 @@
+import { bookingsService } from "@voyantjs/bookings";
+import { contractRecordsService } from "./service-contracts.js";
+import { contractDocumentsService } from "./service-documents.js";
+import { contractSeriesService } from "./service-series.js";
+import { contractTemplatesService } from "./service-templates.js";
+/**
+ * Core auto-generate handler. Fire this from a `booking.confirmed` subscriber.
+ * On success, the booking now has an issued contract with an attachment
+ * (the PDF / storage object produced by the configured generator) and a
+ * `contract.document.generated` event has been emitted post-commit.
+ *
+ * Failure modes (all surfaced via the returned status):
+ *  - `template_not_found`       — no active template matches the slug
+ *  - `template_version_missing` — template exists but has no published version
+ *  - `booking_not_found`        — booking disappeared between confirm + fire
+ *  - `contract_create_failed`   — insert returned null
+ *  - `document_<…>`             — pass-through of generateContractDocument statuses
+ *
+ * Callers (the subscriber wrapper) log these and move on — per the EventBus
+ * contract, handler throws are swallowed anyway; returning a discriminated
+ * status keeps tests honest.
+ */
+export async function autoGenerateContractForBooking(db, event, options, runtime) {
+    // Resolve the template + its current version. Consumers configure the slug
+    // once at module bootstrap; we look up on every fire so template body
+    // edits are picked up without restart.
+    const template = await contractTemplatesService.findTemplateBySlug(db, options.templateSlug);
+    if (!template) {
+        return { status: "template_not_found" };
+    }
+    if (!template.currentVersionId) {
+        return { status: "template_version_missing" };
+    }
+    const booking = await bookingsService.getBookingById(db, event.bookingId);
+    if (!booking) {
+        return { status: "booking_not_found" };
+    }
+    const travelers = await bookingsService.listTravelers(db, event.bookingId);
+    const leadTraveler = travelers.find((t) => t.isPrimary) ??
+        travelers.find((t) => t.participantType === "traveler") ??
+        travelers[0] ??
+        null;
+    const now = new Date();
+    const defaults = {
+        contract: {
+            issuedAt: now.toISOString(),
+            date: now.toISOString().slice(0, 10),
+        },
+        booking: {
+            id: booking.id,
+            number: booking.bookingNumber,
+            status: booking.status,
+            currency: booking.sellCurrency ?? null,
+            startDate: booking.startDate,
+            endDate: booking.endDate,
+            pax: booking.pax,
+            internalNotes: booking.internalNotes,
+            totalAmountCents: booking.sellAmountCents ?? null,
+        },
+        travelers: travelers.map((t) => ({
+            id: t.id,
+            firstName: t.firstName,
+            lastName: t.lastName,
+            email: t.email,
+            phone: t.phone,
+            isPrimary: t.isPrimary,
+            participantType: t.participantType,
+        })),
+        leadTraveler: leadTraveler
+            ? {
+                id: leadTraveler.id,
+                firstName: leadTraveler.firstName,
+                lastName: leadTraveler.lastName,
+                email: leadTraveler.email,
+                phone: leadTraveler.phone,
+            }
+            : null,
+    };
+    const variables = options.resolveVariables
+        ? await options.resolveVariables({ db, booking, travelers, defaults })
+        : defaults;
+    // Resolve a series id if the consumer gave a name — failure to find is
+    // non-fatal since a contract can issue without a number (some operators
+    // use templates as standalone records and number externally).
+    let seriesId = null;
+    if (options.seriesName) {
+        const series = await contractSeriesService.findSeriesByName(db, options.seriesName);
+        seriesId = series?.id ?? null;
+    }
+    const contract = await contractRecordsService.createContract(db, {
+        scope: options.scope ?? "customer",
+        status: "draft",
+        title: `${template.name} — ${booking.bookingNumber}`,
+        templateVersionId: template.currentVersionId,
+        seriesId,
+        bookingId: event.bookingId,
+        personId: booking.personId ?? null,
+        organizationId: booking.organizationId ?? null,
+        language: options.language ?? template.language ?? "en",
+        variables,
+        metadata: {
+            autoGenerated: true,
+            trigger: "booking.confirmed",
+            triggerActorId: event.actorId,
+        },
+    });
+    if (!contract) {
+        return { status: "contract_create_failed" };
+    }
+    const result = await contractDocumentsService.generateContractDocument(db, contract.id, {
+        issueIfDraft: true,
+        replaceExisting: true,
+        kind: "document",
+    }, {
+        generator: runtime.generator,
+        eventBus: runtime.eventBus,
+    });
+    if (result.status === "generated") {
+        return { status: "ok", contractId: contract.id, attachmentId: result.attachment.id };
+    }
+    return { status: "document_failed", reason: result.status };
+}

package/dist/contracts/service-series.d.ts

@@ -29,6 +29,26 @@ export declare const contractSeriesService: {
         createdAt: Date;
         updatedAt: Date;
     } | null>;
+    /**
+     * Find the most-recently-updated active series matching a name. Used by
+     * the auto-generate subscriber so consumers can pin a named series
+     * (`"2026 Customer"`) in config and let operators rename the row via
+     * the admin UI without breaking the wiring.
+     */
+    findSeriesByName(db: PostgresJsDatabase, name: string): Promise<{
+        id: string;
+        name: string;
+        prefix: string;
+        separator: string;
+        padLength: number;
+        currentSequence: number;
+        resetStrategy: "never" | "annual" | "monthly";
+        resetAt: Date | null;
+        scope: "customer" | "partner" | "supplier" | "other" | "channel";
+        active: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
     createSeries(db: PostgresJsDatabase, data: CreateContractNumberSeriesInput): Promise<{
         id: string;
         name: string;

package/dist/contracts/service-series.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service-series.d.ts","sourceRoot":"","sources":["../../src/contracts/service-series.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,OAAO,KAAK,EACV,+BAA+B,EAC/B,+BAA+B,EAChC,MAAM,qBAAqB,CAAA;AAE5B,eAAO,MAAM,qBAAqB;mBACX,kBAAkB;;;;;;;;;;;;;;sBAGf,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;qBAQ/B,kBAAkB,QAAQ,+BAA+B;;;;;;;;;;;;;;qBAIzD,kBAAkB,MAAM,MAAM,QAAQ,+BAA+B;;;;;;;;;;;;;;qBAQrE,kBAAkB,MAAM,MAAM;;;CAOtD,CAAA"}
+{"version":3,"file":"service-series.d.ts","sourceRoot":"","sources":["../../src/contracts/service-series.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,OAAO,KAAK,EACV,+BAA+B,EAC/B,+BAA+B,EAChC,MAAM,qBAAqB,CAAA;AAE5B,eAAO,MAAM,qBAAqB;mBACX,kBAAkB;;;;;;;;;;;;;;sBAGf,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;IAQtD;;;;;OAKG;yBACwB,kBAAkB,QAAQ,MAAM;;;;;;;;;;;;;;qBASpC,kBAAkB,QAAQ,+BAA+B;;;;;;;;;;;;;;qBAIzD,kBAAkB,MAAM,MAAM,QAAQ,+BAA+B;;;;;;;;;;;;;;qBAQrE,kBAAkB,MAAM,MAAM;;;CAOtD,CAAA"}

package/dist/contracts/service-series.js

@@ -1,4 +1,4 @@
-import { desc, eq } from "drizzle-orm";
+import { and, desc, eq } from "drizzle-orm";
 import { contractNumberSeries } from "./schema.js";
 export const contractSeriesService = {
     async listSeries(db) {
@@ -12,6 +12,21 @@ export const contractSeriesService = {
             .limit(1);
         return row ?? null;
     },
+    /**
+     * Find the most-recently-updated active series matching a name. Used by
+     * the auto-generate subscriber so consumers can pin a named series
+     * (`"2026 Customer"`) in config and let operators rename the row via
+     * the admin UI without breaking the wiring.
+     */
+    async findSeriesByName(db, name) {
+        const [row] = await db
+            .select()
+            .from(contractNumberSeries)
+            .where(and(eq(contractNumberSeries.name, name), eq(contractNumberSeries.active, true)))
+            .orderBy(desc(contractNumberSeries.updatedAt))
+            .limit(1);
+        return row ?? null;
+    },
     async createSeries(db, data) {
         const [row] = await db.insert(contractNumberSeries).values(data).returning();
         return row ?? null;

package/dist/contracts/service-templates.d.ts

@@ -34,6 +34,24 @@ export declare const contractTemplatesService: {
         createdAt: Date;
         updatedAt: Date;
     } | null>;
+    /**
+     * Slug lookup, used by the auto-generate subscriber. Slug is unique so the
+     * result is either the row or null — no disambiguation needed.
+     */
+    findTemplateBySlug(db: PostgresJsDatabase, slug: string): Promise<{
+        id: string;
+        name: string;
+        slug: string;
+        scope: "customer" | "partner" | "supplier" | "other" | "channel";
+        language: string;
+        description: string | null;
+        body: string;
+        variableSchema: unknown;
+        currentVersionId: string | null;
+        active: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
     getDefaultTemplate(db: PostgresJsDatabase, query: {
         scope: "customer" | "supplier" | "partner" | "channel" | "other";
         language?: string;

package/dist/contracts/service-templates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service-templates.d.ts","sourceRoot":"","sources":["../../src/contracts/service-templates.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,EAChC,KAAK,kCAAkC,EAEvC,KAAK,mBAAmB,EAExB,KAAK,2BAA2B,EACjC,MAAM,qBAAqB,CAAA;AAE5B,eAAO,MAAM,wBAAwB;sBACX,kBAAkB,SAAS,yBAAyB;;;;;;;;;;;;;;;;;;;wBA6BlD,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;2BASlD,kBAAkB,SACf;QACL,KAAK,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAA;QAChE,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;KAC7B;;;;;;;;;;;;;;uBAgCsB,kBAAkB,QAAQ,2BAA2B;;;;;;;;;;;;;;uBAIrD,kBAAkB,MAAM,MAAM,QAAQ,2BAA2B;;;;;;;;;;;;;;uBAQjE,kBAAkB,MAAM,MAAM;;;6BAO9B,kBAAkB,cAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAO9B,kBAAkB,MAAM,MAAM;;;;;;;;;;8BASzD,kBAAkB,cACV,MAAM,QACZ,kCAAkC;;;;;;;;;;yBAkCrB,mBAAmB,GAAG,MAAM;CAIlD,CAAA"}
+{"version":3,"file":"service-templates.d.ts","sourceRoot":"","sources":["../../src/contracts/service-templates.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,EAChC,KAAK,kCAAkC,EAEvC,KAAK,mBAAmB,EAExB,KAAK,2BAA2B,EACjC,MAAM,qBAAqB,CAAA;AAE5B,eAAO,MAAM,wBAAwB;sBACX,kBAAkB,SAAS,yBAAyB;;;;;;;;;;;;;;;;;;;wBA6BlD,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;IAQxD;;;OAGG;2BAC0B,kBAAkB,QAAQ,MAAM;;;;;;;;;;;;;;2BASvD,kBAAkB,SACf;QACL,KAAK,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAA;QAChE,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;KAC7B;;;;;;;;;;;;;;uBAgCsB,kBAAkB,QAAQ,2BAA2B;;;;;;;;;;;;;;uBAIrD,kBAAkB,MAAM,MAAM,QAAQ,2BAA2B;;;;;;;;;;;;;;uBAQjE,kBAAkB,MAAM,MAAM;;;6BAO9B,kBAAkB,cAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAO9B,kBAAkB,MAAM,MAAM;;;;;;;;;;8BASzD,kBAAkB,cACV,MAAM,QACZ,kCAAkC;;;;;;;;;;yBAkCrB,mBAAmB,GAAG,MAAM;CAIlD,CAAA"}

package/dist/contracts/service-templates.js

@@ -31,6 +31,18 @@ export const contractTemplatesService = {
             .limit(1);
         return row ?? null;
     },
+    /**
+     * Slug lookup, used by the auto-generate subscriber. Slug is unique so the
+     * result is either the row or null — no disambiguation needed.
+     */
+    async findTemplateBySlug(db, slug) {
+        const [row] = await db
+            .select()
+            .from(contractTemplates)
+            .where(eq(contractTemplates.slug, slug))
+            .limit(1);
+        return row ?? null;
+    },
     async getDefaultTemplate(db, query) {
         const rows = await db
             .select()

package/dist/contracts/service.d.ts

@@ -1282,6 +1282,20 @@ export declare const contractsService: {
         createdAt: Date;
         updatedAt: Date;
     } | null>;
+    findSeriesByName(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, name: string): Promise<{
+        id: string;
+        name: string;
+        prefix: string;
+        separator: string;
+        padLength: number;
+        currentSequence: number;
+        resetStrategy: "never" | "annual" | "monthly";
+        resetAt: Date | null;
+        scope: "customer" | "partner" | "supplier" | "other" | "channel";
+        active: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
     createSeries(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, data: import("./service-shared.js").CreateContractNumberSeriesInput): Promise<{
         id: string;
         name: string;
@@ -1346,6 +1360,20 @@ export declare const contractsService: {
         createdAt: Date;
         updatedAt: Date;
     } | null>;
+    findTemplateBySlug(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, slug: string): Promise<{
+        id: string;
+        name: string;
+        slug: string;
+        scope: "customer" | "partner" | "supplier" | "other" | "channel";
+        language: string;
+        description: string | null;
+        body: string;
+        variableSchema: unknown;
+        currentVersionId: string | null;
+        active: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
     getDefaultTemplate(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, query: {
         scope: "customer" | "supplier" | "partner" | "channel" | "other";
         language?: string;

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

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/contracts/service.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,sBAAsB,EACtB,cAAc,EACd,yBAAyB,EAC1B,MAAM,qBAAqB,CAAA;AAG5B,OAAO,EAAE,sBAAsB,EAAE,cAAc,EAAE,yBAAyB,EAAE,CAAA;AAE5E,eAAO,MAAM,gBAAgB;;mBAMy1S,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAAlkQ,CAAC;yBAAgC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CADt1C,CAAA"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/contracts/service.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,sBAAsB,EACtB,cAAc,EACd,yBAAyB,EAC1B,MAAM,qBAAqB,CAAA;AAG5B,OAAO,EAAE,sBAAsB,EAAE,cAAc,EAAE,yBAAyB,EAAE,CAAA;AAE5E,eAAO,MAAM,gBAAgB;;mBAMy1S,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAA9rP,CAAC;yBAAgC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAD1tD,CAAA"}

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import type { Module } from "@voyantjs/core";
 import type { HonoModule } from "@voyantjs/hono/module";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
 import { type ContractsRouteOptions } from "./contracts/routes.js";
+import { type AutoGenerateContractOptions } from "./contracts/service-auto-generate.js";
 export declare const legalLinkable: {
     policy: import("@voyantjs/core").LinkableDefinition;
     policyVersion: import("@voyantjs/core").LinkableDefinition;
@@ -9,10 +11,27 @@ export declare const legalLinkable: {
     contractTemplate: import("@voyantjs/core").LinkableDefinition;
 };
 export declare const legalModule: Module;
-export declare function createLegalHonoModule(options?: ContractsRouteOptions): HonoModule;
+export interface CreateLegalHonoModuleOptions extends ContractsRouteOptions {
+    /**
+     * Required when `autoGenerateContractOnConfirmed.enabled` is true. The
+     * `booking.confirmed` subscriber fires outside request scope, so it
+     * needs its own db handle from runtime bindings.
+     */
+    resolveDb?: (bindings: Record<string, unknown>) => PostgresJsDatabase;
+    /**
+     * Opt-in auto-generate on `booking.confirmed`. When enabled + a
+     * `templateSlug` is supplied + a `documentGenerator` is resolvable, every
+     * booking.confirmed event creates a contract against the template's
+     * current version and generates its attachment via the configured
+     * generator (R2-backed PDF, etc.).
+     */
+    autoGenerateContractOnConfirmed?: AutoGenerateContractOptions;
+}
+export declare function createLegalHonoModule(options?: CreateLegalHonoModuleOptions): HonoModule;
 export declare const legalHonoModule: HonoModule;
 export * from "./contracts/index.js";
 export { buildContractsRouteRuntime, CONTRACTS_ROUTE_RUNTIME_CONTAINER_KEY, type ContractsRouteRuntime, } from "./contracts/route-runtime.js";
 export type { ContractsRouteOptions } from "./contracts/routes.js";
+export { type AutoGenerateContractOptions, type AutoGenerateContractRuntime, autoGenerateContractForBooking, type BookingConfirmedLikeEvent, type DefaultContractVariables, type ResolveContractVariablesFn, } from "./contracts/service-auto-generate.js";
 export * from "./policies/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAOvD,OAAO,EACL,KAAK,qBAAqB,EAG3B,MAAM,uBAAuB,CAAA;AAI9B,eAAO,MAAM,aAAa;;;;;;CAGzB,CAAA;AAED,eAAO,MAAM,WAAW,EAAE,MAGzB,CAAA;AAED,wBAAgB,qBAAqB,CAAC,OAAO,GAAE,qBAA0B,GAAG,UAAU,CAwBrF;AAED,eAAO,MAAM,eAAe,EAAE,UAAoC,CAAA;AAElE,cAAc,sBAAsB,CAAA;AACpC,OAAO,EACL,0BAA0B,EAC1B,qCAAqC,EACrC,KAAK,qBAAqB,GAC3B,MAAM,8BAA8B,CAAA;AACrC,YAAY,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAA;AAClE,cAAc,qBAAqB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAOjE,OAAO,EACL,KAAK,qBAAqB,EAG3B,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACL,KAAK,2BAA2B,EAEjC,MAAM,sCAAsC,CAAA;AAI7C,eAAO,MAAM,aAAa;;;;;;CAGzB,CAAA;AAED,eAAO,MAAM,WAAW,EAAE,MAGzB,CAAA;AAED,MAAM,WAAW,4BAA6B,SAAQ,qBAAqB;IACzE;;;;OAIG;IACH,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,kBAAkB,CAAA;IACrE;;;;;;OAMG;IACH,+BAA+B,CAAC,EAAE,2BAA2B,CAAA;CAC9D;AAED,wBAAgB,qBAAqB,CAAC,OAAO,GAAE,4BAAiC,GAAG,UAAU,CAsE5F;AAED,eAAO,MAAM,eAAe,EAAE,UAAoC,CAAA;AAElE,cAAc,sBAAsB,CAAA;AACpC,OAAO,EACL,0BAA0B,EAC1B,qCAAqC,EACrC,KAAK,qBAAqB,GAC3B,MAAM,8BAA8B,CAAA;AACrC,YAAY,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAA;AAClE,OAAO,EACL,KAAK,2BAA2B,EAChC,KAAK,2BAA2B,EAChC,8BAA8B,EAC9B,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,0BAA0B,GAChC,MAAM,sCAAsC,CAAA;AAC7C,cAAc,qBAAqB,CAAA"}

package/dist/index.js

@@ -2,6 +2,7 @@ import { Hono } from "hono";
 import { contractsLinkable } from "./contracts/index.js";
 import { buildContractsRouteRuntime, CONTRACTS_ROUTE_RUNTIME_CONTAINER_KEY, } from "./contracts/route-runtime.js";
 import { createContractsAdminRoutes, createContractsPublicRoutes, } from "./contracts/routes.js";
+import { autoGenerateContractForBooking, } from "./contracts/service-auto-generate.js";
 import { policiesLinkable } from "./policies/index.js";
 import { policiesAdminRoutes, policiesPublicRoutes } from "./policies/routes.js";
 export const legalLinkable = {
@@ -21,8 +22,42 @@ export function createLegalHonoModule(options = {}) {
         .route("/policies", policiesPublicRoutes);
     const module = {
         ...legalModule,
-        bootstrap: ({ bindings, container }) => {
+        bootstrap: ({ bindings, container, eventBus }) => {
             container.register(CONTRACTS_ROUTE_RUNTIME_CONTAINER_KEY, buildContractsRouteRuntime(bindings, options));
+            // Auto-generate wiring — opt-in. Mirrors the notifications
+            // autoConfirmAndDispatch subscriber pattern. Both fire on the same
+            // booking.confirmed event; legal's handler just needs to run first
+            // so the contract attachment exists before notifications looks it
+            // up via listLegalBookingDocuments. Module-registration order in the
+            // template controls this.
+            const auto = options.autoGenerateContractOnConfirmed;
+            if (auto?.enabled && options.resolveDb) {
+                const resolveDb = options.resolveDb;
+                const runtime = buildContractsRouteRuntime(bindings, options);
+                if (!runtime.documentGenerator) {
+                    // Mis-configuration — don't silently drop contracts. Log and
+                    // skip; the template operator will notice on the first confirm.
+                    console.error("[legal] autoGenerateContractOnConfirmed.enabled=true but no documentGenerator resolved; skipping subscriber.");
+                    return;
+                }
+                const generator = runtime.documentGenerator;
+                eventBus.subscribe("booking.confirmed", async (event) => {
+                    try {
+                        const db = resolveDb(bindings);
+                        const result = await autoGenerateContractForBooking(db, event.data, auto, {
+                            generator,
+                            eventBus,
+                        });
+                        if (result.status !== "ok") {
+                            console.error(`[legal] auto-generate contract skipped for booking ${event.data.bookingId}: ${result.status}`);
+                        }
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        console.error(`[legal] auto-generate contract failed for booking ${event.data.bookingId}: ${message}`);
+                    }
+                });
+            }
         },
     };
     return {
@@ -34,4 +69,5 @@ export function createLegalHonoModule(options = {}) {
 export const legalHonoModule = createLegalHonoModule();
 export * from "./contracts/index.js";
 export { buildContractsRouteRuntime, CONTRACTS_ROUTE_RUNTIME_CONTAINER_KEY, } from "./contracts/route-runtime.js";
+export { autoGenerateContractForBooking, } from "./contracts/service-auto-generate.js";
 export * from "./policies/index.js";

package/dist/policies/routes.d.ts

@@ -114,7 +114,7 @@ export declare const policiesAdminRoutes: import("hono/hono-base").HonoBase<Env,
                         label: string | null;
                         daysBeforeDeparture: number | null;
                         refundPercent: number | null;
-                        refundType: "cash" | "credit" | "cash_or_credit" | "none" | null;
+                        refundType: "none" | "cash" | "credit" | "cash_or_credit" | null;
                         flatAmountCents: number | null;
                         currency: string | null;
                         validFrom: string | null;
@@ -380,7 +380,7 @@ export declare const policiesAdminRoutes: import("hono/hono-base").HonoBase<Env,
                     label: string | null;
                     daysBeforeDeparture: number | null;
                     refundPercent: number | null;
-                    refundType: "cash" | "credit" | "cash_or_credit" | "none" | null;
+                    refundType: "none" | "cash" | "credit" | "cash_or_credit" | null;
                     flatAmountCents: number | null;
                     currency: string | null;
                     validFrom: string | null;
@@ -429,7 +429,7 @@ export declare const policiesAdminRoutes: import("hono/hono-base").HonoBase<Env,
                     ruleType: "custom" | "window" | "percentage" | "flat_amount" | "date_range";
                     daysBeforeDeparture: number | null;
                     refundPercent: number | null;
-                    refundType: "cash" | "credit" | "cash_or_credit" | "none" | null;
+                    refundType: "none" | "cash" | "credit" | "cash_or_credit" | null;
                     flatAmountCents: number | null;
                 };
             };
@@ -464,7 +464,7 @@ export declare const policiesAdminRoutes: import("hono/hono-base").HonoBase<Env,
                     label: string | null;
                     daysBeforeDeparture: number | null;
                     refundPercent: number | null;
-                    refundType: "cash" | "credit" | "cash_or_credit" | "none" | null;
+                    refundType: "none" | "cash" | "credit" | "cash_or_credit" | null;
                     flatAmountCents: number | null;
                     currency: string | null;
                     validFrom: string | null;
@@ -670,9 +670,9 @@ export declare const policiesAdminRoutes: import("hono/hono-base").HonoBase<Env,
                     bookingId: string | null;
                     orderId: string | null;
                     method: "signature" | "implicit" | "explicit_checkbox";
-                    policyVersionId: string;
-                    offerId: string | null;
                     acceptedAt: string;
+                    offerId: string | null;
+                    policyVersionId: string;
                     acceptedBy: string | null;
                 } | null;
             };
@@ -892,9 +892,9 @@ export declare const policiesPublicRoutes: import("hono/hono-base").HonoBase<Env
                     bookingId: string | null;
                     orderId: string | null;
                     method: "signature" | "implicit" | "explicit_checkbox";
-                    policyVersionId: string;
-                    offerId: string | null;
                     acceptedAt: string;
+                    offerId: string | null;
+                    policyVersionId: string;
                     acceptedBy: string | null;
                 } | null;
             };

package/dist/policies/schema.d.ts

@@ -507,7 +507,7 @@ export declare const policyRules: import("drizzle-orm/pg-core").PgTableWithColum
             tableName: "policy_rules";
             dataType: "string";
             columnType: "PgEnumColumn";
-            data: "cash" | "credit" | "cash_or_credit" | "none";
+            data: "none" | "cash" | "credit" | "cash_or_credit";
             driverParam: string;
             notNull: false;
             hasDefault: false;

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

@@ -680,7 +680,7 @@ export declare const policiesCoreService: {
             tableName: "policy_rules";
             dataType: "string";
             columnType: "PgEnumColumn";
-            data: "cash" | "credit" | "cash_or_credit" | "none";
+            data: "none" | "cash" | "credit" | "cash_or_credit";
             driverParam: string;
             notNull: false;
             hasDefault: false;
@@ -835,7 +835,7 @@ export declare const policiesCoreService: {
         label: string | null;
         daysBeforeDeparture: number | null;
         refundPercent: number | null;
-        refundType: "cash" | "credit" | "cash_or_credit" | "none" | null;
+        refundType: "none" | "cash" | "credit" | "cash_or_credit" | null;
         flatAmountCents: number | null;
         currency: string | null;
         validFrom: string | null;
@@ -952,7 +952,7 @@ export declare const policiesCoreService: {
             tableName: "policy_rules";
             dataType: "string";
             columnType: "PgEnumColumn";
-            data: "cash" | "credit" | "cash_or_credit" | "none";
+            data: "none" | "cash" | "credit" | "cash_or_credit";
             driverParam: string;
             notNull: false;
             hasDefault: false;
@@ -1115,7 +1115,7 @@ export declare const policiesCoreService: {
         ruleType: "custom" | "window" | "percentage" | "flat_amount" | "date_range";
         daysBeforeDeparture: number | null;
         refundPercent: number | null;
-        refundType: "cash" | "credit" | "cash_or_credit" | "none" | null;
+        refundType: "none" | "cash" | "credit" | "cash_or_credit" | null;
         flatAmountCents: number | null;
     } | null>;
     updatePolicyRule(db: PostgresJsDatabase, ruleId: string, data: UpdatePolicyRuleInput): Promise<{
@@ -1125,7 +1125,7 @@ export declare const policiesCoreService: {
         label: string | null;
         daysBeforeDeparture: number | null;
         refundPercent: number | null;
-        refundType: "cash" | "credit" | "cash_or_credit" | "none" | null;
+        refundType: "none" | "cash" | "credit" | "cash_or_credit" | null;
         flatAmountCents: number | null;
         currency: string | null;
         validFrom: string | null;
@@ -1244,7 +1244,7 @@ export declare const policiesCoreService: {
             label: string | null;
             daysBeforeDeparture: number | null;
             refundPercent: number | null;
-            refundType: "cash" | "credit" | "cash_or_credit" | "none" | null;
+            refundType: "none" | "cash" | "credit" | "cash_or_credit" | null;
             flatAmountCents: number | null;
             currency: string | null;
             validFrom: string | null;
@@ -1286,9 +1286,9 @@ export declare const policiesCoreService: {
         bookingId: string | null;
         orderId: string | null;
         method: "signature" | "implicit" | "explicit_checkbox";
-        policyVersionId: string;
-        offerId: string | null;
         acceptedAt: Date;
+        offerId: string | null;
+        policyVersionId: string;
         acceptedBy: string | null;
     } | null>;
 };

package/dist/policies/service.d.ts

@@ -680,7 +680,7 @@ export declare const policiesService: {
             tableName: "policy_rules";
             dataType: "string";
             columnType: "PgEnumColumn";
-            data: "cash" | "credit" | "cash_or_credit" | "none";
+            data: "none" | "cash" | "credit" | "cash_or_credit";
             driverParam: string;
             notNull: false;
             hasDefault: false;
@@ -835,7 +835,7 @@ export declare const policiesService: {
         label: string | null;
         daysBeforeDeparture: number | null;
         refundPercent: number | null;
-        refundType: "cash" | "credit" | "cash_or_credit" | "none" | null;
+        refundType: "none" | "cash" | "credit" | "cash_or_credit" | null;
         flatAmountCents: number | null;
         currency: string | null;
         validFrom: string | null;
@@ -952,7 +952,7 @@ export declare const policiesService: {
             tableName: "policy_rules";
             dataType: "string";
             columnType: "PgEnumColumn";
-            data: "cash" | "credit" | "cash_or_credit" | "none";
+            data: "none" | "cash" | "credit" | "cash_or_credit";
             driverParam: string;
             notNull: false;
             hasDefault: false;
@@ -1115,7 +1115,7 @@ export declare const policiesService: {
         ruleType: "custom" | "window" | "percentage" | "flat_amount" | "date_range";
         daysBeforeDeparture: number | null;
         refundPercent: number | null;
-        refundType: "cash" | "credit" | "cash_or_credit" | "none" | null;
+        refundType: "none" | "cash" | "credit" | "cash_or_credit" | null;
         flatAmountCents: number | null;
     } | null>;
     updatePolicyRule(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, ruleId: string, data: import("./service-shared.js").UpdatePolicyRuleInput): Promise<{
@@ -1125,7 +1125,7 @@ export declare const policiesService: {
         label: string | null;
         daysBeforeDeparture: number | null;
         refundPercent: number | null;
-        refundType: "cash" | "credit" | "cash_or_credit" | "none" | null;
+        refundType: "none" | "cash" | "credit" | "cash_or_credit" | null;
         flatAmountCents: number | null;
         currency: string | null;
         validFrom: string | null;
@@ -1244,7 +1244,7 @@ export declare const policiesService: {
             label: string | null;
             daysBeforeDeparture: number | null;
             refundPercent: number | null;
-            refundType: "cash" | "credit" | "cash_or_credit" | "none" | null;
+            refundType: "none" | "cash" | "credit" | "cash_or_credit" | null;
             flatAmountCents: number | null;
             currency: string | null;
             validFrom: string | null;
@@ -1286,9 +1286,9 @@ export declare const policiesService: {
         bookingId: string | null;
         orderId: string | null;
         method: "signature" | "implicit" | "explicit_checkbox";
-        policyVersionId: string;
-        offerId: string | null;
         acceptedAt: Date;
+        offerId: string | null;
+        policyVersionId: string;
         acceptedBy: string | null;
     } | null>;
 };

package/dist/policies/validation.d.ts

@@ -22,10 +22,10 @@ export declare const policyRuleTypeSchema: z.ZodEnum<{
     date_range: "date_range";
 }>;
 export declare const policyRefundTypeSchema: z.ZodEnum<{
+    none: "none";
     cash: "cash";
     credit: "credit";
     cash_or_credit: "cash_or_credit";
-    none: "none";
 }>;
 export declare const policyAssignmentScopeSchema: z.ZodEnum<{
     supplier: "supplier";
@@ -114,10 +114,10 @@ export declare const insertPolicyRuleSchema: z.ZodObject<{
     daysBeforeDeparture: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
     refundPercent: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
     refundType: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+        none: "none";
         cash: "cash";
         credit: "credit";
         cash_or_credit: "cash_or_credit";
-        none: "none";
     }>>>;
     flatAmountCents: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
     currency: z.ZodNullable<z.ZodOptional<z.ZodString>>;
@@ -138,10 +138,10 @@ export declare const updatePolicyRuleSchema: z.ZodObject<{
     daysBeforeDeparture: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodNumber>>>;
     refundPercent: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodNumber>>>;
     refundType: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+        none: "none";
         cash: "cash";
         credit: "credit";
         cash_or_credit: "cash_or_credit";
-        none: "none";
     }>>>>;
     flatAmountCents: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodNumber>>>;
     currency: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voyantjs/legal",
-  "version": "0.6.9",
+  "version": "0.8.0",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",
   "exports": {
@@ -53,13 +53,14 @@
     "drizzle-orm": "^0.45.2",
     "hono": "^4.12.10",
     "zod": "^4.3.6",
-    "@voyantjs/core": "0.6.9",
-    "@voyantjs/crm": "0.6.9",
-    "@voyantjs/db": "0.6.9",
-    "@voyantjs/hono": "0.6.9",
-    "@voyantjs/suppliers": "0.6.9",
-    "@voyantjs/utils": "0.6.9",
-    "@voyantjs/voyant-storage": "0.6.9"
+    "@voyantjs/bookings": "0.8.0",
+    "@voyantjs/core": "0.8.0",
+    "@voyantjs/crm": "0.8.0",
+    "@voyantjs/db": "0.8.0",
+    "@voyantjs/hono": "0.8.0",
+    "@voyantjs/suppliers": "0.8.0",
+    "@voyantjs/utils": "0.8.0",
+    "@voyantjs/voyant-storage": "0.8.0"
   },
   "devDependencies": {
     "typescript": "^6.0.2",