@leaflow/sdk 0.0.0-dev.357.gf8331d0 → 0.0.0-dev.359.gca6d1b5

package/dist/billing/type/order/v1/generated/validators/cancelSubscriptionRequest.zod.js

@@ -6,12 +6,12 @@
  * OpenAPI spec version: v1
  */
 import * as zod from "zod";
+import { CancellationPolicy } from "./cancellationPolicy.zod.js";
 import { Money } from "./money.zod.js";
-import { TerminationPolicy } from "./terminationPolicy.zod.js";
 export const cancelSubscriptionRequestExpectedRefundableAmountTwoRegExp = new RegExp("^[0-9]{1,15}([.][0-9]{1,10})?$");
 export const cancelSubscriptionRequestReasonMax = 1024;
 export const CancelSubscriptionRequest = zod.strictObject({
-    mode: TerminationPolicy,
+    mode: CancellationPolicy,
     proration_date: zod.iso
         .datetime({ offset: true })
         .optional()

package/dist/billing/type/order/v1/generated/validators/cancellation.zod.js

@@ -7,13 +7,13 @@
  */
 import * as zod from "zod";
 import { CancellationItem } from "./cancellationItem.zod.js";
+import { CancellationPolicy } from "./cancellationPolicy.zod.js";
 import { Money } from "./money.zod.js";
-import { TerminationPolicy } from "./terminationPolicy.zod.js";
 export const Cancellation = zod
     .strictObject({
     id: zod.uuid(),
     status: zod.enum(["requested", "scheduled", "releasing", "completed", "canceled", "failed"]),
-    mode: TerminationPolicy,
+    mode: CancellationPolicy,
     scheduled_at: zod.iso.datetime({ offset: true }).optional(),
     proration_date: zod.iso
         .datetime({ offset: true })

package/dist/billing/type/order/v1/generated/validators/cancellationCreate.zod.js

@@ -6,8 +6,8 @@
  * OpenAPI spec version: v1
  */
 import * as zod from "zod";
+import { CancellationPolicy } from "./cancellationPolicy.zod.js";
 import { Money } from "./money.zod.js";
-import { TerminationPolicy } from "./terminationPolicy.zod.js";
 export const cancellationCreateSubscriptionIdsMax = 50;
 export const cancellationCreateExpectedRefundableAmountTwoRegExp = new RegExp("^[0-9]{1,15}([.][0-9]{1,10})?$");
 export const cancellationCreateReasonMax = 1024;
@@ -17,7 +17,7 @@ export const CancellationCreate = zod.strictObject({
         .min(1)
         .max(cancellationCreateSubscriptionIdsMax)
         .describe("As in the quote."),
-    mode: TerminationPolicy,
+    mode: CancellationPolicy,
     proration_date: zod.iso
         .datetime({ offset: true })
         .optional()

package/dist/billing/type/order/v1/generated/validators/{terminationPolicy.zod.d.ts → cancellationPolicy.zod.d.ts}

@@ -6,9 +6,9 @@
  * OpenAPI spec version: v1
  */
 import * as zod from "zod";
-export declare const TerminationPolicy: zod.ZodEnum<{
+export declare const CancellationPolicy: zod.ZodEnum<{
     immediate: "immediate";
     period_end: "period_end";
 }>;
-export type TerminationPolicy = zod.input<typeof TerminationPolicy>;
-export type TerminationPolicyOutput = zod.output<typeof TerminationPolicy>;
+export type CancellationPolicy = zod.input<typeof CancellationPolicy>;
+export type CancellationPolicyOutput = zod.output<typeof CancellationPolicy>;

package/dist/billing/type/order/v1/generated/validators/{terminationPolicy.zod.js → cancellationPolicy.zod.js}

@@ -6,6 +6,6 @@
  * OpenAPI spec version: v1
  */
 import * as zod from "zod";
-export const TerminationPolicy = zod
+export const CancellationPolicy = zod
     .enum(["immediate", "period_end"])
-    .describe("Whether a delivered purchase may end immediately or only at the end of its paid term; refunds follow the refund policy. When absent, no termination terms were agreed.");
+    .describe("Whether a cancellation of a delivered purchase may take effect immediately or only at the end of its paid term; refunds follow the refund policy. When absent, no cancellation terms were agreed.");

package/dist/billing/type/order/v1/generated/validators/cancellationRefundPreview.zod.d.ts

@@ -15,6 +15,7 @@ export declare const CancellationRefundPreview: zod.ZodObject<{
     proration_date: zod.ZodOptional<zod.z.ZodISODateTime>;
     currency: zod.ZodString;
     unused_amount: zod.ZodString;
+    short_rate_surcharge_amount: zod.ZodString;
     refundable_amount: zod.ZodString;
     refund_amount: zod.ZodString;
     credit_amount: zod.ZodString;
@@ -38,6 +39,7 @@ export declare const CancellationRefundPreview: zod.ZodObject<{
         }>;
         auto_renew: zod.ZodBoolean;
         unused_amount: zod.ZodString;
+        short_rate_surcharge_amount: zod.ZodString;
         refundable_amount: zod.ZodString;
         refund_amount: zod.ZodString;
         credit_amount: zod.ZodString;

package/dist/billing/type/order/v1/generated/validators/cancellationRefundPreview.zod.js

@@ -6,12 +6,12 @@
  * OpenAPI spec version: v1
  */
 import * as zod from "zod";
+import { CancellationPolicy } from "./cancellationPolicy.zod.js";
 import { CancellationRefundPreviewItem } from "./cancellationRefundPreviewItem.zod.js";
 import { Money } from "./money.zod.js";
-import { TerminationPolicy } from "./terminationPolicy.zod.js";
 export const CancellationRefundPreview = zod
     .strictObject({
-    mode: TerminationPolicy,
+    mode: CancellationPolicy,
     scheduled_at: zod.iso
         .datetime({ offset: true })
         .optional()
@@ -22,6 +22,7 @@ export const CancellationRefundPreview = zod
         .describe("For `immediate`, the second the refund is computed as of. Give it when creating the cancellation."),
     currency: zod.string(),
     unused_amount: Money,
+    short_rate_surcharge_amount: Money,
     refundable_amount: Money,
     refund_amount: Money,
     credit_amount: Money,
@@ -29,4 +30,4 @@ export const CancellationRefundPreview = zod
     forfeited_amount: Money,
     items: zod.array(CancellationRefundPreviewItem),
 })
-    .describe("What the cancellation would return, per subscription and in total, as of now. Give `proration_date` and\n`refundable_amount` when creating the cancellation.\n\n- `unused_amount`: before tax, the amount paid for the current periods minus the value of the time used,\n  valued as refund policy `prorated` describes, whatever the refund terms say.\n- `refundable_amount`: what is returned the way it was paid, tax included; `refund_amount` plus\n  `credit_amount`.\n- `refund_amount`: the part returned to the balance or the payment method.\n- `credit_amount`: the part restored to the credit grants that paid.\n- `tax_amount`: the tax included in `refundable_amount`.\n- `forfeited_amount`: before tax, the part of `unused_amount` the refund terms do not return.\n\nMetered and one-time subscriptions show zero; their usage until release is charged as usual.");
+    .describe("What the cancellation would return, per subscription and in total, as of now. Give `proration_date` and\n`refundable_amount` when creating the cancellation.\n\n- `unused_amount`: before tax, the amount paid for the current periods in proportion to the time remaining.\n- `short_rate_surcharge_amount`: before tax, the part of `forfeited_amount` due to the short rate of the\n  refund policy.\n- `refundable_amount`: what is returned the way it was paid, tax included; `refund_amount` plus\n  `credit_amount`.\n- `refund_amount`: the part returned to the balance or the payment method.\n- `credit_amount`: the part restored to the credit grants that paid.\n- `tax_amount`: the tax included in `refundable_amount`.\n- `forfeited_amount`: before tax, the part of `unused_amount` the refund terms do not return.\n\nMetered and one-time subscriptions show zero; their usage until release is charged as usual.");

package/dist/billing/type/order/v1/generated/validators/cancellationRefundPreviewItem.zod.d.ts

@@ -24,6 +24,7 @@ export declare const CancellationRefundPreviewItem: zod.ZodObject<{
     }>;
     auto_renew: zod.ZodBoolean;
     unused_amount: zod.ZodString;
+    short_rate_surcharge_amount: zod.ZodString;
     refundable_amount: zod.ZodString;
     refund_amount: zod.ZodString;
     credit_amount: zod.ZodString;

package/dist/billing/type/order/v1/generated/validators/cancellationRefundPreviewItem.zod.js

@@ -25,6 +25,7 @@ export const CancellationRefundPreviewItem = zod
         .boolean()
         .describe("Whether automatic renewal is on now. Creating the cancellation turns it off; withdrawing it turns it back on for a metered subscription but not for a licensed one."),
     unused_amount: Money,
+    short_rate_surcharge_amount: Money,
     refundable_amount: Money,
     refund_amount: Money,
     credit_amount: Money,

package/dist/billing/type/order/v1/generated/validators/order.zod.d.ts

@@ -92,16 +92,18 @@ export declare const Order: zod.ZodObject<{
             year: "year";
         }>;
         interval_count: zod.ZodOptional<zod.ZodInt>;
-        termination_policy: zod.ZodOptional<zod.ZodEnum<{
+        cancellation_policy: zod.ZodOptional<zod.ZodEnum<{
             immediate: "immediate";
             period_end: "period_end";
         }>>;
         refund_policy: zod.ZodOptional<zod.ZodEnum<{
             none: "none";
             prorated: "prorated";
+            short_rate: "short_rate";
         }>>;
-        refund_monthly_amount: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
-        refund_hourly_amount: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+        monthly_list_amount: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+        short_rate_multiplier: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+        short_rate_threshold_seconds: zod.ZodOptional<zod.ZodNullable<zod.ZodInt>>;
         recurring_amount: zod.ZodOptional<zod.ZodString>;
         setup_amount: zod.ZodOptional<zod.ZodString>;
         type: zod.ZodEnum<{

package/dist/billing/type/order/v1/generated/validators/orderItem.zod.d.ts

@@ -20,16 +20,18 @@ export declare const OrderItem: zod.ZodObject<{
         year: "year";
     }>;
     interval_count: zod.ZodOptional<zod.ZodInt>;
-    termination_policy: zod.ZodOptional<zod.ZodEnum<{
+    cancellation_policy: zod.ZodOptional<zod.ZodEnum<{
         immediate: "immediate";
         period_end: "period_end";
     }>>;
     refund_policy: zod.ZodOptional<zod.ZodEnum<{
         none: "none";
         prorated: "prorated";
+        short_rate: "short_rate";
     }>>;
-    refund_monthly_amount: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
-    refund_hourly_amount: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    monthly_list_amount: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    short_rate_multiplier: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    short_rate_threshold_seconds: zod.ZodOptional<zod.ZodNullable<zod.ZodInt>>;
     recurring_amount: zod.ZodOptional<zod.ZodString>;
     setup_amount: zod.ZodOptional<zod.ZodString>;
     type: zod.ZodEnum<{

package/dist/billing/type/order/v1/generated/validators/orderItem.zod.js

@@ -6,13 +6,13 @@
  * OpenAPI spec version: v1
  */
 import * as zod from "zod";
+import { CancellationPolicy } from "./cancellationPolicy.zod.js";
 import { Money } from "./money.zod.js";
 import { OrderItemStatus } from "./orderItemStatus.zod.js";
 import { PriceType } from "./priceType.zod.js";
 import { Product } from "./product.zod.js";
 import { ProductID } from "./productID.zod.js";
 import { RefundPolicy } from "./refundPolicy.zod.js";
-import { TerminationPolicy } from "./terminationPolicy.zod.js";
 import { UsageType } from "./usageType.zod.js";
 export const orderItemPositionMin = 0;
 export const OrderItem = zod
@@ -33,16 +33,20 @@ export const OrderItem = zod
         .describe("The Billing subscription: the new pending subscription of a recurring purchase, or the existing one renewed or changed, which keeps its ID. Absent for a purchase without a subscription."),
     interval: zod.enum(["none", "day", "month", "year"]),
     interval_count: zod.int().min(1).optional(),
-    termination_policy: TerminationPolicy.optional(),
+    cancellation_policy: CancellationPolicy.optional(),
     refund_policy: RefundPolicy.optional(),
-    refund_monthly_amount: zod
+    monthly_list_amount: zod
         .string()
         .nullish()
-        .describe("Recurring licensed items only: the plan's one-month licensed price for this item's quantity, before tax and frozen at purchase, used to value time under a prorated refund or a downgrade. Null when the plan has no licensed period shorter than the one bought."),
-    refund_hourly_amount: zod
+        .describe("Recurring licensed items only: a month at list price for this item's quantity, before tax and discounts, which values time under a refund or a downgrade. It is the monthly amount of the shortest period the plan sells, not longer than the one bought, at the item's dimensions, fixed at purchase; a renewal at the agreed amount keeps the previous value. Null when time used is valued at the amount paid, as for a daily period."),
+    short_rate_multiplier: zod
         .string()
         .nullish()
-        .describe("Recurring licensed items only, the plan's metered hourly price for this item's quantity before tax, frozen at purchase, used for time used short of a full month. Null when the licensed price has no meter."),
+        .describe("Refund policy `short_rate` only, as on the price when bought."),
+    short_rate_threshold_seconds: zod
+        .int()
+        .nullish()
+        .describe("Refund policy `short_rate` only, as on the price when bought."),
     recurring_amount: zod.string().optional(),
     setup_amount: zod.string().optional(),
     type: PriceType,

package/dist/billing/type/order/v1/generated/validators/orderItemList.zod.d.ts

@@ -20,16 +20,18 @@ export declare const OrderItemList: zod.ZodObject<{
             year: "year";
         }>;
         interval_count: zod.ZodOptional<zod.ZodInt>;
-        termination_policy: zod.ZodOptional<zod.ZodEnum<{
+        cancellation_policy: zod.ZodOptional<zod.ZodEnum<{
             immediate: "immediate";
             period_end: "period_end";
         }>>;
         refund_policy: zod.ZodOptional<zod.ZodEnum<{
             none: "none";
             prorated: "prorated";
+            short_rate: "short_rate";
         }>>;
-        refund_monthly_amount: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
-        refund_hourly_amount: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+        monthly_list_amount: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+        short_rate_multiplier: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+        short_rate_threshold_seconds: zod.ZodOptional<zod.ZodNullable<zod.ZodInt>>;
         recurring_amount: zod.ZodOptional<zod.ZodString>;
         setup_amount: zod.ZodOptional<zod.ZodString>;
         type: zod.ZodEnum<{

package/dist/billing/type/order/v1/generated/validators/orderList.zod.d.ts

@@ -93,16 +93,18 @@ export declare const OrderList: zod.ZodObject<{
                 year: "year";
             }>;
             interval_count: zod.ZodOptional<zod.ZodInt>;
-            termination_policy: zod.ZodOptional<zod.ZodEnum<{
+            cancellation_policy: zod.ZodOptional<zod.ZodEnum<{
                 immediate: "immediate";
                 period_end: "period_end";
             }>>;
             refund_policy: zod.ZodOptional<zod.ZodEnum<{
                 none: "none";
                 prorated: "prorated";
+                short_rate: "short_rate";
             }>>;
-            refund_monthly_amount: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
-            refund_hourly_amount: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+            monthly_list_amount: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+            short_rate_multiplier: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+            short_rate_threshold_seconds: zod.ZodOptional<zod.ZodNullable<zod.ZodInt>>;
             recurring_amount: zod.ZodOptional<zod.ZodString>;
             setup_amount: zod.ZodOptional<zod.ZodString>;
             type: zod.ZodEnum<{

package/dist/billing/type/order/v1/generated/validators/orderRefundQuote.zod.js

@@ -15,4 +15,4 @@ export const OrderRefundQuote = zod
     credit_amount: Money,
     currency: zod.string(),
 })
-    .describe("An estimated refund to the original payment sources. Before acceptance, cancellation returns the collected amount. For delivered service, only value paid by this order is included; renewals are evaluated with their own orders under the agreed termination terms. Nothing is refunded by the quote; the amount is fixed when cancellation or termination is confirmed.");
+    .describe("An estimated refund to the original payment sources. Before acceptance, cancellation returns the collected amount. For delivered service, only value paid by this order is included; renewals are evaluated with their own orders under the agreed cancellation terms. Nothing is refunded by the quote; the amount is fixed when cancellation or termination is confirmed.");

package/dist/billing/type/order/v1/generated/validators/price.zod.d.ts

@@ -31,14 +31,17 @@ export declare const Price: zod.ZodObject<{
     }, zod.z.core.$strict>>;
     unit_quantity: zod.ZodString;
     active: zod.ZodBoolean;
-    termination_policy: zod.ZodOptional<zod.ZodEnum<{
+    cancellation_policy: zod.ZodOptional<zod.ZodEnum<{
         immediate: "immediate";
         period_end: "period_end";
     }>>;
     refund_policy: zod.ZodOptional<zod.ZodEnum<{
         none: "none";
         prorated: "prorated";
+        short_rate: "short_rate";
     }>>;
+    short_rate_multiplier: zod.ZodOptional<zod.ZodString>;
+    short_rate_threshold_seconds: zod.ZodOptional<zod.ZodInt>;
     product_id: zod.ZodOptional<zod.ZodString>;
     id: zod.ZodUUID;
     plan_id: zod.ZodUUID;

package/dist/billing/type/order/v1/generated/validators/price.zod.js

@@ -7,13 +7,13 @@
  */
 import * as zod from "zod";
 import { BillingScheme } from "./billingScheme.zod.js";
+import { CancellationPolicy } from "./cancellationPolicy.zod.js";
 import { Money } from "./money.zod.js";
 import { ObjectIdentity } from "./objectIdentity.zod.js";
 import { PriceType } from "./priceType.zod.js";
 import { Product } from "./product.zod.js";
 import { ProductID } from "./productID.zod.js";
 import { RefundPolicy } from "./refundPolicy.zod.js";
-import { TerminationPolicy } from "./terminationPolicy.zod.js";
 import { Tier } from "./tier.zod.js";
 import { UsageType } from "./usageType.zod.js";
 export const Price = zod.strictObject({
@@ -30,8 +30,16 @@ export const Price = zod.strictObject({
     active: zod
         .boolean()
         .describe("False once archived. An archived price cannot be bought until it is active again."),
-    termination_policy: TerminationPolicy.optional(),
+    cancellation_policy: CancellationPolicy.optional(),
     refund_policy: RefundPolicy.optional(),
+    short_rate_multiplier: zod
+        .string()
+        .optional()
+        .describe("Refund policy `short_rate` only, the factor applied to the value of the time used when a cancellation takes effect less than `short_rate_threshold_seconds` after the period start."),
+    short_rate_threshold_seconds: zod
+        .int()
+        .optional()
+        .describe("Refund policy `short_rate` only, how long after the period start `short_rate_multiplier` applies."),
     product_id: ProductID.optional(),
     id: zod.uuid(),
     plan_id: zod.uuid(),

package/dist/billing/type/order/v1/generated/validators/priceList.zod.d.ts

@@ -32,14 +32,17 @@ export declare const PriceList: zod.ZodObject<{
         }, zod.z.core.$strict>>;
         unit_quantity: zod.ZodString;
         active: zod.ZodBoolean;
-        termination_policy: zod.ZodOptional<zod.ZodEnum<{
+        cancellation_policy: zod.ZodOptional<zod.ZodEnum<{
             immediate: "immediate";
             period_end: "period_end";
         }>>;
         refund_policy: zod.ZodOptional<zod.ZodEnum<{
             none: "none";
             prorated: "prorated";
+            short_rate: "short_rate";
         }>>;
+        short_rate_multiplier: zod.ZodOptional<zod.ZodString>;
+        short_rate_threshold_seconds: zod.ZodOptional<zod.ZodInt>;
         product_id: zod.ZodOptional<zod.ZodString>;
         id: zod.ZodUUID;
         plan_id: zod.ZodUUID;

package/dist/billing/type/order/v1/generated/validators/quote.zod.d.ts

@@ -66,6 +66,7 @@ export declare const Quote: zod.ZodObject<{
         proration_date: zod.ZodOptional<zod.z.ZodISODateTime>;
         currency: zod.ZodString;
         unused_amount: zod.ZodString;
+        short_rate_surcharge_amount: zod.ZodString;
         refundable_amount: zod.ZodString;
         refund_amount: zod.ZodString;
         credit_amount: zod.ZodString;
@@ -89,6 +90,7 @@ export declare const Quote: zod.ZodObject<{
             }>;
             auto_renew: zod.ZodBoolean;
             unused_amount: zod.ZodString;
+            short_rate_surcharge_amount: zod.ZodString;
             refundable_amount: zod.ZodString;
             refund_amount: zod.ZodString;
             credit_amount: zod.ZodString;

package/dist/billing/type/order/v1/generated/validators/quoteCancellation.zod.js

@@ -6,7 +6,7 @@
  * OpenAPI spec version: v1
  */
 import * as zod from "zod";
-import { TerminationPolicy } from "./terminationPolicy.zod.js";
+import { CancellationPolicy } from "./cancellationPolicy.zod.js";
 export const quoteCancellationSubscriptionIdsMax = 50;
 export const QuoteCancellation = zod
     .strictObject({
@@ -15,6 +15,6 @@ export const QuoteCancellation = zod
         .min(1)
         .max(quoteCancellationSubscriptionIdsMax)
         .describe("The subscriptions to end together, all of one service, including every subscription released with a resource."),
-    mode: TerminationPolicy,
+    mode: CancellationPolicy,
 })
     .describe("A cancellation to quote: what ending these subscriptions together would return, for one mode; quote `immediate` and `period_end` separately to compare. Refused with 409 `BILLING_SUBSCRIPTION_OPERATION_PENDING` when a subscription is already being canceled (`meta.cancellation_id`), is being reclaimed (`meta.reason` `reclaim_requested`) or has a paid change waiting to switch (`meta.order_id`).");

package/dist/billing/type/order/v1/generated/validators/quoteItemInput.zod.d.ts

@@ -31,7 +31,7 @@ export declare const QuoteItemInput: zod.ZodObject<{
         year: "year";
     }>>;
     interval_count: zod.ZodOptional<zod.ZodInt>;
-    termination_policy: zod.ZodOptional<zod.ZodEnum<{
+    cancellation_policy: zod.ZodOptional<zod.ZodEnum<{
         immediate: "immediate";
         period_end: "period_end";
     }>>;

package/dist/billing/type/order/v1/generated/validators/quoteItemInput.zod.js

@@ -6,9 +6,9 @@
  * OpenAPI spec version: v1
  */
 import * as zod from "zod";
+import { CancellationPolicy } from "./cancellationPolicy.zod.js";
 import { PriceType } from "./priceType.zod.js";
 import { ProductID } from "./productID.zod.js";
-import { TerminationPolicy } from "./terminationPolicy.zod.js";
 import { UsageType } from "./usageType.zod.js";
 export const quoteItemInputPriceLookupKeyMax = 128;
 export const quoteItemInputPlanLookupKeyMax = 128;
@@ -25,7 +25,7 @@ export const QuoteItemInput = zod
     usage_type: UsageType.optional().describe("Narrows the selection when a plan offers more than one usage type."),
     interval: zod.enum(["none", "day", "month", "year"]).optional(),
     interval_count: zod.int().min(1).optional(),
-    termination_policy: TerminationPolicy.optional().describe("Selects among licensed prices with otherwise identical billing terms. Ambiguous terms are refused instead of choosing a price arbitrarily."),
+    cancellation_policy: CancellationPolicy.optional().describe("Selects among licensed prices with otherwise identical billing terms. Ambiguous terms are refused instead of choosing a price arbitrarily."),
     quantity: zod.string().regex(quoteItemInputQuantityRegExp),
     meter_id: zod.uuid().optional(),
     meter_lookup_key: zod.string().min(1).max(quoteItemInputMeterLookupKeyMax).optional(),

package/dist/billing/type/order/v1/generated/validators/quoteRenewal.zod.d.ts

@@ -17,7 +17,7 @@ export declare const QuoteRenewal: zod.ZodObject<{
         year: "year";
     }>>;
     interval_count: zod.ZodOptional<zod.ZodInt>;
-    termination_policy: zod.ZodOptional<zod.ZodEnum<{
+    cancellation_policy: zod.ZodOptional<zod.ZodEnum<{
         immediate: "immediate";
         period_end: "period_end";
     }>>;

package/dist/billing/type/order/v1/generated/validators/quoteRenewal.zod.js

@@ -6,7 +6,7 @@
  * OpenAPI spec version: v1
  */
 import * as zod from "zod";
-import { TerminationPolicy } from "./terminationPolicy.zod.js";
+import { CancellationPolicy } from "./cancellationPolicy.zod.js";
 export const quoteRenewalPeriodsDefault = 1;
 export const quoteRenewalPeriodsMax = 100;
 export const QuoteRenewal = zod
@@ -15,7 +15,7 @@ export const QuoteRenewal = zod
     price_id: zod.uuid().optional(),
     interval: zod.enum(["day", "month", "year"]).optional(),
     interval_count: zod.int().min(1).optional(),
-    termination_policy: TerminationPolicy.optional().describe("With `interval` and `interval_count`, chooses among prices of that term that differ in termination policy."),
+    cancellation_policy: CancellationPolicy.optional().describe("With `interval` and `interval_count`, chooses among prices of that term that differ in cancellation policy."),
     periods: zod
         .int()
         .min(1)
@@ -23,4 +23,4 @@ export const QuoteRenewal = zod
         .default(quoteRenewalPeriodsDefault)
         .describe("How many consecutive periods to renew for."),
 })
-    .describe("Price renewing a licensed subscription. Give `price_id`, or `interval` with\n`interval_count`, to renew for another term at the price currently sold for it. Naming\nthe current term, or giving neither, renews at the agreed amount. A term sold at several\nprices that differ in termination policy is refused with 409\n`BILLING_RENEWAL_OPTION_AMBIGUOUS` unless `termination_policy` or `price_id` is given.");
+    .describe("Price renewing a licensed subscription. Give `price_id`, or `interval` with\n`interval_count`, to renew for another term at the price currently sold for it. Naming\nthe current term, or giving neither, renews at the agreed amount. A term sold at several\nprices that differ in cancellation policy is refused with 409\n`BILLING_RENEWAL_OPTION_AMBIGUOUS` unless `cancellation_policy` or `price_id` is given.");

package/dist/billing/type/order/v1/generated/validators/quoteRequest.zod.d.ts

@@ -32,7 +32,7 @@ export declare const QuoteRequest: zod.ZodObject<{
             year: "year";
         }>>;
         interval_count: zod.ZodOptional<zod.ZodInt>;
-        termination_policy: zod.ZodOptional<zod.ZodEnum<{
+        cancellation_policy: zod.ZodOptional<zod.ZodEnum<{
             immediate: "immediate";
             period_end: "period_end";
         }>>;
@@ -52,7 +52,7 @@ export declare const QuoteRequest: zod.ZodObject<{
             year: "year";
         }>>;
         interval_count: zod.ZodOptional<zod.ZodInt>;
-        termination_policy: zod.ZodOptional<zod.ZodEnum<{
+        cancellation_policy: zod.ZodOptional<zod.ZodEnum<{
             immediate: "immediate";
             period_end: "period_end";
         }>>;

package/dist/billing/type/order/v1/generated/validators/refundPolicy.zod.d.ts

@@ -9,6 +9,7 @@ import * as zod from "zod";
 export declare const RefundPolicy: zod.ZodEnum<{
     none: "none";
     prorated: "prorated";
+    short_rate: "short_rate";
 }>;
 export type RefundPolicy = zod.input<typeof RefundPolicy>;
 export type RefundPolicyOutput = zod.output<typeof RefundPolicy>;

package/dist/billing/type/order/v1/generated/validators/refundPolicy.zod.js

@@ -7,5 +7,5 @@
  */
 import * as zod from "zod";
 export const RefundPolicy = zod
-    .enum(["none", "prorated"])
-    .describe("`none` refunds nothing. `prorated` refunds the amount paid for the current period minus the value of the time used, never below zero or above what remains unrefunded. Time used runs from the period start to the effective cancellation and is valued at prices frozen on the order item: each full calendar month at `refund_monthly_amount`, the rest at `refund_hourly_amount` or, without it, at the monthly price by the second. When the plan has no licensed period shorter than the one bought, time used is valued pro rata at the price paid. Discounts and setup fees are not refunded. Refunds return to the original payment sources, with tax refunded in proportion.");
+    .enum(["none", "prorated", "short_rate"])
+    .describe("`none` refunds nothing.\n\n`prorated` refunds the amount paid for the current period minus the value of the time used, never below zero\nor above what remains unrefunded. Time used runs from the period start to the effective cancellation, by the\nsecond. Each whole month from the period start is valued at the order item's `monthly_list_amount`, and the\nremainder at that amount in proportion to the length of the month it falls in; without `monthly_list_amount`,\ntime used is valued at the amount paid in proportion to the length of the period. A renewal starts a new\nperiod, and an immediate change starts one at the change. Discounts and setup fees are not refunded. Refunds\nreturn to the original payment sources, with tax refunded in proportion.\n\n`short_rate` refunds as `prorated`, except that when the cancellation takes effect less than\n`short_rate_threshold_seconds` after the period start, the value of the time used is multiplied by\n`short_rate_multiplier`, up to `monthly_list_amount` for each month begun or, without `monthly_list_amount`,\nup to the amount paid.");

package/dist/billing/type/order/v1/generated/validators/refundReason.zod.js

@@ -20,4 +20,4 @@ export const RefundReason = zod
     "payment_not_applied",
     "operator",
 ])
-    .describe("Why the refund was made. New codes may be added; treat an unknown code as unspecified.\n\n- `provisioning_failed`: the purchase could not be delivered.\n- `order_expired`: the order expired after part of it was paid.\n- `order_canceled`: the order was canceled after part of it was paid.\n- `change_canceled`: a scheduled change was withdrawn after part of it was paid.\n- `change_expired`: a scheduled change could not take effect in time.\n- `subscription_canceled`: the unused value of a canceled subscription, under its refund terms.\n- `future_period_canceled`: a renewal that had not started was withdrawn.\n- `downgrade_difference`: after a downgrade, the remaining paid value, valued as refund policy `prorated`\n  describes, minus the new configuration's cost for the remaining time at the change item's\n  `refund_monthly_amount` and `refund_hourly_amount`.\n- `usage_true_up`: usage priced over the whole month cost less than was charged.\n- `payment_not_applied`: a payment arrived after its invoice could no longer be paid.\n- `operator`: made by the platform operator.");
+    .describe("Why the refund was made. New codes may be added; treat an unknown code as unspecified.\n\n- `provisioning_failed`: the purchase could not be delivered.\n- `order_expired`: the order expired after part of it was paid.\n- `order_canceled`: the order was canceled after part of it was paid.\n- `change_canceled`: a scheduled change was withdrawn after part of it was paid.\n- `change_expired`: a scheduled change could not take effect in time.\n- `subscription_canceled`: the unused value of a canceled subscription, under its refund terms.\n- `future_period_canceled`: a renewal that had not started was withdrawn.\n- `downgrade_difference`: after a downgrade, the remaining paid value, valued under each paid period's refund\n  policy and as `prorated` where that policy is `none`, minus the new configuration's value for the remaining\n  time: each whole month at the change item's `monthly_list_amount` and the remainder in proportion to the\n  length of the month it falls in, or without `monthly_list_amount`, the new period price in proportion to the\n  remaining time.\n- `usage_true_up`: usage priced over the whole month cost less than was charged.\n- `payment_not_applied`: a payment arrived after its invoice could no longer be paid.\n- `operator`: made by the platform operator.");

package/dist/billing/type/order/v1/generated/validators/renewRequest.zod.d.ts

@@ -18,7 +18,7 @@ export declare const RenewRequest: zod.ZodObject<{
         month: "month";
         year: "year";
     }>>;
-    termination_policy: zod.ZodOptional<zod.ZodEnum<{
+    cancellation_policy: zod.ZodOptional<zod.ZodEnum<{
         immediate: "immediate";
         period_end: "period_end";
     }>>;

package/dist/billing/type/order/v1/generated/validators/renewRequest.zod.js

@@ -6,7 +6,7 @@
  * OpenAPI spec version: v1
  */
 import * as zod from "zod";
-import { TerminationPolicy } from "./terminationPolicy.zod.js";
+import { CancellationPolicy } from "./cancellationPolicy.zod.js";
 export const renewRequestPeriodsDefault = 1;
 export const renewRequestUseBalanceDefault = true;
 export const renewRequestUseCreditsDefault = true;
@@ -23,12 +23,12 @@ export const RenewRequest = zod.strictObject({
         .int()
         .min(1)
         .optional()
-        .describe("Renew for a term of this length instead, at the price currently sold for it. Give\n`interval` with it.\n\nLeaving both out renews at the price this item already bills at, which a later price\nchange does not affect. Naming a term that differs from the current one is a fresh\nchoice, so it is bought at today's price. Naming the current term changes nothing. A\nterm sold at several prices that differ in termination policy is refused with 409\n`BILLING_RENEWAL_OPTION_AMBIGUOUS` unless `termination_policy` is given.\n\nList the terms on offer with the renewal prices operation."),
+        .describe("Renew for a term of this length instead, at the price currently sold for it. Give\n`interval` with it.\n\nLeaving both out renews at the price this item already bills at, which a later price\nchange does not affect. Naming a term that differs from the current one is a fresh\nchoice, so it is bought at today's price. Naming the current term changes nothing. A\nterm sold at several prices that differ in cancellation policy is refused with 409\n`BILLING_RENEWAL_OPTION_AMBIGUOUS` unless `cancellation_policy` is given.\n\nList the terms on offer with the renewal prices operation."),
     interval: zod
         .enum(["day", "month", "year"])
         .optional()
         .describe("The unit interval_count counts in."),
-    termination_policy: TerminationPolicy.optional().describe("With `interval` and `interval_count`, chooses among prices of that term that differ in termination policy."),
+    cancellation_policy: CancellationPolicy.optional().describe("With `interval` and `interval_count`, chooses among prices of that term that differ in cancellation policy."),
     payment_method_id: zod.uuid().optional(),
     use_balance: zod
         .boolean()

package/dist/billing/type/order/v1/generated/validators/renewalOrderRequest.zod.d.ts

@@ -16,7 +16,7 @@ export declare const RenewalOrderRequest: zod.ZodObject<{
         month: "month";
         year: "year";
     }>>;
-    termination_policy: zod.ZodOptional<zod.ZodEnum<{
+    cancellation_policy: zod.ZodOptional<zod.ZodEnum<{
         immediate: "immediate";
         period_end: "period_end";
     }>>;

package/dist/billing/type/order/v1/generated/validators/renewalOrderRequest.zod.js

@@ -6,7 +6,7 @@
  * OpenAPI spec version: v1
  */
 import * as zod from "zod";
-import { TerminationPolicy } from "./terminationPolicy.zod.js";
+import { CancellationPolicy } from "./cancellationPolicy.zod.js";
 export const renewalOrderRequestPeriodsDefault = 1;
 export const RenewalOrderRequest = zod
     .strictObject({
@@ -20,6 +20,6 @@ export const RenewalOrderRequest = zod
         .describe("As in renewing."),
     interval_count: zod.int().min(1).optional().describe("As in renewing."),
     interval: zod.enum(["day", "month", "year"]).optional().describe("As in renewing."),
-    termination_policy: TerminationPolicy.optional().describe("As in renewing."),
+    cancellation_policy: CancellationPolicy.optional().describe("As in renewing."),
 })
     .describe("The renewal's periods and price, chosen as in renewing.");

package/dist/billing/type/order/v1/generated/validators/renewalPrice.zod.d.ts

@@ -7,14 +7,17 @@
  */
 import * as zod from "zod";
 export declare const RenewalPrice: zod.ZodObject<{
-    termination_policy: zod.ZodOptional<zod.ZodEnum<{
+    cancellation_policy: zod.ZodOptional<zod.ZodEnum<{
         immediate: "immediate";
         period_end: "period_end";
     }>>;
     refund_policy: zod.ZodOptional<zod.ZodEnum<{
         none: "none";
         prorated: "prorated";
+        short_rate: "short_rate";
     }>>;
+    short_rate_multiplier: zod.ZodOptional<zod.ZodString>;
+    short_rate_threshold_seconds: zod.ZodOptional<zod.ZodInt>;
     price_id: zod.ZodUUID;
     interval_count: zod.ZodInt;
     interval: zod.ZodEnum<{

package/dist/billing/type/order/v1/generated/validators/renewalPrice.zod.js

@@ -6,12 +6,14 @@
  * OpenAPI spec version: v1
  */
 import * as zod from "zod";
+import { CancellationPolicy } from "./cancellationPolicy.zod.js";
 import { Money } from "./money.zod.js";
 import { RefundPolicy } from "./refundPolicy.zod.js";
-import { TerminationPolicy } from "./terminationPolicy.zod.js";
 export const RenewalPrice = zod.strictObject({
-    termination_policy: TerminationPolicy.optional(),
+    cancellation_policy: CancellationPolicy.optional(),
     refund_policy: RefundPolicy.optional(),
+    short_rate_multiplier: zod.string().optional().describe("Refund policy `short_rate` only."),
+    short_rate_threshold_seconds: zod.int().optional().describe("Refund policy `short_rate` only."),
     price_id: zod.uuid(),
     interval_count: zod.int().describe("How many periods one renewal covers."),
     interval: zod.enum(["day", "month", "year"]),