@riverbankcms/sdk 0.148.0 → 0.150.0

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 {};

package/dist/_dts/core/src/branded.d.ts

@@ -80,6 +80,7 @@ export type MembershipId = Brand<string, 'MembershipId'>;
 export type RetiredCourseId = Brand<string, 'RetiredCourseId'>;
 export type CustomerId = Brand<string, 'CustomerId'>;
 export type OrderId = Brand<string, 'OrderId'>;
+export type OrderRetirementOperationId = Brand<string, 'OrderRetirementOperationId'>;
 export type OrderItemId = Brand<string, 'OrderItemId'>;
 export type OrderRefundId = Brand<string, 'OrderRefundId'>;
 export type OrderPaymentReceiptId = Brand<string, 'OrderPaymentReceiptId'>;
@@ -228,6 +229,7 @@ export declare const unsafeAsFormSubmissionId: (id: string) => FormSubmissionId;
 export declare const unsafeAsPassId: (id: string) => PassId;
 export declare const unsafeAsMembershipId: (id: string) => MembershipId;
 export declare const unsafeAsCustomerId: (id: string) => CustomerId;
+export declare const unsafeAsOrderRetirementOperationId: (id: string) => OrderRetirementOperationId;
 export declare const unsafeAsOrderId: (id: string) => OrderId;
 export declare const unsafeAsOrderItemId: (id: string) => OrderItemId;
 export declare const unsafeAsOrderRefundId: (id: string) => OrderRefundId;
@@ -338,6 +340,7 @@ export declare const parseEventSeriesRegistrationId: (value: unknown) => Result<
 export declare const parseParticipantId: (value: unknown) => Result<ParticipantId, BrandedIdParseError>;
 export declare const parseParticipantParticipationId: (value: unknown) => Result<ParticipantParticipationId, BrandedIdParseError>;
 export declare const parseOrderItemId: (value: unknown) => Result<OrderItemId, BrandedIdParseError>;
+export declare const parseOrderRetirementOperationId: (value: unknown) => Result<OrderRetirementOperationId, BrandedIdParseError>;
 export declare const parseOrderId: (value: unknown) => Result<OrderId, BrandedIdParseError>;
 export declare const parseOrderRefundId: (value: unknown) => Result<OrderRefundId, BrandedIdParseError>;
 export declare const parseOrderPaymentReceiptId: (value: unknown) => Result<OrderPaymentReceiptId, BrandedIdParseError>;

package/dist/_dts/core/src/edit-lease.d.ts

@@ -1,4 +1,9 @@
 import type { ContentEntryId, EditLeaseToken, EditorClientId, PageId, PageSurfaceId } from './branded';
+/**
+ * How long a lease lasts without a heartbeat. The server grants for this long, and a
+ * reload handover is only worth presenting within it (issue 1570).
+ */
+export declare const EDIT_LEASE_TTL_SECONDS = 60;
 export type EditLeaseScope = Readonly<{
     nodeType: 'page';
     nodeId: PageId;

package/dist/_dts/core/src/index.d.ts

@@ -18,6 +18,9 @@ export * from './money-input';
 export * from './booking-flexible-balance';
 export * from './booking-refunds';
 export * from './booking-instalments';
+export * from './booking-instalment-deposit';
+export * from './booking-live-payment-terms';
+export * from './booking-payment-options';
 export * from './booking-date-time';
 export * from './booking-consent';
 export * from './appointment-service-categories';
@@ -82,3 +85,4 @@ export * from './navigation-locations';
 export * from './navigation-portal-labels';
 export * from './event-preset-vocabulary';
 export * from './event-catalogue';
+export * from './patch';

package/dist/_dts/core/src/patch/index.d.ts

@@ -0,0 +1,30 @@
+import type { Result } from '../result';
+export type Settable<T> = Readonly<{
+    kind: 'keep';
+}> | Readonly<{
+    kind: 'set';
+    value: T;
+}>;
+export type Clearable<T> = Settable<T> | Readonly<{
+    kind: 'clear';
+}>;
+/** Lists and documents use Settable too: a supplied value replaces the whole value. */
+export type ChangesWire<T extends Readonly<Record<string, Settable<unknown> | Clearable<unknown>>>> = {
+    readonly [K in keyof T]?: Extract<T[K], {
+        kind: 'set';
+    }>['value'] | (Extract<T[K], {
+        kind: 'clear';
+    }> extends never ? never : null);
+};
+export declare function settableFrom<T>(wireValue: T | undefined): Settable<T>;
+export declare function clearableFrom<T>(wireValue: T | null | undefined): Clearable<T>;
+export declare function applySettable<T>(stored: T, change: Settable<T>): T;
+export declare function applyClearable<T>(stored: T | null, change: Clearable<T>): T | null;
+export type ProtectedBagKeys<K extends string> = Readonly<{
+    kind: 'protected-keys';
+    keys: readonly K[];
+}>;
+/** A null deletes a key; protected keys are refused even when their value agrees. */
+export declare function mergeBag<T, K extends string>(stored: Readonly<Record<string, T>>, patch: Readonly<Record<string, T | null | undefined>>, options: Readonly<{
+    protectedKeys: readonly K[];
+}>): Readonly<Result<Readonly<Record<string, T>>, ProtectedBagKeys<K>>>;