@leaflow/sdk 0.0.0-dev.352.g85966ed → 0.0.0-dev.355.g42152f5

package/dist/billing/type/order/v1/generated/models.js

@@ -3,7 +3,6 @@ export const InvoiceStatus = {
     open: "open",
     paid: "paid",
     void: "void",
-    uncollectible: "uncollectible",
 };
 export const WithdrawalItemStatus = {
     pending: "pending",
@@ -41,10 +40,13 @@ export const QuotedDiscountType = {
     promotion_code: "promotion_code",
     account_discount: "account_discount",
 };
-export const CancellationRefundPreviewItemChargeType = {
-    postpaid: "postpaid",
-    prepaid: "prepaid",
+export const PriceType = {
     one_time: "one_time",
+    recurring: "recurring",
+};
+export const UsageType = {
+    licensed: "licensed",
+    metered: "metered",
 };
 export const CancellationStatus = {
     requested: "requested",
@@ -59,11 +61,6 @@ export const CancellationOrigin = {
     operator: "operator",
     project_deletion: "project_deletion",
 };
-export const CancellationItemChargeType = {
-    postpaid: "postpaid",
-    prepaid: "prepaid",
-    one_time: "one_time",
-};
 export const CancellationItemStatus = {
     requested: "requested",
     scheduled: "scheduled",
@@ -89,15 +86,9 @@ export const BillingAccountStatus = {
     suspended: "suspended",
     closed: "closed",
 };
-export const PriceOptionBillingScheme = {
+export const BillingScheme = {
     per_unit: "per_unit",
     tiered: "tiered",
-    rated: "rated",
-};
-export const PriceOptionType = {
-    postpaid: "postpaid",
-    prepaid: "prepaid",
-    one_time: "one_time",
 };
 export const PriceOptionInterval = {
     none: "none",
@@ -209,11 +200,6 @@ export const RefundReason = {
     payment_not_applied: "payment_not_applied",
     operator: "operator",
 };
-export const SubscriptionChargeType = {
-    postpaid: "postpaid",
-    prepaid: "prepaid",
-    one_time: "one_time",
-};
 export const SubscriptionInterval = {
     none: "none",
     day: "day",
@@ -285,11 +271,6 @@ export const OrderItemInterval = {
     month: "month",
     year: "year",
 };
-export const OrderItemChargeType = {
-    postpaid: "postpaid",
-    prepaid: "prepaid",
-    one_time: "one_time",
-};
 export const DiscountStatus = {
     scheduled: "scheduled",
     active: "active",
@@ -323,16 +304,6 @@ export const FeatureGrantStatus = {
     expired: "expired",
     voided: "voided",
 };
-export const PriceType = {
-    postpaid: "postpaid",
-    prepaid: "prepaid",
-    one_time: "one_time",
-};
-export const PriceBillingScheme = {
-    per_unit: "per_unit",
-    tiered: "tiered",
-    rated: "rated",
-};
 export const PriceTiersMode = {
     none: "none",
     graduated: "graduated",
@@ -344,20 +315,17 @@ export const PriceInterval = {
     month: "month",
     year: "year",
 };
-export const RateBillingScheme = {
-    per_unit: "per_unit",
-    tiered: "tiered",
+export const RateInterval = {
+    none: "none",
+    day: "day",
+    month: "month",
+    year: "year",
 };
 export const RateTiersMode = {
     none: "none",
     graduated: "graduated",
     volume: "volume",
 };
-export const QuoteItemInputPriceType = {
-    postpaid: "postpaid",
-    prepaid: "prepaid",
-    one_time: "one_time",
-};
 export const QuoteItemInputInterval = {
     none: "none",
     day: "day",

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

@@ -38,18 +38,20 @@ export declare const AccountBalance: zod.ZodObject<{
                     id: zod.ZodUUID;
                     name: zod.ZodString;
                 }, zod.z.core.$strict>;
-                billing_scheme: zod.ZodEnum<{
+                billing_scheme: zod.ZodOptional<zod.ZodEnum<{
                     per_unit: "per_unit";
                     tiered: "tiered";
-                    rated: "rated";
-                }>;
+                }>>;
                 unit_quantity: zod.ZodString;
                 id: zod.ZodUUID;
                 currency: zod.ZodString;
                 type: zod.ZodEnum<{
-                    postpaid: "postpaid";
-                    prepaid: "prepaid";
                     one_time: "one_time";
+                    recurring: "recurring";
+                }>;
+                usage_type: zod.ZodEnum<{
+                    licensed: "licensed";
+                    metered: "metered";
                 }>;
                 interval: zod.ZodEnum<{
                     none: "none";
@@ -61,7 +63,14 @@ export declare const AccountBalance: zod.ZodObject<{
                 unit_amount: zod.ZodOptional<zod.ZodString>;
                 active: zod.ZodBoolean;
             }, zod.z.core.$strict>>>;
-            price_types: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+            price_types: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
+                one_time: "one_time";
+                recurring: "recurring";
+            }>>>;
+            usage_types: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
+                licensed: "licensed";
+                metered: "metered";
+            }>>>;
             operations: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
                 new: "new";
                 renew: "renew";
@@ -90,18 +99,20 @@ export declare const AccountBalance: zod.ZodObject<{
                     id: zod.ZodUUID;
                     name: zod.ZodString;
                 }, zod.z.core.$strict>;
-                billing_scheme: zod.ZodEnum<{
+                billing_scheme: zod.ZodOptional<zod.ZodEnum<{
                     per_unit: "per_unit";
                     tiered: "tiered";
-                    rated: "rated";
-                }>;
+                }>>;
                 unit_quantity: zod.ZodString;
                 id: zod.ZodUUID;
                 currency: zod.ZodString;
                 type: zod.ZodEnum<{
-                    postpaid: "postpaid";
-                    prepaid: "prepaid";
                     one_time: "one_time";
+                    recurring: "recurring";
+                }>;
+                usage_type: zod.ZodEnum<{
+                    licensed: "licensed";
+                    metered: "metered";
                 }>;
                 interval: zod.ZodEnum<{
                     none: "none";

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

@@ -11,17 +11,17 @@ import { Money } from "./money.zod.js";
 export const AccountBalance = zod
     .strictObject({
     available_credit: Money.describe("Balance minus pending balance returns and the part of unbilled_amount and due that estimated_credit_applied does not cover. Negative only when the balance and applicable credit fall short of what the account owes."),
-    estimated_credit_applied: Money.describe("Credit expected to pay unbilled_amount and due. Each charge is matched to grants whose scope, validity and conditions it meets, in the order credit is applied at payment. Nothing is reserved or deducted until an invoice is paid, so credits still includes this amount."),
-    unbilled_amount: Money.describe("Current estimate of rated usage that has not been invoiced. Final pricing and tax are fixed at issuance."),
+    estimated_credit_applied: Money.describe("Credit expected to pay unbilled_amount and due, matching each charge to the grants whose scope, validity and conditions it meets, in the order credit is applied at payment. Nothing is deducted until an invoice is paid, so credits still includes this amount."),
+    unbilled_amount: Money.describe("Current estimate of priced usage that has not been invoiced. Final pricing and tax are fixed at issuance."),
     billing_account_id: zod.int(),
     currency: zod.string(),
-    balance: Money.describe("Prepaid funds in the account currency, excluding credits. May be negative after a payment\ndispute. Outstanding charges are reported separately in due; this value is not a withdrawal quote."),
-    credits: Money.describe("The recorded remaining credit, including restricted grants. It is not withdrawable\nand is not part of balance. credit_groups describes currently valid credit by permitted use; a positive\ncredits balance does not imply that due is zero."),
-    restricted_credits: Money.describe("Currently valid credit whose use has applicable product, operation or eligibility conditions. Included in credits, separate from the balance."),
+    balance: Money.describe("Topped-up funds in the account's currency, excluding credits. May be negative after a payment dispute. Amounts owed are reported in due; this is not a withdrawable amount."),
+    credits: Money.describe("Remaining credit, including restricted grants; not withdrawable and not part of balance. credit_groups shows currently valid credit by permitted use; positive credits do not mean due is zero."),
+    restricted_credits: Money.describe("Currently valid credit restricted to certain products, operations or conditions; part of credits, not of balance."),
     credit_groups: zod
         .array(CreditGroup)
-        .describe("Currently valid, unspent credit grouped by permitted use. Restrictions and\nvalidity dates determine which charges a group can cover, so these groups are not a general\nspendable balance and may differ from the recorded credits total."),
-    due: Money.describe("Amount still payable on issued invoices. The invoice of an order not yet accepted is a request to pay for that order rather than a debt, so it is excluded here and from available_credit. Unbilled usage is reported separately; arrears depend on actual eligible funding and grace terms."),
+        .describe("Currently valid unspent credit grouped by permitted use. Each group covers only the charges its restrictions and validity allow, and the groups may differ from the recorded credits total."),
+    due: Money.describe("Amount still payable on issued invoices. The invoice of an order not yet accepted is excluded, here and from available_credit. Usage not yet invoiced is reported separately."),
     pending_returns_amount: Money,
 })
-    .describe("Account balance, credits, and unpaid charges are reported separately.");
+    .describe("Balance, credits and unpaid charges, each reported separately.");

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

@@ -16,21 +16,24 @@ export const ActiveResource = zod
     state_changed_at: zod.iso.datetime({ offset: true }).optional(),
     subscription_id: zod
         .uuid()
-        .describe("The postpaid subscription charged for this metering record, including shared services."),
+        .describe("The metered subscription charged for this metering record."),
     resource_id: zod.string(),
     product: Product,
-    resource_type: zod.string().optional().describe("What it is, as its own service names it."),
+    resource_type: zod
+        .string()
+        .optional()
+        .describe("The resource type, as the owning service names it."),
     meter: ObjectIdentity,
     unit: zod.string().optional(),
     quantity: zod
         .string()
-        .describe("How much is held — cores, MiB, cards. Not how much has been used."),
+        .describe("How much is held, such as cores, MiB or cards; not how much was used."),
     dimensions: zod.record(zod.string(), zod.string()).optional(),
     status: zod.enum(["active", "suspended", "closing", "closed"]),
     started_at: zod.iso.datetime({ offset: true }),
     project_id: zod.uuid().optional(),
     usage_generated_until: zod.iso
         .datetime({ offset: true })
-        .describe("Usage has been generated up to this boundary; it does not imply invoicing or payment."),
+        .describe("Usage has been generated up to this boundary; it says nothing about invoicing or payment."),
 })
-    .describe("A resource currently accruing charges by the second.");
+    .describe("A resource charged continuously by the second.");

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

@@ -21,7 +21,7 @@ export const Allowance = zod.strictObject({
     unit: zod.string().optional().describe("The unit it is counted in, such as `MiB`."),
     category: zod
         .enum(["paid", "promotional"])
-        .describe("Whether the quantity was paid for or granted free of charge. Both are consumed the same way."),
+        .describe("Whether the quantity was paid for or granted free; both are consumed the same way."),
     dimensions: zod
         .record(zod.string(), zod.string())
         .describe("Exact values for a subset of the meter's dimensions. Only usage with these values is deducted;\nomitted dimensions are not restricted."),
@@ -31,11 +31,11 @@ export const Allowance = zod.strictObject({
     priority: zod
         .int()
         .optional()
-        .describe("Lower values are consumed first. At equal priority, earlier expiry and then earlier issuance take\nprecedence."),
+        .describe("Lower values are consumed first; at equal priority, earlier expiry and then earlier issuance."),
     status: zod.enum(["active", "depleted", "expired", "voided"]),
     valid_from: zod.iso.datetime({ offset: true }),
     valid_until: zod.iso
         .datetime({ offset: true })
         .nullish()
-        .describe("When it lapses. Anything unused at that point is lost; it is not refunded and does\nnot carry over. Absent when it does not expire on its own."),
+        .describe("When the allowance lapses; unused quantity is lost. Absent when it does not expire."),
 });

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

@@ -28,18 +28,20 @@ export declare const Applicability: zod.ZodObject<{
             id: zod.ZodUUID;
             name: zod.ZodString;
         }, zod.z.core.$strict>;
-        billing_scheme: zod.ZodEnum<{
+        billing_scheme: zod.ZodOptional<zod.ZodEnum<{
             per_unit: "per_unit";
             tiered: "tiered";
-            rated: "rated";
-        }>;
+        }>>;
         unit_quantity: zod.ZodString;
         id: zod.ZodUUID;
         currency: zod.ZodString;
         type: zod.ZodEnum<{
-            postpaid: "postpaid";
-            prepaid: "prepaid";
             one_time: "one_time";
+            recurring: "recurring";
+        }>;
+        usage_type: zod.ZodEnum<{
+            licensed: "licensed";
+            metered: "metered";
         }>;
         interval: zod.ZodEnum<{
             none: "none";
@@ -51,7 +53,14 @@ export declare const Applicability: zod.ZodObject<{
         unit_amount: zod.ZodOptional<zod.ZodString>;
         active: zod.ZodBoolean;
     }, zod.z.core.$strict>>>;
-    price_types: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+    price_types: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
+        one_time: "one_time";
+        recurring: "recurring";
+    }>>>;
+    usage_types: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
+        licensed: "licensed";
+        metered: "metered";
+    }>>>;
     operations: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
         new: "new";
         renew: "renew";
@@ -80,18 +89,20 @@ export declare const Applicability: zod.ZodObject<{
             id: zod.ZodUUID;
             name: zod.ZodString;
         }, zod.z.core.$strict>;
-        billing_scheme: zod.ZodEnum<{
+        billing_scheme: zod.ZodOptional<zod.ZodEnum<{
             per_unit: "per_unit";
             tiered: "tiered";
-            rated: "rated";
-        }>;
+        }>>;
         unit_quantity: zod.ZodString;
         id: zod.ZodUUID;
         currency: zod.ZodString;
         type: zod.ZodEnum<{
-            postpaid: "postpaid";
-            prepaid: "prepaid";
             one_time: "one_time";
+            recurring: "recurring";
+        }>;
+        usage_type: zod.ZodEnum<{
+            licensed: "licensed";
+            metered: "metered";
         }>;
         interval: zod.ZodEnum<{
             none: "none";

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

@@ -8,19 +8,28 @@
 import * as zod from "zod";
 import { ApplicablePlan } from "./applicablePlan.zod.js";
 import { PriceOption } from "./priceOption.zod.js";
+import { PriceType } from "./priceType.zod.js";
 import { Product } from "./product.zod.js";
 import { PurchaseOperation } from "./purchaseOperation.zod.js";
+import { UsageType } from "./usageType.zod.js";
 export const Applicability = zod
     .strictObject({
     products: zod.array(Product).optional(),
     plans: zod.array(ApplicablePlan).optional(),
     prices: zod.array(PriceOption).optional(),
-    price_types: zod.array(zod.string()).optional(),
+    price_types: zod
+        .array(PriceType)
+        .optional()
+        .describe("The price types covered; empty covers both."),
+    usage_types: zod
+        .array(UsageType)
+        .optional()
+        .describe("The usage types covered; empty covers both."),
     operations: zod.array(PurchaseOperation).optional(),
     min_term_months: zod
         .int()
         .optional()
-        .describe("The shortest term a purchase may have, in months. A purchase with no term, such as\nmetered usage, never qualifies while this is set."),
+        .describe("The shortest term a purchase may have, in months. Purchases without a term, such as metered usage, do not qualify while this is set."),
     max_term_months: zod
         .int()
         .optional()
@@ -29,4 +38,4 @@ export const Applicability = zod
     excluded_plans: zod.array(ApplicablePlan).optional(),
     excluded_prices: zod.array(PriceOption).optional(),
 })
-    .describe("Anything not excluded that matches an inclusion, or anything not excluded when no inclusion is\ngiven, subject to the charge type, operation and term conditions. Entries always include their\ndisplay fields; archived plans and prices stay listed with active set to false.");
+    .describe("Covers anything not excluded that matches an inclusion, or anything not excluded when no inclusion is given, subject to the price type, usage type, operation and term conditions. Archived plans and prices stay listed with active false.");

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

@@ -12,4 +12,4 @@ export const ApplicablePlan = zod
     name: zod.string(),
     active: zod.boolean(),
 })
-    .describe("A plan it refers to. active is false once the plan is archived; it still applies to subscriptions already on this plan.");
+    .describe("A plan referenced by an applicability; active is false once it is archived, and the reference still applies.");

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

@@ -10,22 +10,22 @@ export const BillingAccount = zod.strictObject({
     invoice_contact_id: zod
         .uuid()
         .nullish()
-        .describe("The active contact used for invoicing. Must belong to this account; null clears the selection."),
+        .describe("The active contact used for invoices, of this account; null clears it."),
     id: zod.int(),
-    name: zod.string().optional().describe("What you call this account."),
+    name: zod.string().optional().describe("Your name for the account."),
     currency: zod.string().describe("Fixed when the account was opened."),
     status: zod.enum(["active", "suspended", "closed"]),
     grace_amount: zod
         .string()
         .optional()
-        .describe('How far past the suspension threshold this account may go before its resources are\nsuspended. "0" means none: the account is suspended as soon as it crosses the threshold.'),
+        .describe("How far past the suspension threshold the account may go before its resources are suspended; `0` means none."),
     grace_period_seconds: zod
         .int()
         .optional()
-        .describe("How long this account has to top up after crossing the suspension threshold.\n0 means none. Whichever runs out first — this or grace_amount — ends the grace."),
+        .describe("How long the account has to top up after crossing the suspension threshold, in seconds; `0` means none. Grace ends when this or grace_amount runs out."),
     closed_at: zod.iso
         .datetime({ offset: true })
         .nullish()
-        .describe("The actual time this account was closed, in UTC (RFC 3339).\nNull or absent if the account is not closed or its historical close time is unknown."),
+        .describe("When the account was closed. Null if it is not closed or the time is unknown."),
     created_at: zod.iso.datetime({ offset: true }),
 });

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

@@ -11,6 +11,6 @@ export const BillingAccountUpdate = zod.strictObject({
     invoice_contact_id: zod
         .uuid()
         .nullish()
-        .describe("The active contact used for invoicing. Must belong to this account; null clears the selection."),
+        .describe("The active contact used for invoices, of this account; null clears it."),
     name: zod.string().max(billingAccountUpdateNameMax).optional(),
 });

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

@@ -0,0 +1,14 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Billing Order Types
+ * The Billing order a product purchase placed. Types only; this document declares no operations.
+ * OpenAPI spec version: v1
+ */
+import * as zod from "zod";
+export declare const BillingScheme: zod.ZodEnum<{
+    per_unit: "per_unit";
+    tiered: "tiered";
+}>;
+export type BillingScheme = zod.input<typeof BillingScheme>;
+export type BillingSchemeOutput = zod.output<typeof BillingScheme>;

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

@@ -0,0 +1,11 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Billing Order Types
+ * The Billing order a product purchase placed. Types only; this document declares no operations.
+ * OpenAPI spec version: v1
+ */
+import * as zod from "zod";
+export const BillingScheme = zod
+    .enum(["per_unit", "tiered"])
+    .describe("`per_unit` multiplies a unit amount; `tiered` walks a ladder.");

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

@@ -39,10 +39,13 @@ export declare const Cancellation: zod.ZodObject<{
         subscription_id: zod.ZodUUID;
         plan_id: zod.ZodUUID;
         plan_name: zod.ZodString;
-        charge_type: zod.ZodEnum<{
-            postpaid: "postpaid";
-            prepaid: "prepaid";
+        type: zod.ZodEnum<{
             one_time: "one_time";
+            recurring: "recurring";
+        }>;
+        usage_type: zod.ZodEnum<{
+            licensed: "licensed";
+            metered: "metered";
         }>;
         status: zod.ZodEnum<{
             completed: "completed";

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

@@ -21,16 +21,16 @@ export const Cancellation = zod
         .describe("For `immediate`, the second the refund is computed as of."),
     origin: zod
         .enum(["customer", "operator", "project_deletion"])
-        .describe("Who asked for it. `project_deletion` means the project was deleted."),
+        .describe("Who requested it; `project_deletion` means the project was deleted."),
     billing_account_id: zod
         .int()
-        .describe("The billing account that paid for these subscriptions when the cancellation was created: the\naccount of an account-level purchase, or the account the project was linked to."),
+        .describe("The billing account paying for these subscriptions when the cancellation was created: the purchasing account of an account-level purchase, or the project's linked account."),
     currency: zod.string(),
-    expected_refundable_amount: Money.optional().describe("The refund confirmed when it was created. Absent when the platform created it."),
+    expected_refundable_amount: Money.optional().describe("The refund confirmed when the cancellation was created. Absent when the platform created it."),
     failure_code: zod
         .string()
         .optional()
-        .describe("Present with `failed`. A code of the service that provides the resources, such as a disk\nthat can only be released with its server. Clients map it to their own wording."),
+        .describe("Present with `failed`: the owning service's code, such as for a disk that can only be released with its server."),
     requested_at: zod.iso.datetime({ offset: true }),
     completed_at: zod.iso.datetime({ offset: true }).optional(),
     canceled_at: zod.iso.datetime({ offset: true }).optional(),

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

@@ -21,11 +21,11 @@ export const CancellationCreate = zod.strictObject({
     proration_date: zod.iso
         .datetime({ offset: true })
         .optional()
-        .describe("For `immediate`, the `proration_date` of the quote: a whole second, not in the future and\nat most ten minutes old. The refund is computed as of it. Now when omitted."),
-    expected_refundable_amount: Money.and(zod.string().regex(cancellationCreateExpectedRefundableAmountTwoRegExp)).describe("The `refundable_amount` of the quote. The cancellation is refused when the refund differs."),
+        .describe("For `immediate`, the quote's `proration_date`: a whole second, not in the future and at most ten minutes old; the refund is computed as of it. Now when omitted."),
+    expected_refundable_amount: Money.and(zod.string().regex(cancellationCreateExpectedRefundableAmountTwoRegExp)).describe("The quote's `refundable_amount`; the cancellation is refused when the refund differs."),
     reason: zod
         .string()
         .max(cancellationCreateReasonMax)
         .optional()
-        .describe("A note from the account holder. It is kept with the cancellation and not shown elsewhere."),
+        .describe("A note from the account holder, kept with the cancellation."),
 });

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

@@ -11,10 +11,13 @@ export declare const CancellationItem: zod.ZodObject<{
     subscription_id: zod.ZodUUID;
     plan_id: zod.ZodUUID;
     plan_name: zod.ZodString;
-    charge_type: zod.ZodEnum<{
-        postpaid: "postpaid";
-        prepaid: "prepaid";
+    type: zod.ZodEnum<{
         one_time: "one_time";
+        recurring: "recurring";
+    }>;
+    usage_type: zod.ZodEnum<{
+        licensed: "licensed";
+        metered: "metered";
     }>;
     status: zod.ZodEnum<{
         completed: "completed";

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

@@ -7,22 +7,23 @@
  */
 import * as zod from "zod";
 import { Money } from "./money.zod.js";
+import { PriceType } from "./priceType.zod.js";
+import { UsageType } from "./usageType.zod.js";
 export const CancellationItem = zod
     .strictObject({
     id: zod
         .uuid()
-        .describe("The cancellation item of this subscription, the same as `Subscription.cancellation.id`."),
+        .describe("The subscription's cancellation item, the same as `Subscription.cancellation.id`."),
     subscription_id: zod.uuid(),
     plan_id: zod.uuid(),
     plan_name: zod.string(),
-    charge_type: zod
-        .enum(["postpaid", "prepaid", "one_time"])
-        .describe("How the subscription is charged. Creating the cancellation turned automatic renewal off;\nwithdrawing it turns renewal back on for a `postpaid` subscription and leaves it off for a\n`prepaid` one."),
+    type: PriceType,
+    usage_type: UsageType.describe("Creating the cancellation turned automatic renewal off; withdrawing it turns renewal back on\nfor a `metered` subscription and leaves it off for a `licensed` one."),
     status: zod.enum(["requested", "scheduled", "releasing", "completed", "canceled", "failed"]),
     failure_code: zod
         .string()
         .optional()
-        .describe("Execution stopped or its result is unknown. Present while release still requires resolution; it does not establish refund eligibility."),
+        .describe("The release stopped or its result is unknown; present while the release needs resolution."),
     release_started_at: zod.iso.datetime({ offset: true }).optional(),
     effective_at: zod.iso
         .datetime({ offset: true })

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

@@ -40,10 +40,13 @@ export declare const CancellationList: zod.ZodObject<{
             subscription_id: zod.ZodUUID;
             plan_id: zod.ZodUUID;
             plan_name: zod.ZodString;
-            charge_type: zod.ZodEnum<{
-                postpaid: "postpaid";
-                prepaid: "prepaid";
+            type: zod.ZodEnum<{
                 one_time: "one_time";
+                recurring: "recurring";
+            }>;
+            usage_type: zod.ZodEnum<{
+                licensed: "licensed";
+                metered: "metered";
             }>;
             status: zod.ZodEnum<{
                 completed: "completed";

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

@@ -28,10 +28,13 @@ export declare const CancellationRefundPreview: zod.ZodObject<{
             id: zod.ZodUUID;
             name: zod.ZodString;
         }, zod.z.core.$strict>, zod.ZodNull]>>;
-        charge_type: zod.ZodEnum<{
-            postpaid: "postpaid";
-            prepaid: "prepaid";
+        type: zod.ZodEnum<{
             one_time: "one_time";
+            recurring: "recurring";
+        }>;
+        usage_type: zod.ZodEnum<{
+            licensed: "licensed";
+            metered: "metered";
         }>;
         auto_renew: zod.ZodBoolean;
         unused_amount: zod.ZodString;

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

@@ -29,4 +29,4 @@ export const CancellationRefundPreview = zod
     forfeited_amount: Money,
     items: zod.array(CancellationRefundPreviewItem),
 })
-    .describe("What the cancellation would return, subscription by subscription and in total, as of now. Give\n`proration_date` and `refundable_amount` when creating the cancellation.\n\n- `unused_amount`: before tax, the amount paid for the current periods minus the value of the\n  time used, valued as refund policy `prorated` describes, whatever the refund terms say.\n- `refundable_amount`: what is returned the way it was paid, including the tax paid on it;\n  `refund_amount` plus `credit_amount`.\n- `refund_amount`: the part returned to the balance or to 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\nPostpaid and one-time subscriptions show zero; 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 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.");

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

@@ -14,10 +14,13 @@ export declare const CancellationRefundPreviewItem: zod.ZodObject<{
         id: zod.ZodUUID;
         name: zod.ZodString;
     }, zod.z.core.$strict>, zod.ZodNull]>>;
-    charge_type: zod.ZodEnum<{
-        postpaid: "postpaid";
-        prepaid: "prepaid";
+    type: zod.ZodEnum<{
         one_time: "one_time";
+        recurring: "recurring";
+    }>;
+    usage_type: zod.ZodEnum<{
+        licensed: "licensed";
+        metered: "metered";
     }>;
     auto_renew: zod.ZodBoolean;
     unused_amount: zod.ZodString;