@riverbankcms/sdk 0.147.0 → 0.149.0

package/dist/_dts/core/src/booking-live-payment-terms.d.ts

@@ -0,0 +1,72 @@
+import type { BookingFlexibleBalanceContractStatus } from './booking-flexible-balance';
+import type { OrderInstalmentPlanStatus } from './booking-instalments';
+/**
+ * Whether an order still has payment terms being collected: an instalment plan
+ * or a flexible-balance contract that hasn't been settled, closed or cancelled.
+ *
+ * Both tables are total over their status unions, so a new status is a compile
+ * error here until someone decides whether it counts as live.
+ */
+declare const LIVE_PLAN_STATUSES: {
+    readonly pending_initial_payment: true;
+    readonly active: true;
+    readonly payment_failed: true;
+    readonly reconciliation_required: true;
+    readonly completed: false;
+    readonly cancelled: false;
+    readonly cancelled_as_paid_early: false;
+    readonly refunded: false;
+};
+declare const LIVE_CONTRACT_STATUSES: {
+    readonly active: true;
+    readonly payment_pending: true;
+    readonly overdue: true;
+    readonly completed: false;
+    readonly waived: false;
+    readonly refunded: false;
+    readonly cancelled_due_to_non_payment: false;
+    readonly closed_order_failed: false;
+};
+type LiveKeys<TTable extends Record<string, boolean>> = {
+    [K in keyof TTable]: TTable[K] extends true ? K : never;
+}[keyof TTable];
+/** The plan statuses in which instalments are still being collected. */
+export type LiveOrderInstalmentPlanStatus = LiveKeys<typeof LIVE_PLAN_STATUSES>;
+export declare function isLiveOrderInstalmentPlanStatus(status: OrderInstalmentPlanStatus): status is LiveOrderInstalmentPlanStatus;
+/** The contract statuses in which a balance is still being collected. */
+export type LiveFlexibleBalanceContractStatus = LiveKeys<typeof LIVE_CONTRACT_STATUSES>;
+export declare function isLiveFlexibleBalanceContractStatus(status: BookingFlexibleBalanceContractStatus): status is LiveFlexibleBalanceContractStatus;
+export type LivePaymentTermsInput = Readonly<{
+    plan: Readonly<{
+        status: OrderInstalmentPlanStatus;
+    }> | null;
+    contract: Readonly<{
+        status: BookingFlexibleBalanceContractStatus;
+    }> | null;
+}>;
+export declare function hasLivePaymentTerms(input: LivePaymentTermsInput): boolean;
+/** Partial refunds must also protect a cancelled contract that staff can reopen. */
+export declare function paymentTermsBlockPartialRefund(input: LivePaymentTermsInput): boolean;
+/**
+ * Whether an instalment plan's remaining balance can take a payment now, by
+ * hand or online: it's live and no collection is in flight.
+ */
+export declare function isSettleableOrderInstalmentPlanStatus(status: OrderInstalmentPlanStatus): boolean;
+/**
+ * Whether a flexible-balance contract's remaining balance can take a payment
+ * now, by hand or online: it's live and no collection is in flight.
+ */
+export declare function isSettleableFlexibleBalanceContractStatus(status: BookingFlexibleBalanceContractStatus): boolean;
+/**
+ * What happens to a flexible-balance contract when its order fails or is
+ * retired before it completes. Only a live contract is closed; one that was
+ * already settled, waived, refunded, cancelled or closed keeps its status.
+ */
+export type FailedOrderContractClosure = Readonly<{
+    kind: 'close';
+    from: LiveFlexibleBalanceContractStatus;
+}> | Readonly<{
+    kind: 'keep';
+}>;
+export declare function decideContractClosureForFailedOrder(status: BookingFlexibleBalanceContractStatus): FailedOrderContractClosure;
+export {};

package/dist/_dts/core/src/booking-payment-options.d.ts

@@ -0,0 +1,24 @@
+import type { BookingFlexibleBalanceConfig } from './booking-flexible-balance';
+import type { BookingInstalmentPlanConfig } from './booking-instalments';
+import { type Result } from './result';
+/**
+ * One way a customer may pay for a booking. This is the single definition of
+ * the option type; `booking-payment-schemas.typetest.ts` keeps it equal to the
+ * schema's output in both directions.
+ */
+export type BookingPaymentCollectionOption = Readonly<{
+    kind: 'upfront';
+}> | Readonly<{
+    kind: 'deferred_manual';
+}> | Readonly<{
+    kind: 'instalment_plan';
+    plan: BookingInstalmentPlanConfig;
+}> | Readonly<{
+    kind: 'flexible_balance';
+    config: BookingFlexibleBalanceConfig;
+}>;
+/** The ways a customer may pay for a booking: the one kind set. */
+export type BookingPaymentCollectionOptionKind = BookingPaymentCollectionOption['kind'];
+export type BookingPaymentOptionKindsError = 'no_options' | 'duplicate_kind' | 'incompatible_collection_options';
+/** Automatic instalments and a flexible balance cannot share one booking offer. */
+export declare function validateBookingPaymentOptionKinds(kinds: readonly BookingPaymentCollectionOptionKind[]): Result<void, BookingPaymentOptionKindsError>;

package/dist/_dts/core/src/booking-payment-schemas.d.ts

@@ -0,0 +1,522 @@
+import { z } from 'zod';
+/**
+ * The one declaration of a booking payment option's shape: the option kinds,
+ * instalment plans and flexible-balance configs. Stored terms, API bodies,
+ * site commands and block props all parse through it.
+ *
+ * This module is a subpath (`@riverbankcms/core/booking-payment-schemas`) so
+ * core's main entry stays free of zod.
+ *
+ * `strip` drops unknown keys (readers and API bodies); `strict` rejects them
+ * (site commands, which must not accept fields they'd silently ignore).
+ */
+export type BookingPaymentSchemaObjectMode = 'strip' | 'strict';
+type ObjectFactory<TConfig extends z.core.$ZodObjectConfig> = <TShape extends z.ZodRawShape>(shape: TShape) => z.ZodObject<TShape, TConfig>;
+declare function buildBookingPaymentOptionSchemas<TConfig extends z.core.$ZodObjectConfig>(object: ObjectFactory<TConfig>): {
+    depositRefundPolicy: z.ZodEnum<{
+        refundable: "refundable";
+        non_refundable: "non_refundable";
+    }>;
+    instalmentPlan: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"deposit_plus_one_remainder">;
+        depositAmountCents: z.ZodNumber;
+        depositRefundability: z.ZodEnum<{
+            refundable: "refundable";
+            non_refundable: "non_refundable";
+        }>;
+        remainderDueCount: z.ZodNumber;
+        intervalUnit: z.ZodEnum<{
+            day: "day";
+            week: "week";
+            month: "month";
+        }>;
+    }, TConfig>, z.ZodObject<{
+        kind: z.ZodLiteral<"deposit_plus_scheduled_instalments">;
+        depositAmountCents: z.ZodNumber;
+        depositRefundability: z.ZodEnum<{
+            refundable: "refundable";
+            non_refundable: "non_refundable";
+        }>;
+        instalmentCount: z.ZodNumber;
+        intervalCount: z.ZodNumber;
+        intervalUnit: z.ZodEnum<{
+            day: "day";
+            week: "week";
+            month: "month";
+        }>;
+    }, TConfig>, z.ZodObject<{
+        kind: z.ZodLiteral<"equal_scheduled_instalments">;
+        instalmentCount: z.ZodNumber;
+        intervalCount: z.ZodNumber;
+        intervalUnit: z.ZodEnum<{
+            day: "day";
+            week: "week";
+            month: "month";
+        }>;
+    }, TConfig>], "kind">;
+    flexibleBalanceDueDateRule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"relative_to_start_date">;
+        daysBeforeStart: z.ZodNumber;
+    }, TConfig>, z.ZodObject<{
+        kind: z.ZodLiteral<"fixed_calendar_date">;
+        dueAt: z.ZodString;
+    }, TConfig>], "kind">;
+    flexibleBalanceConfig: z.ZodObject<{
+        upfrontAmountCents: z.ZodNumber;
+        dueDateRule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"relative_to_start_date">;
+            daysBeforeStart: z.ZodNumber;
+        }, TConfig>, z.ZodObject<{
+            kind: z.ZodLiteral<"fixed_calendar_date">;
+            dueAt: z.ZodString;
+        }, TConfig>], "kind">;
+        depositRefundability: z.ZodEnum<{
+            refundable: "refundable";
+            non_refundable: "non_refundable";
+        }>;
+    }, TConfig>;
+    paymentCollectionOption: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"upfront">;
+    }, TConfig>, z.ZodObject<{
+        kind: z.ZodLiteral<"deferred_manual">;
+    }, TConfig>, z.ZodObject<{
+        kind: z.ZodLiteral<"instalment_plan">;
+        plan: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"deposit_plus_one_remainder">;
+            depositAmountCents: z.ZodNumber;
+            depositRefundability: z.ZodEnum<{
+                refundable: "refundable";
+                non_refundable: "non_refundable";
+            }>;
+            remainderDueCount: z.ZodNumber;
+            intervalUnit: z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+            }>;
+        }, TConfig>, z.ZodObject<{
+            kind: z.ZodLiteral<"deposit_plus_scheduled_instalments">;
+            depositAmountCents: z.ZodNumber;
+            depositRefundability: z.ZodEnum<{
+                refundable: "refundable";
+                non_refundable: "non_refundable";
+            }>;
+            instalmentCount: z.ZodNumber;
+            intervalCount: z.ZodNumber;
+            intervalUnit: z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+            }>;
+        }, TConfig>, z.ZodObject<{
+            kind: z.ZodLiteral<"equal_scheduled_instalments">;
+            instalmentCount: z.ZodNumber;
+            intervalCount: z.ZodNumber;
+            intervalUnit: z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+            }>;
+        }, TConfig>], "kind">;
+    }, TConfig>, z.ZodObject<{
+        kind: z.ZodLiteral<"flexible_balance">;
+        config: z.ZodObject<{
+            upfrontAmountCents: z.ZodNumber;
+            dueDateRule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"relative_to_start_date">;
+                daysBeforeStart: z.ZodNumber;
+            }, TConfig>, z.ZodObject<{
+                kind: z.ZodLiteral<"fixed_calendar_date">;
+                dueAt: z.ZodString;
+            }, TConfig>], "kind">;
+            depositRefundability: z.ZodEnum<{
+                refundable: "refundable";
+                non_refundable: "non_refundable";
+            }>;
+        }, TConfig>;
+    }, TConfig>], "kind">;
+    paymentTerms: z.ZodObject<{
+        allowedOptions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"upfront">;
+        }, TConfig>, z.ZodObject<{
+            kind: z.ZodLiteral<"deferred_manual">;
+        }, TConfig>, z.ZodObject<{
+            kind: z.ZodLiteral<"instalment_plan">;
+            plan: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"deposit_plus_one_remainder">;
+                depositAmountCents: z.ZodNumber;
+                depositRefundability: z.ZodEnum<{
+                    refundable: "refundable";
+                    non_refundable: "non_refundable";
+                }>;
+                remainderDueCount: z.ZodNumber;
+                intervalUnit: z.ZodEnum<{
+                    day: "day";
+                    week: "week";
+                    month: "month";
+                }>;
+            }, TConfig>, z.ZodObject<{
+                kind: z.ZodLiteral<"deposit_plus_scheduled_instalments">;
+                depositAmountCents: z.ZodNumber;
+                depositRefundability: z.ZodEnum<{
+                    refundable: "refundable";
+                    non_refundable: "non_refundable";
+                }>;
+                instalmentCount: z.ZodNumber;
+                intervalCount: z.ZodNumber;
+                intervalUnit: z.ZodEnum<{
+                    day: "day";
+                    week: "week";
+                    month: "month";
+                }>;
+            }, TConfig>, z.ZodObject<{
+                kind: z.ZodLiteral<"equal_scheduled_instalments">;
+                instalmentCount: z.ZodNumber;
+                intervalCount: z.ZodNumber;
+                intervalUnit: z.ZodEnum<{
+                    day: "day";
+                    week: "week";
+                    month: "month";
+                }>;
+            }, TConfig>], "kind">;
+        }, TConfig>, z.ZodObject<{
+            kind: z.ZodLiteral<"flexible_balance">;
+            config: z.ZodObject<{
+                upfrontAmountCents: z.ZodNumber;
+                dueDateRule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"relative_to_start_date">;
+                    daysBeforeStart: z.ZodNumber;
+                }, TConfig>, z.ZodObject<{
+                    kind: z.ZodLiteral<"fixed_calendar_date">;
+                    dueAt: z.ZodString;
+                }, TConfig>], "kind">;
+                depositRefundability: z.ZodEnum<{
+                    refundable: "refundable";
+                    non_refundable: "non_refundable";
+                }>;
+            }, TConfig>;
+        }, TConfig>], "kind">>;
+    }, TConfig>;
+    paymentOptionsChoice: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"default">;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"custom">;
+        paymentTerms: z.ZodObject<{
+            allowedOptions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"upfront">;
+            }, TConfig>, z.ZodObject<{
+                kind: z.ZodLiteral<"deferred_manual">;
+            }, TConfig>, z.ZodObject<{
+                kind: z.ZodLiteral<"instalment_plan">;
+                plan: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"deposit_plus_one_remainder">;
+                    depositAmountCents: z.ZodNumber;
+                    depositRefundability: z.ZodEnum<{
+                        refundable: "refundable";
+                        non_refundable: "non_refundable";
+                    }>;
+                    remainderDueCount: z.ZodNumber;
+                    intervalUnit: z.ZodEnum<{
+                        day: "day";
+                        week: "week";
+                        month: "month";
+                    }>;
+                }, TConfig>, z.ZodObject<{
+                    kind: z.ZodLiteral<"deposit_plus_scheduled_instalments">;
+                    depositAmountCents: z.ZodNumber;
+                    depositRefundability: z.ZodEnum<{
+                        refundable: "refundable";
+                        non_refundable: "non_refundable";
+                    }>;
+                    instalmentCount: z.ZodNumber;
+                    intervalCount: z.ZodNumber;
+                    intervalUnit: z.ZodEnum<{
+                        day: "day";
+                        week: "week";
+                        month: "month";
+                    }>;
+                }, TConfig>, z.ZodObject<{
+                    kind: z.ZodLiteral<"equal_scheduled_instalments">;
+                    instalmentCount: z.ZodNumber;
+                    intervalCount: z.ZodNumber;
+                    intervalUnit: z.ZodEnum<{
+                        day: "day";
+                        week: "week";
+                        month: "month";
+                    }>;
+                }, TConfig>], "kind">;
+            }, TConfig>, z.ZodObject<{
+                kind: z.ZodLiteral<"flexible_balance">;
+                config: z.ZodObject<{
+                    upfrontAmountCents: z.ZodNumber;
+                    dueDateRule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"relative_to_start_date">;
+                        daysBeforeStart: z.ZodNumber;
+                    }, TConfig>, z.ZodObject<{
+                        kind: z.ZodLiteral<"fixed_calendar_date">;
+                        dueAt: z.ZodString;
+                    }, TConfig>], "kind">;
+                    depositRefundability: z.ZodEnum<{
+                        refundable: "refundable";
+                        non_refundable: "non_refundable";
+                    }>;
+                }, TConfig>;
+            }, TConfig>], "kind">>;
+        }, TConfig>;
+    }, z.core.$strict>], "source">;
+};
+export type BookingPaymentOptionSchemas<TConfig extends z.core.$ZodObjectConfig> = ReturnType<typeof buildBookingPaymentOptionSchemas<TConfig>>;
+export declare function createBookingPaymentOptionSchemas(mode: 'strip'): BookingPaymentOptionSchemas<z.core.$strip>;
+export declare function createBookingPaymentOptionSchemas(mode: 'strict'): BookingPaymentOptionSchemas<z.core.$strict>;
+export declare const bookingDepositRefundPolicySchema: z.ZodEnum<{
+    refundable: "refundable";
+    non_refundable: "non_refundable";
+}>;
+export declare const bookingInstalmentPlanSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"deposit_plus_one_remainder">;
+    depositAmountCents: z.ZodNumber;
+    depositRefundability: z.ZodEnum<{
+        refundable: "refundable";
+        non_refundable: "non_refundable";
+    }>;
+    remainderDueCount: z.ZodNumber;
+    intervalUnit: z.ZodEnum<{
+        day: "day";
+        week: "week";
+        month: "month";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"deposit_plus_scheduled_instalments">;
+    depositAmountCents: z.ZodNumber;
+    depositRefundability: z.ZodEnum<{
+        refundable: "refundable";
+        non_refundable: "non_refundable";
+    }>;
+    instalmentCount: z.ZodNumber;
+    intervalCount: z.ZodNumber;
+    intervalUnit: z.ZodEnum<{
+        day: "day";
+        week: "week";
+        month: "month";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"equal_scheduled_instalments">;
+    instalmentCount: z.ZodNumber;
+    intervalCount: z.ZodNumber;
+    intervalUnit: z.ZodEnum<{
+        day: "day";
+        week: "week";
+        month: "month";
+    }>;
+}, z.core.$strip>], "kind">;
+export declare const bookingFlexibleBalanceDueDateRuleSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"relative_to_start_date">;
+    daysBeforeStart: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"fixed_calendar_date">;
+    dueAt: z.ZodString;
+}, z.core.$strip>], "kind">;
+export declare const bookingFlexibleBalanceConfigSchema: z.ZodObject<{
+    upfrontAmountCents: z.ZodNumber;
+    dueDateRule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"relative_to_start_date">;
+        daysBeforeStart: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"fixed_calendar_date">;
+        dueAt: z.ZodString;
+    }, z.core.$strip>], "kind">;
+    depositRefundability: z.ZodEnum<{
+        refundable: "refundable";
+        non_refundable: "non_refundable";
+    }>;
+}, z.core.$strip>;
+export declare const bookingPaymentCollectionOptionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"upfront">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"deferred_manual">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"instalment_plan">;
+    plan: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"deposit_plus_one_remainder">;
+        depositAmountCents: z.ZodNumber;
+        depositRefundability: z.ZodEnum<{
+            refundable: "refundable";
+            non_refundable: "non_refundable";
+        }>;
+        remainderDueCount: z.ZodNumber;
+        intervalUnit: z.ZodEnum<{
+            day: "day";
+            week: "week";
+            month: "month";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"deposit_plus_scheduled_instalments">;
+        depositAmountCents: z.ZodNumber;
+        depositRefundability: z.ZodEnum<{
+            refundable: "refundable";
+            non_refundable: "non_refundable";
+        }>;
+        instalmentCount: z.ZodNumber;
+        intervalCount: z.ZodNumber;
+        intervalUnit: z.ZodEnum<{
+            day: "day";
+            week: "week";
+            month: "month";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"equal_scheduled_instalments">;
+        instalmentCount: z.ZodNumber;
+        intervalCount: z.ZodNumber;
+        intervalUnit: z.ZodEnum<{
+            day: "day";
+            week: "week";
+            month: "month";
+        }>;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"flexible_balance">;
+    config: z.ZodObject<{
+        upfrontAmountCents: z.ZodNumber;
+        dueDateRule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"relative_to_start_date">;
+            daysBeforeStart: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"fixed_calendar_date">;
+            dueAt: z.ZodString;
+        }, z.core.$strip>], "kind">;
+        depositRefundability: z.ZodEnum<{
+            refundable: "refundable";
+            non_refundable: "non_refundable";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "kind">;
+export declare const bookingPaymentTermsSchema: z.ZodObject<{
+    allowedOptions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"upfront">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"deferred_manual">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"instalment_plan">;
+        plan: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"deposit_plus_one_remainder">;
+            depositAmountCents: z.ZodNumber;
+            depositRefundability: z.ZodEnum<{
+                refundable: "refundable";
+                non_refundable: "non_refundable";
+            }>;
+            remainderDueCount: z.ZodNumber;
+            intervalUnit: z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"deposit_plus_scheduled_instalments">;
+            depositAmountCents: z.ZodNumber;
+            depositRefundability: z.ZodEnum<{
+                refundable: "refundable";
+                non_refundable: "non_refundable";
+            }>;
+            instalmentCount: z.ZodNumber;
+            intervalCount: z.ZodNumber;
+            intervalUnit: z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"equal_scheduled_instalments">;
+            instalmentCount: z.ZodNumber;
+            intervalCount: z.ZodNumber;
+            intervalUnit: z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+            }>;
+        }, z.core.$strip>], "kind">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"flexible_balance">;
+        config: z.ZodObject<{
+            upfrontAmountCents: z.ZodNumber;
+            dueDateRule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"relative_to_start_date">;
+                daysBeforeStart: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"fixed_calendar_date">;
+                dueAt: z.ZodString;
+            }, z.core.$strip>], "kind">;
+            depositRefundability: z.ZodEnum<{
+                refundable: "refundable";
+                non_refundable: "non_refundable";
+            }>;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "kind">>;
+}, z.core.$strip>;
+export declare const bookingPaymentOptionsChoiceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    source: z.ZodLiteral<"default">;
+}, z.core.$strict>, z.ZodObject<{
+    source: z.ZodLiteral<"custom">;
+    paymentTerms: z.ZodObject<{
+        allowedOptions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"upfront">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"deferred_manual">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"instalment_plan">;
+            plan: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"deposit_plus_one_remainder">;
+                depositAmountCents: z.ZodNumber;
+                depositRefundability: z.ZodEnum<{
+                    refundable: "refundable";
+                    non_refundable: "non_refundable";
+                }>;
+                remainderDueCount: z.ZodNumber;
+                intervalUnit: z.ZodEnum<{
+                    day: "day";
+                    week: "week";
+                    month: "month";
+                }>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"deposit_plus_scheduled_instalments">;
+                depositAmountCents: z.ZodNumber;
+                depositRefundability: z.ZodEnum<{
+                    refundable: "refundable";
+                    non_refundable: "non_refundable";
+                }>;
+                instalmentCount: z.ZodNumber;
+                intervalCount: z.ZodNumber;
+                intervalUnit: z.ZodEnum<{
+                    day: "day";
+                    week: "week";
+                    month: "month";
+                }>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"equal_scheduled_instalments">;
+                instalmentCount: z.ZodNumber;
+                intervalCount: z.ZodNumber;
+                intervalUnit: z.ZodEnum<{
+                    day: "day";
+                    week: "week";
+                    month: "month";
+                }>;
+            }, z.core.$strip>], "kind">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"flexible_balance">;
+            config: z.ZodObject<{
+                upfrontAmountCents: z.ZodNumber;
+                dueDateRule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"relative_to_start_date">;
+                    daysBeforeStart: z.ZodNumber;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"fixed_calendar_date">;
+                    dueAt: z.ZodString;
+                }, z.core.$strip>], "kind">;
+                depositRefundability: z.ZodEnum<{
+                    refundable: "refundable";
+                    non_refundable: "non_refundable";
+                }>;
+            }, z.core.$strip>;
+        }, z.core.$strip>], "kind">>;
+    }, z.core.$strip>;
+}, z.core.$strict>], "source">;
+export {};