@voyantjs/finance-contracts 0.95.0

package/dist/validation-public.js

@@ -0,0 +1,216 @@
+import { z } from "zod";
+import { paymentInstrumentStatusSchema, paymentInstrumentTypeSchema, paymentMethodSchema, paymentScheduleStatusSchema, paymentScheduleTypeSchema, paymentSessionStatusSchema, paymentSessionTargetTypeSchema, } from "./validation-shared.js";
+export const publicFinanceInvoiceTypeSchema = z.enum(["invoice", "proforma", "credit_note"]);
+export const publicFinanceDocumentAvailabilitySchema = z.enum([
+    "missing",
+    "pending",
+    "ready",
+    "failed",
+    "stale",
+]);
+export const publicFinanceDocumentFormatSchema = z.enum(["html", "pdf", "xml", "json"]);
+export const publicPaymentOptionsQuerySchema = z.object({
+    personId: z.string().optional(),
+    organizationId: z.string().optional(),
+    provider: z.string().optional(),
+    instrumentType: paymentInstrumentTypeSchema.optional(),
+    includeInactive: z.coerce.boolean().default(false),
+});
+export const publicStartPaymentSessionSchema = z.object({
+    provider: z.string().max(255).optional().nullable(),
+    paymentMethod: paymentMethodSchema.optional().nullable(),
+    paymentInstrumentId: z.string().optional().nullable(),
+    payerPersonId: z.string().optional().nullable(),
+    payerOrganizationId: z.string().optional().nullable(),
+    payerEmail: z.string().email().optional().nullable(),
+    payerName: z.string().max(255).optional().nullable(),
+    externalReference: z.string().max(255).optional().nullable(),
+    idempotencyKey: z.string().max(255).optional().nullable(),
+    clientReference: z.string().max(255).optional().nullable(),
+    returnUrl: z.string().url().optional().nullable(),
+    cancelUrl: z.string().url().optional().nullable(),
+    callbackUrl: z.string().url().optional().nullable(),
+    expiresAt: z.string().optional().nullable(),
+    notes: z.string().optional().nullable(),
+    providerPayload: z.record(z.string(), z.unknown()).optional().nullable(),
+    metadata: z.record(z.string(), z.unknown()).optional().nullable(),
+});
+export const publicValidateVoucherSchema = z.object({
+    code: z.string().min(1).max(255),
+    provider: z.string().max(255).optional().nullable(),
+    bookingId: z.string().optional().nullable(),
+    currency: z.string().min(3).max(3).optional().nullable(),
+    amountCents: z.number().int().min(1).optional().nullable(),
+});
+export const publicFinanceDocumentLookupQuerySchema = z.object({
+    reference: z.string().min(1).max(255),
+    invoiceType: publicFinanceInvoiceTypeSchema.optional(),
+});
+export const publicPaymentAccountSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    provider: z.string().nullable(),
+    instrumentType: paymentInstrumentTypeSchema,
+    status: paymentInstrumentStatusSchema,
+    brand: z.string().nullable(),
+    last4: z.string().nullable(),
+    expiryMonth: z.number().int().nullable(),
+    expiryYear: z.number().int().nullable(),
+    isDefault: z.boolean(),
+});
+export const publicBookingPaymentScheduleSchema = z.object({
+    id: z.string(),
+    scheduleType: paymentScheduleTypeSchema,
+    status: paymentScheduleStatusSchema,
+    dueDate: z.string(),
+    currency: z.string(),
+    amountCents: z.number().int(),
+    notes: z.string().nullable(),
+});
+export const publicBookingGuaranteeSchema = z.object({
+    id: z.string(),
+    bookingPaymentScheduleId: z.string().nullable(),
+    guaranteeType: z.string(),
+    status: z.string(),
+    currency: z.string().nullable(),
+    amountCents: z.number().int().nullable(),
+    provider: z.string().nullable(),
+    referenceNumber: z.string().nullable(),
+    expiresAt: z.string().nullable(),
+    notes: z.string().nullable(),
+});
+export const publicBookingPaymentOptionsSchema = z.object({
+    bookingId: z.string(),
+    accounts: z.array(publicPaymentAccountSchema),
+    schedules: z.array(publicBookingPaymentScheduleSchema),
+    guarantees: z.array(publicBookingGuaranteeSchema),
+    recommendedTarget: z
+        .object({
+        targetType: z.enum(["booking_payment_schedule", "booking_guarantee"]).nullable(),
+        targetId: z.string().nullable(),
+    })
+        .nullable(),
+});
+export const publicPaymentSessionSchema = z.object({
+    id: z.string(),
+    targetType: paymentSessionTargetTypeSchema,
+    targetId: z.string().nullable(),
+    bookingId: z.string().nullable(),
+    invoiceId: z.string().nullable(),
+    bookingPaymentScheduleId: z.string().nullable(),
+    bookingGuaranteeId: z.string().nullable(),
+    status: paymentSessionStatusSchema,
+    provider: z.string().nullable(),
+    providerSessionId: z.string().nullable(),
+    providerPaymentId: z.string().nullable(),
+    externalReference: z.string().nullable(),
+    clientReference: z.string().nullable(),
+    currency: z.string(),
+    amountCents: z.number().int(),
+    paymentMethod: paymentMethodSchema.nullable(),
+    payerEmail: z.string().nullable(),
+    payerName: z.string().nullable(),
+    redirectUrl: z.string().nullable(),
+    returnUrl: z.string().nullable(),
+    cancelUrl: z.string().nullable(),
+    expiresAt: z.string().nullable(),
+    completedAt: z.string().nullable(),
+    failureCode: z.string().nullable(),
+    failureMessage: z.string().nullable(),
+    /**
+     * Operator-supplied human-readable context (e.g. "London → New York,
+     * Sat 16 May · Diego Müller"). Surfaced on the public landing page so
+     * the customer can see what they're paying for. Server-controlled — only
+     * populated when the session is created with `notes`.
+     */
+    notes: z.string().nullable(),
+});
+export const publicFinanceBookingDocumentSchema = z.object({
+    invoiceId: z.string(),
+    invoiceNumber: z.string(),
+    invoiceType: publicFinanceInvoiceTypeSchema,
+    invoiceStatus: z.enum([
+        "draft",
+        "pending_external_allocation",
+        "issued",
+        "partially_paid",
+        "paid",
+        "overdue",
+        "void",
+    ]),
+    currency: z.string(),
+    totalCents: z.number().int(),
+    paidCents: z.number().int(),
+    balanceDueCents: z.number().int(),
+    issueDate: z.string(),
+    dueDate: z.string(),
+    renditionId: z.string().nullable(),
+    documentStatus: publicFinanceDocumentAvailabilitySchema,
+    format: publicFinanceDocumentFormatSchema.nullable(),
+    language: z.string().nullable(),
+    generatedAt: z.string().nullable(),
+    fileSize: z.number().int().nullable(),
+    checksum: z.string().nullable(),
+    downloadUrl: z.string().nullable(),
+});
+export const publicBookingFinanceDocumentsSchema = z.object({
+    bookingId: z.string(),
+    documents: z.array(publicFinanceBookingDocumentSchema),
+});
+export const publicFinanceDocumentLookupSchema = publicFinanceBookingDocumentSchema.extend({
+    bookingId: z.string(),
+});
+export const publicFinanceBookingPaymentSchema = z.object({
+    id: z.string(),
+    invoiceId: z.string(),
+    invoiceNumber: z.string(),
+    invoiceType: publicFinanceInvoiceTypeSchema,
+    status: z.enum(["pending", "completed", "failed", "refunded"]),
+    paymentMethod: paymentMethodSchema,
+    amountCents: z.number().int(),
+    currency: z.string(),
+    /**
+     * When the customer paid in a currency different from the invoice
+     * (`currency`), `baseCurrency` is the invoice's currency and
+     * `baseAmountCents` is the converted amount at the payment date.
+     * Both are null for same-currency payments.
+     */
+    baseCurrency: z.string().nullable(),
+    baseAmountCents: z.number().int().nullable(),
+    paymentDate: z.string(),
+    referenceNumber: z.string().nullable(),
+    notes: z.string().nullable(),
+});
+export const publicBookingFinancePaymentsSchema = z.object({
+    bookingId: z.string(),
+    payments: z.array(publicFinanceBookingPaymentSchema),
+});
+export const publicVoucherValidationSchema = z.object({
+    valid: z.boolean(),
+    reason: z
+        .enum([
+        "not_found",
+        "inactive",
+        "not_started",
+        "expired",
+        "booking_mismatch",
+        "currency_mismatch",
+        "insufficient_balance",
+    ])
+        .nullable(),
+    voucher: z
+        .object({
+        id: z.string(),
+        code: z.string(),
+        // Nullable: the new vouchers table (#239) doesn't carry a separate
+        // label column — display falls back to `code`. Legacy
+        // payment_instruments rows still populate this.
+        label: z.string().nullable(),
+        provider: z.string().nullable(),
+        currency: z.string().nullable(),
+        amountCents: z.number().int().nullable(),
+        remainingAmountCents: z.number().int().nullable(),
+        expiresAt: z.string().nullable(),
+    })
+        .nullable(),
+});

package/dist/validation-shared.d.ts

@@ -0,0 +1,200 @@
+import { z } from "zod";
+export declare const invoiceStatusSchema: z.ZodEnum<{
+    draft: "draft";
+    pending_external_allocation: "pending_external_allocation";
+    issued: "issued";
+    partially_paid: "partially_paid";
+    paid: "paid";
+    overdue: "overdue";
+    void: "void";
+}>;
+export declare const paymentMethodSchema: z.ZodEnum<{
+    bank_transfer: "bank_transfer";
+    credit_card: "credit_card";
+    debit_card: "debit_card";
+    cash: "cash";
+    cheque: "cheque";
+    wallet: "wallet";
+    direct_bill: "direct_bill";
+    voucher: "voucher";
+    other: "other";
+}>;
+export declare const paymentStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    failed: "failed";
+    completed: "completed";
+    refunded: "refunded";
+}>;
+export declare const paymentSessionStatusSchema: z.ZodEnum<{
+    paid: "paid";
+    pending: "pending";
+    failed: "failed";
+    expired: "expired";
+    requires_redirect: "requires_redirect";
+    processing: "processing";
+    authorized: "authorized";
+    cancelled: "cancelled";
+}>;
+export declare const paymentSessionTargetTypeSchema: z.ZodEnum<{
+    other: "other";
+    invoice: "invoice";
+    booking: "booking";
+    order: "order";
+    booking_payment_schedule: "booking_payment_schedule";
+    booking_guarantee: "booking_guarantee";
+    flight_order: "flight_order";
+}>;
+export declare const paymentInstrumentTypeSchema: z.ZodEnum<{
+    credit_card: "credit_card";
+    debit_card: "debit_card";
+    cash: "cash";
+    wallet: "wallet";
+    direct_bill: "direct_bill";
+    voucher: "voucher";
+    other: "other";
+    bank_account: "bank_account";
+}>;
+export declare const paymentInstrumentOwnerTypeSchema: z.ZodEnum<{
+    other: "other";
+    channel: "channel";
+    agency: "agency";
+    internal: "internal";
+    supplier: "supplier";
+    client: "client";
+}>;
+export declare const paymentInstrumentStatusSchema: z.ZodEnum<{
+    active: "active";
+    inactive: "inactive";
+    expired: "expired";
+    revoked: "revoked";
+    failed_verification: "failed_verification";
+}>;
+export declare const paymentAuthorizationStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    failed: "failed";
+    expired: "expired";
+    authorized: "authorized";
+    partially_captured: "partially_captured";
+    captured: "captured";
+    voided: "voided";
+}>;
+export declare const paymentCaptureStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    failed: "failed";
+    voided: "voided";
+    completed: "completed";
+    refunded: "refunded";
+}>;
+export declare const captureModeSchema: z.ZodEnum<{
+    automatic: "automatic";
+    manual: "manual";
+}>;
+export declare const creditNoteStatusSchema: z.ZodEnum<{
+    draft: "draft";
+    issued: "issued";
+    applied: "applied";
+}>;
+export declare const paymentScheduleTypeSchema: z.ZodEnum<{
+    other: "other";
+    deposit: "deposit";
+    installment: "installment";
+    balance: "balance";
+    hold: "hold";
+}>;
+export declare const paymentScheduleStatusSchema: z.ZodEnum<{
+    paid: "paid";
+    pending: "pending";
+    expired: "expired";
+    cancelled: "cancelled";
+    due: "due";
+    waived: "waived";
+}>;
+export declare const guaranteeTypeSchema: z.ZodEnum<{
+    bank_transfer: "bank_transfer";
+    credit_card: "credit_card";
+    voucher: "voucher";
+    other: "other";
+    deposit: "deposit";
+    preauth: "preauth";
+    card_on_file: "card_on_file";
+    agency_letter: "agency_letter";
+}>;
+export declare const guaranteeStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    active: "active";
+    failed: "failed";
+    expired: "expired";
+    cancelled: "cancelled";
+    released: "released";
+}>;
+export declare const taxScopeSchema: z.ZodEnum<{
+    included: "included";
+    excluded: "excluded";
+    withheld: "withheld";
+}>;
+export declare const commissionRecipientTypeSchema: z.ZodEnum<{
+    other: "other";
+    channel: "channel";
+    affiliate: "affiliate";
+    agency: "agency";
+    agent: "agent";
+    internal: "internal";
+    supplier: "supplier";
+}>;
+export declare const commissionModelSchema: z.ZodEnum<{
+    percentage: "percentage";
+    fixed: "fixed";
+    markup: "markup";
+    net: "net";
+}>;
+export declare const commissionStatusSchema: z.ZodEnum<{
+    paid: "paid";
+    void: "void";
+    pending: "pending";
+    accrued: "accrued";
+    payable: "payable";
+}>;
+export declare const paginationSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export declare const voucherStatusSchema: z.ZodEnum<{
+    void: "void";
+    active: "active";
+    expired: "expired";
+    redeemed: "redeemed";
+}>;
+export declare const voucherSourceTypeSchema: z.ZodEnum<{
+    manual: "manual";
+    refund: "refund";
+    cancellation_credit: "cancellation_credit";
+    gift: "gift";
+    promo: "promo";
+}>;
+export declare const financeAggregatesQuerySchema: z.ZodObject<{
+    range: z.ZodDefault<z.ZodEnum<{
+        custom: "custom";
+        this_month: "this_month";
+        last_month: "last_month";
+        year_to_date: "year_to_date";
+        all_time: "all_time";
+    }>>;
+    from: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodString>;
+    currency: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodString>>>>;
+    invoiceType: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        invoice: "invoice";
+        proforma: "proforma";
+    }>>>>>;
+    status: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        draft: "draft";
+        pending_external_allocation: "pending_external_allocation";
+        issued: "issued";
+        partially_paid: "partially_paid";
+        paid: "paid";
+        overdue: "overdue";
+        void: "void";
+    }>>>>>;
+    outstandingTopLimit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+//# sourceMappingURL=validation-shared.d.ts.map

package/dist/validation-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-shared.d.ts","sourceRoot":"","sources":["../src/validation-shared.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,mBAAmB;;;;;;;;EAQ9B,CAAA;AACF,eAAO,MAAM,mBAAmB;;;;;;;;;;EAU9B,CAAA;AACF,eAAO,MAAM,mBAAmB;;;;;EAAyD,CAAA;AACzF,eAAO,MAAM,0BAA0B;;;;;;;;;EASrC,CAAA;AACF,eAAO,MAAM,8BAA8B;;;;;;;;EAQzC,CAAA;AACF,eAAO,MAAM,2BAA2B;;;;;;;;;EAStC,CAAA;AACF,eAAO,MAAM,gCAAgC;;;;;;;EAO3C,CAAA;AACF,eAAO,MAAM,6BAA6B;;;;;;EAMxC,CAAA;AACF,eAAO,MAAM,gCAAgC;;;;;;;;EAQ3C,CAAA;AACF,eAAO,MAAM,0BAA0B;;;;;;EAMrC,CAAA;AACF,eAAO,MAAM,iBAAiB;;;EAAkC,CAAA;AAChE,eAAO,MAAM,sBAAsB;;;;EAAyC,CAAA;AAC5E,eAAO,MAAM,yBAAyB;;;;;;EAMpC,CAAA;AACF,eAAO,MAAM,2BAA2B;;;;;;;EAOtC,CAAA;AACF,eAAO,MAAM,mBAAmB;;;;;;;;;EAS9B,CAAA;AACF,eAAO,MAAM,qBAAqB;;;;;;;EAOhC,CAAA;AACF,eAAO,MAAM,cAAc;;;;EAA+C,CAAA;AAC1E,eAAO,MAAM,6BAA6B;;;;;;;;EAQxC,CAAA;AACF,eAAO,MAAM,qBAAqB;;;;;EAAmD,CAAA;AACrF,eAAO,MAAM,sBAAsB;;;;;;EAA4D,CAAA;AAE/F,eAAO,MAAM,gBAAgB;;;iBAG3B,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;EAAoD,CAAA;AACpF,eAAO,MAAM,uBAAuB;;;;;;EAMlC,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;iBAiDvC,CAAA"}

package/dist/validation-shared.js

@@ -0,0 +1,179 @@
+import { z } from "zod";
+export const invoiceStatusSchema = z.enum([
+    "draft",
+    "pending_external_allocation",
+    "issued",
+    "partially_paid",
+    "paid",
+    "overdue",
+    "void",
+]);
+export const paymentMethodSchema = z.enum([
+    "bank_transfer",
+    "credit_card",
+    "debit_card",
+    "cash",
+    "cheque",
+    "wallet",
+    "direct_bill",
+    "voucher",
+    "other",
+]);
+export const paymentStatusSchema = z.enum(["pending", "completed", "failed", "refunded"]);
+export const paymentSessionStatusSchema = z.enum([
+    "pending",
+    "requires_redirect",
+    "processing",
+    "authorized",
+    "paid",
+    "failed",
+    "cancelled",
+    "expired",
+]);
+export const paymentSessionTargetTypeSchema = z.enum([
+    "booking",
+    "order",
+    "invoice",
+    "booking_payment_schedule",
+    "booking_guarantee",
+    "flight_order",
+    "other",
+]);
+export const paymentInstrumentTypeSchema = z.enum([
+    "credit_card",
+    "debit_card",
+    "bank_account",
+    "wallet",
+    "voucher",
+    "direct_bill",
+    "cash",
+    "other",
+]);
+export const paymentInstrumentOwnerTypeSchema = z.enum([
+    "client",
+    "supplier",
+    "channel",
+    "agency",
+    "internal",
+    "other",
+]);
+export const paymentInstrumentStatusSchema = z.enum([
+    "active",
+    "inactive",
+    "expired",
+    "revoked",
+    "failed_verification",
+]);
+export const paymentAuthorizationStatusSchema = z.enum([
+    "pending",
+    "authorized",
+    "partially_captured",
+    "captured",
+    "voided",
+    "failed",
+    "expired",
+]);
+export const paymentCaptureStatusSchema = z.enum([
+    "pending",
+    "completed",
+    "failed",
+    "refunded",
+    "voided",
+]);
+export const captureModeSchema = z.enum(["automatic", "manual"]);
+export const creditNoteStatusSchema = z.enum(["draft", "issued", "applied"]);
+export const paymentScheduleTypeSchema = z.enum([
+    "deposit",
+    "installment",
+    "balance",
+    "hold",
+    "other",
+]);
+export const paymentScheduleStatusSchema = z.enum([
+    "pending",
+    "due",
+    "paid",
+    "waived",
+    "cancelled",
+    "expired",
+]);
+export const guaranteeTypeSchema = z.enum([
+    "deposit",
+    "credit_card",
+    "preauth",
+    "card_on_file",
+    "bank_transfer",
+    "voucher",
+    "agency_letter",
+    "other",
+]);
+export const guaranteeStatusSchema = z.enum([
+    "pending",
+    "active",
+    "released",
+    "failed",
+    "cancelled",
+    "expired",
+]);
+export const taxScopeSchema = z.enum(["included", "excluded", "withheld"]);
+export const commissionRecipientTypeSchema = z.enum([
+    "channel",
+    "affiliate",
+    "agency",
+    "agent",
+    "internal",
+    "supplier",
+    "other",
+]);
+export const commissionModelSchema = z.enum(["percentage", "fixed", "markup", "net"]);
+export const commissionStatusSchema = z.enum(["pending", "accrued", "payable", "paid", "void"]);
+export const paginationSchema = z.object({
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+    offset: z.coerce.number().int().min(0).default(0),
+});
+export const voucherStatusSchema = z.enum(["active", "redeemed", "expired", "void"]);
+export const voucherSourceTypeSchema = z.enum([
+    "refund",
+    "cancellation_credit",
+    "gift",
+    "manual",
+    "promo",
+]);
+export const financeAggregatesQuerySchema = z.object({
+    range: z
+        .enum(["this_month", "last_month", "year_to_date", "all_time", "custom"])
+        .default("all_time"),
+    from: z.string().datetime().optional(),
+    to: z.string().datetime().optional(),
+    currency: z
+        .preprocess((value) => typeof value === "string"
+        ? value
+            .split(",")
+            .map((item) => item.trim())
+            .filter(Boolean)
+        : value, z.array(z.string().trim().min(1)).optional())
+        .optional(),
+    invoiceType: z
+        .preprocess((value) => typeof value === "string"
+        ? value
+            .split(",")
+            .map((item) => item.trim())
+            .filter(Boolean)
+        : value, z.array(z.enum(["invoice", "proforma"])).optional())
+        .optional(),
+    status: z
+        .preprocess((value) => typeof value === "string"
+        ? value
+            .split(",")
+            .map((item) => item.trim())
+            .filter(Boolean)
+        : value, z.array(invoiceStatusSchema).optional())
+        .optional(),
+    /**
+     * Cap on the top-N outstanding-invoice rows returned alongside the
+     * outstanding-by-currency aggregate. The dashboard surfaces 5 rows
+     * in its "needs collection" panel; allow up to 20 so adjacent
+     * digests can reuse the endpoint.
+     */
+    outstandingTopLimit: z.coerce.number().int().min(0).max(20).default(5),
+});

package/dist/validation-vouchers.d.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+/** Issue a new voucher. Code is generated server-side when not supplied. */
+export declare const insertVoucherSchema: z.ZodObject<{
+    code: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    seriesCode: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    currency: z.ZodString;
+    amountCents: z.ZodNumber;
+    issuedToPersonId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    issuedToOrganizationId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    sourceType: z.ZodEnum<{
+        manual: "manual";
+        refund: "refund";
+        cancellation_credit: "cancellation_credit";
+        gift: "gift";
+        promo: "promo";
+    }>;
+    sourceBookingId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    sourcePaymentId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    validFrom: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    expiresAt: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    notes: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Update metadata. Balance (remainingAmountCents) is not in here on purpose —
+ * it's only mutated via `redeem`, transactionally, with a redemption row.
+ */
+export declare const updateVoucherSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<{
+        void: "void";
+        active: "active";
+        expired: "expired";
+        redeemed: "redeemed";
+    }>>;
+    seriesCode: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    validFrom: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    expiresAt: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    notes: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    issuedToPersonId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    issuedToOrganizationId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+/** Apply a voucher against a booking. */
+export declare const redeemVoucherSchema: z.ZodObject<{
+    bookingId: z.ZodString;
+    amountCents: z.ZodNumber;
+    paymentId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const voucherListQuerySchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<{
+        void: "void";
+        active: "active";
+        expired: "expired";
+        redeemed: "redeemed";
+    }>>;
+    seriesCode: z.ZodOptional<z.ZodString>;
+    issuedToPersonId: z.ZodOptional<z.ZodString>;
+    issuedToOrganizationId: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    hasBalance: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+//# sourceMappingURL=validation-vouchers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation-vouchers.d.ts","sourceRoot":"","sources":["../src/validation-vouchers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,4EAA4E;AAC5E,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;iBAa9B,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;iBAQ9B,CAAA;AAEF,yCAAyC;AACzC,eAAO,MAAM,mBAAmB;;;;iBAI9B,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;iBASjC,CAAA"}