@leaflow/sdk 0.0.0-dev.352.g85966ed → 0.0.0-dev.353.g74313e0

package/dist/canopy/v1/generated/validators/refund.zod.js

@@ -39,14 +39,14 @@ export const Refund = zod.strictObject({
     cancellation_item_id: zod.uuid().optional(),
     transactions: zod
         .array(Transaction)
-        .describe("Original funds-return split and each result. Unknown gateway results remain pending."),
+        .describe("The refund split by original payment source, with each result. Unknown gateway results stay pending."),
     id: zod.uuid(),
     billing_account_id: zod.int().optional(),
     invoice_id: zod.uuid().nullish(),
     order_id: zod
         .uuid()
         .nullish()
-        .describe("The order the refund belongs to: the order that caused it, such as a downgrade, otherwise\nthe order of the refunded invoice. Null for refunds of top-ups and of usage invoices."),
+        .describe("The order the refund belongs to: the order that caused it, such as a downgrade, otherwise the order of the refunded invoice. Null for refunds of top-ups and usage invoices."),
     amount: Money.describe("The whole refund. Equals balance_amount plus credit_amount plus gateway_amount."),
     balance_amount: Money.describe("The part returned to the account balance."),
     credit_amount: Money.describe("The part restored to the credit grants that paid for it."),
@@ -56,7 +56,7 @@ export const Refund = zod.strictObject({
     destination: zod
         .enum(["balance", "gateway"])
         .optional()
-        .describe("Use balance_amount, credit_amount and gateway_amount, which also show a refund split between several destinations."),
+        .describe("Use balance_amount, credit_amount and gateway_amount, which also show a refund split between destinations."),
     status: zod
         .enum(["pending", "processing", "succeeded", "failed"])
         .describe("Summary of the parts in `transactions`.\n\n- `pending`: nothing has been returned yet, and at least one part is in progress.\n- `processing`: some parts have been returned, and at least one is still in progress.\n- `succeeded`: every part has been returned.\n- `failed`: no part is in progress and at least one has failed. What was returned is in\n  settled_amount.\n\nReturns to the balance and to credit grants complete shortly after the refund is made; a\nreturn to a payment method completes when the gateway confirms it."),

package/dist/canopy/v1/generated/validators/refundPolicy.zod.js

@@ -33,4 +33,4 @@
 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\nthe time used, never below zero and never more than what remains unrefunded. The time used runs\nfrom the period start to the effective cancellation time and is valued at the plan's\nshorter-period prices in the same currency, frozen at purchase as the order item's\nrefund_monthly_amount and refund_hourly_amount: each full calendar month at the one-month prepaid\nprice, the remainder at the postpaid hourly price or, without one, at the one-month price by the\nsecond. When the plan has no prepaid period shorter than the one bought, the time used is valued\nat the price paid, pro rata by the second. Discounts are not refunded, as they were never paid,\nand setup fees are excluded. The refunded part returns to the payment sources it came from. Tax\npaid is refunded in the same proportion as the amount it was paid on.");
+    .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.");

package/dist/canopy/v1/generated/validators/refundReason.zod.js

@@ -45,4 +45,4 @@ export const RefundReason = zod
     "payment_not_applied",
     "operator",
 ])
-    .describe("Why the refund was made. Clients map the code to their own wording. More codes may be added;\ntreat an unknown code as a refund without a stated reason.\n\n- `provisioning_failed`: the purchase could not be delivered.\n- `order_expired`: the order expired after part of it had been paid.\n- `order_canceled`: the account holder canceled the order after part of it had been paid.\n- `change_canceled`: a scheduled change was withdrawn after part of it had been paid.\n- `change_expired`: a scheduled change could not take effect before its time passed.\n- `subscription_canceled`: the subscription was canceled and its unused value returned under\n  its refund terms.\n- `future_period_canceled`: a renewal that had not started yet was withdrawn.\n- `downgrade_difference`: after a downgrade, the remaining value of what was paid, valued as refund\n  policy `prorated` describes, minus the new configuration's cost for the remaining time at the\n  change item's `refund_monthly_amount` and `refund_hourly_amount`. Nothing is refunded when that is\n  zero or less.\n- `usage_true_up`: usage priced again 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 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.");

package/dist/canopy/v1/generated/validators/renewRequest.zod.js

@@ -38,12 +38,12 @@ export const renewRequestUseCreditsDefault = true;
 export const RenewRequest = zod.strictObject({
     order_id: zod
         .uuid()
-        .describe("Purchase ID saved before submitting. Duplicate creation conflicts; query this order after an unknown result."),
+        .describe("The order ID, chosen by the caller. Creating it again conflicts; read the order after an unknown outcome."),
     periods: zod
         .int()
         .min(1)
         .default(renewRequestPeriodsDefault)
-        .describe("How many further periods to buy, each at the price this item already bills at.\n\nBuying twelve monthly periods is not the same as buying one yearly term: a longer\nterm is usually sold at a lower price, and that price is only reached by naming the\ninterval. Use `interval_count` and `interval` for that."),
+        .describe("How many further periods to buy, each at the price the subscription already renews at. To buy a longer term at its own price, give `interval` and `interval_count` instead."),
     interval_count: zod
         .int()
         .min(1)

package/dist/canopy/v1/generated/validators/renewalOrderRequest.zod.js

@@ -37,7 +37,7 @@ export const RenewalOrderRequest = zod
     .strictObject({
     order_id: zod
         .uuid()
-        .describe("Purchase ID saved before submitting. Duplicate creation conflicts; query this order after an unknown result."),
+        .describe("The order ID, chosen by the caller. Creating it again conflicts; read the order after an unknown outcome."),
     periods: zod
         .int()
         .min(1)
@@ -47,4 +47,4 @@ export const RenewalOrderRequest = zod
     interval: zod.enum(["day", "month", "year"]).optional().describe("As in renewing."),
     termination_policy: TerminationPolicy.optional().describe("As in renewing."),
 })
-    .describe("The periods and price of the renewal, chosen as in renewing.");
+    .describe("The renewal's periods and price, chosen as in renewing.");

package/dist/canopy/v1/generated/validators/renewalPrice.zod.js

@@ -44,5 +44,5 @@ export const RenewalPrice = zod.strictObject({
     currency: zod.string().optional(),
     current: zod
         .boolean()
-        .describe("The term this item already bills at. Renewing for it uses the price bought\noriginally, so a later price change does not affect it."),
+        .describe("The term the subscription renews at now; renewing for it keeps the agreed price."),
 });

package/dist/canopy/v1/generated/validators/scheduledChange.zod.js

@@ -43,9 +43,9 @@ export const ScheduledChange = zod
     plan_name: zod.string(),
     price_id: zod.uuid(),
     quantity: zod.string(),
-    recurring_amount: zod.string().describe("The target prepaid renewal amount before tax."),
+    recurring_amount: zod.string().describe("The target licensed renewal amount before tax."),
     currency: zod.string(),
     interval: zod.enum(["day", "month", "year"]),
     interval_count: zod.int().min(1),
 })
-    .describe("The next accepted period-end change for a subscription. It describes the target terms and does not change the current subscription until effective_at.");
+    .describe("The next accepted period-end change of the subscription: the target terms, applied at effective_at.");

package/dist/canopy/v1/generated/validators/spendRow.zod.d.ts

@@ -40,6 +40,14 @@ export declare const SpendRow: zod.ZodObject<{
     plan_id: zod.ZodOptional<zod.ZodUUID>;
     plan_name: zod.ZodOptional<zod.ZodString>;
     resource_id: zod.ZodOptional<zod.ZodString>;
+    meter: zod.ZodOptional<zod.ZodObject<{
+        lookup_key: zod.ZodOptional<zod.ZodString>;
+        id: zod.ZodUUID;
+        name: zod.ZodString;
+    }, zod.z.core.$strict>>;
+    unit: zod.ZodOptional<zod.ZodString>;
+    quantity: zod.ZodOptional<zod.ZodString>;
+    dimensions: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodString>>;
     amount: zod.ZodString;
     currency: zod.ZodString;
 }, zod.z.core.$strict>;

package/dist/canopy/v1/generated/validators/spendRow.zod.js

@@ -32,12 +32,23 @@
  */
 import * as zod from "zod";
 import { Money } from "./money.zod.js";
+import { ObjectIdentity } from "./objectIdentity.zod.js";
 import { Product } from "./product.zod.js";
 export const SpendRow = zod.strictObject({
     product: Product.optional(),
     plan_id: zod.uuid().optional(),
     plan_name: zod.string().optional(),
     resource_id: zod.string().optional().describe("Present only when grouped by resource."),
+    meter: ObjectIdentity.optional().describe("Present only when grouped by meter."),
+    unit: zod.string().optional().describe("Present only when grouped by meter."),
+    quantity: zod
+        .string()
+        .optional()
+        .describe("Net usage quantity, present only when grouped by meter."),
+    dimensions: zod
+        .record(zod.string(), zod.string())
+        .optional()
+        .describe("The values of the meter's presentation dimensions, present only when grouped by meter."),
     amount: Money,
     currency: zod.string(),
 });

package/dist/canopy/v1/generated/validators/spendRowList.zod.d.ts

@@ -41,6 +41,14 @@ export declare const SpendRowList: zod.ZodObject<{
         plan_id: zod.ZodOptional<zod.ZodUUID>;
         plan_name: zod.ZodOptional<zod.ZodString>;
         resource_id: zod.ZodOptional<zod.ZodString>;
+        meter: zod.ZodOptional<zod.ZodObject<{
+            lookup_key: zod.ZodOptional<zod.ZodString>;
+            id: zod.ZodUUID;
+            name: zod.ZodString;
+        }, zod.z.core.$strict>>;
+        unit: zod.ZodOptional<zod.ZodString>;
+        quantity: zod.ZodOptional<zod.ZodString>;
+        dimensions: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodString>>;
         amount: zod.ZodString;
         currency: zod.ZodString;
     }, zod.z.core.$strict>>;

package/dist/canopy/v1/generated/validators/spendRowList.zod.js

@@ -36,7 +36,7 @@ import { OffsetPagination } from "./offsetPagination.zod.js";
 import { SpendRow } from "./spendRow.zod.js";
 export const SpendRowList = zod.strictObject({
     items: zod.array(SpendRow),
-    total: Money.describe("The sum over the whole period, not only the page returned."),
+    total: Money.describe("The total over all matching groups, not only the page returned."),
     currency: zod.string(),
     pagination: OffsetPagination,
 });

package/dist/canopy/v1/generated/validators/statement.zod.js

@@ -47,7 +47,7 @@ export const Statement = zod
     type: StatementType,
     estimated: zod
         .boolean()
-        .describe("True while the statement is open. The estimate applies tier pricing to the period's usage so far and adds tax for the current invoice contact. Minimum charges are added at the period's final closing, and a tier reduction larger than this statement's own charges is credited to earlier invoices of the period at closing."),
+        .describe("True while the statement is open. The estimate prices the period's usage so far at tier prices and adds tax for the current invoice contact. Minimum charges are added at the period's final closing, and a tier reduction larger than this statement's charges is credited to the period's earlier invoices at closing."),
     amounts: StatementAmounts,
     closed_at: zod.iso.datetime({ offset: true }).optional(),
     invoice_id: zod
@@ -58,4 +58,4 @@ export const Statement = zod
     calculated_at: zod.iso.datetime({ offset: true }).optional(),
     credited_amount: Money,
 })
-    .describe("An account's consumption for one billing period, collected at one closing. Usage is billed after every settlement run, about hourly; each closing issues an invoice for the usage priced since the previous closing and collects it from credits and balance at once, and later usage is collected in the next statement of the same period. A closed statement is never rewritten. The period's consumption is the sum of its statements.");
+    .describe("An account's consumption for one billing period up to one closing. Usage is invoiced after every settlement run, about hourly: each closing issues an invoice for the usage priced since the previous one and collects it from credits and balance, and later usage goes into the next statement of the same period. A closed statement does not change. The period's consumption is the sum of its statements.");

package/dist/canopy/v1/generated/validators/statementItem.zod.d.ts

@@ -36,6 +36,7 @@ export declare const StatementItem: zod.ZodObject<{
     product_id: zod.ZodOptional<zod.ZodString>;
     meter_id: zod.ZodOptional<zod.ZodUUID>;
     unit: zod.ZodOptional<zod.ZodString>;
+    dimensions: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodString>>;
     quantity: zod.ZodOptional<zod.ZodString>;
     deducted_quantity: zod.ZodOptional<zod.ZodString>;
     amount: zod.ZodString;

package/dist/canopy/v1/generated/validators/statementItem.zod.js

@@ -37,6 +37,10 @@ export const StatementItem = zod.strictObject({
     product_id: zod.string().optional(),
     meter_id: zod.uuid().optional(),
     unit: zod.string().optional(),
+    dimensions: zod
+        .record(zod.string(), zod.string())
+        .optional()
+        .describe("The values of the meter's presentation dimensions, such as the model and token kind. Included only when grouping by meter, which splits each meter by these values."),
     quantity: zod
         .string()
         .optional()

package/dist/canopy/v1/generated/validators/statementSummary.zod.d.ts

@@ -46,6 +46,7 @@ export declare const StatementSummary: zod.ZodObject<{
         product_id: zod.ZodOptional<zod.ZodString>;
         meter_id: zod.ZodOptional<zod.ZodUUID>;
         unit: zod.ZodOptional<zod.ZodString>;
+        dimensions: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodString>>;
         quantity: zod.ZodOptional<zod.ZodString>;
         deducted_quantity: zod.ZodOptional<zod.ZodString>;
         amount: zod.ZodString;

package/dist/canopy/v1/generated/validators/statementType.zod.js

@@ -33,4 +33,4 @@
 import * as zod from "zod";
 export const StatementType = zod
     .enum(["interim", "final", "supplement"])
-    .describe("interim: a closing before the period's usage is final; minimum charges are not applied. final: the first closing after the period ended and its late usage was settled; minimum charges for the whole period are applied. supplement: a closing after the final one, for usage priced late. An open statement is interim.");
+    .describe("`interim`: a closing before the period's usage is final, without minimum charges. `final`: the first closing after the period ended and its late usage was settled, applying the period's minimum charges. `supplement`: a closing after the final one, for usage priced late. An open statement is interim.");

package/dist/canopy/v1/generated/validators/subscription.zod.d.ts

@@ -35,11 +35,15 @@ export declare const subscriptionDiscountedRenewalsRemainingMin = 0;
 export declare const Subscription: zod.ZodObject<{
     renewal_discounts_enabled: zod.ZodOptional<zod.ZodBoolean>;
     currency: 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";
+    }>;
+    dimensions: zod.ZodRecord<zod.ZodString, zod.ZodString>;
     interval: zod.ZodEnum<{
         none: "none";
         day: "day";

package/dist/canopy/v1/generated/validators/subscription.zod.js

@@ -34,6 +34,7 @@ import * as zod from "zod";
 import { AccountIdentity } from "./accountIdentity.zod.js";
 import { NamedIdentity } from "./namedIdentity.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";
@@ -41,6 +42,7 @@ import { ScheduledChange } from "./scheduledChange.zod.js";
 import { SubscriptionCancellation } from "./subscriptionCancellation.zod.js";
 import { SubscriptionRestriction } from "./subscriptionRestriction.zod.js";
 import { TerminationPolicy } from "./terminationPolicy.zod.js";
+import { UsageType } from "./usageType.zod.js";
 export const subscriptionDiscountedRenewalsRemainingMin = 0;
 export const Subscription = zod
     .strictObject({
@@ -49,13 +51,17 @@ export const Subscription = zod
         .optional()
         .describe("Whether new account discounts may apply to future renewals. A fixed operator renewal agreement disables automatic discounts; catalog repricing or a newly selected purchase agreement enables them."),
     currency: zod.string(),
-    charge_type: zod.enum(["postpaid", "prepaid", "one_time"]),
+    type: PriceType,
+    usage_type: UsageType,
+    dimensions: zod
+        .record(zod.string(), zod.string())
+        .describe("The dimension values of what was bought, such as region and instance type. Empty when the purchase gave none."),
     interval: zod.enum(["none", "day", "month", "year"]),
     interval_count: zod.int().min(1).optional(),
     recurring_amount: zod
         .string()
         .optional()
-        .describe("Whole-subscription prepaid renewal amount, after continuing discounts and before tax.\nPending subscriptions show base terms until paying the order fixes any new continuing discount.\nAbsent for other charge types."),
+        .describe("The whole licensed subscription's renewal amount, after continuing discounts and before tax. A pending subscription shows base terms until paying the order fixes any new discount. Absent for metered and one-time subscriptions."),
     termination_policy: TerminationPolicy.optional(),
     refund_policy: RefundPolicy.optional(),
     order_item_id: zod.uuid().optional(),
@@ -68,17 +74,17 @@ export const Subscription = zod
     restrictions: zod
         .array(SubscriptionRestriction)
         .optional()
-        .describe("The operations currently prevented on the subscription, sorted. The subscription is suspended while this contains billing.subscriptions.use."),
+        .describe("The operations currently prevented on the subscription, sorted; it is suspended while this contains `billing.subscriptions.use`."),
     billing_cycle_anchor: zod.iso.datetime({ offset: true }).optional(),
     cancellation: SubscriptionCancellation.optional(),
     scheduled_change: zod
         .union([ScheduledChange, zod.null()])
         .optional()
-        .describe("The accepted period-end change currently scheduled for this subscription. Null when no such change exists."),
+        .describe("The accepted period-end change scheduled for this subscription; null when there is none."),
     default_payment_method_id: zod
         .uuid()
         .nullish()
-        .describe("The saved payment method automatic renewal charges after the account's balance and credits,\nbefore the account's default payment method. Set when the purchase, a renewal or a change is paid with a\nsaved payment method; paying any other way leaves it unchanged. It is used only while it belongs to the\naccount that pays the renewal."),
+        .describe("The saved payment method automatic renewal charges after balance and credits, before the account's default payment method. Set when a purchase, renewal or change is paid with a saved payment method. Used only while it belongs to the account paying the renewal."),
     created_at: zod.iso.datetime({ offset: true }).optional(),
     id: zod.uuid(),
     billing_account_id: zod
@@ -89,11 +95,11 @@ export const Subscription = zod
     project_id: zod
         .uuid()
         .nullish()
-        .describe("Which project this is for. Absent when it was bought at account level, such as a\nmembership, which belongs to no single project."),
+        .describe("The project it is for. Absent for an account-level purchase, such as a membership."),
     project: zod
         .union([NamedIdentity, zod.null()])
         .optional()
-        .describe("The project and its current name, for display. Absent for a purchase at account level,\nand when the project no longer exists or its details cannot be read at the moment;\n`project_id` still identifies it then."),
+        .describe("The project and its current name. Absent for an account-level purchase or when the project cannot be read; `project_id` still identifies it."),
     product: Product,
     plan_id: zod.uuid(),
     plan_name: zod.string(),
@@ -102,25 +108,25 @@ export const Subscription = zod
     current_term_end: zod.iso
         .datetime({ offset: true })
         .nullish()
-        .describe("When a prepaid subscription renews or expires, the end of the last service period bought.\nRenewing several periods in advance moves it. Null until a new subscription becomes active, even when\nits purchase has been paid, and for postpaid subscriptions."),
+        .describe("When a licensed subscription renews or expires: the end of the last period bought, moved by renewing in advance. Null until the subscription becomes active, even when its purchase has been paid, and for metered subscriptions."),
     current_period_start: zod.iso
         .datetime({ offset: true })
         .nullish()
-        .describe("Start of the service period in effect now. Null when none is, including for postpaid subscriptions."),
+        .describe("Start of the service period in effect now. Null when none is, including for metered subscriptions."),
     current_period_end: zod.iso
         .datetime({ offset: true })
         .nullish()
-        .describe("End of the service period in effect now. Renewing in advance moves `current_term_end`, not\nthis. Null when no period is in effect, including for postpaid subscriptions."),
+        .describe("End of the service period in effect now; renewing in advance moves `current_term_end`, not this. Null when no period is in effect, including for metered subscriptions."),
     auto_renew: zod
         .boolean()
-        .describe("A prepaid subscription renews automatically while this is on. A postpaid subscription always continues until it is canceled; this is true until a cancellation is requested and cannot be set."),
+        .describe("Whether a licensed subscription renews automatically. A metered subscription continues until it is canceled; for it this is true until a cancellation is requested, and cannot be set."),
     status: zod
         .enum(["pending", "provisioning", "active", "suspended", "canceled", "terminated"])
-        .describe("pending means the purchase relationship exists but its order has not been accepted.\nprovisioning means the service accepted the order and is delivering. For a service-owned\npurchase, only confirmed delivery moves it to active; paying alone does not.\ncanceled means cancellation completed, or an unfulfilled purchase was canceled or failed without delivery.\nterminated means an administrator or the owning service immediately ended the commercial relationship."),
+        .describe("`pending`: the order has not been accepted. `provisioning`: the owning service accepted the order and is delivering. `active`: delivery was confirmed; payment alone does not make a subscription active. `suspended`: service is stopped while a lien restricts its use. `canceled`: cancellation completed, or an undelivered purchase was canceled or failed. `terminated`: an operator or the owning service ended it immediately."),
     started_at: zod.iso
         .datetime({ offset: true })
         .nullish()
-        .describe("Confirmed start of service. Null until a new subscription becomes active, including after payment."),
+        .describe("When service started. Null until a new subscription becomes active, also after payment."),
     ended_at: zod.iso.datetime({ offset: true }).nullish(),
 })
-    .describe("An independently billed purchase relationship, separate from the owning service's resource.\nPlacing a new prepaid or postpaid service order creates a pending subscription for each line\nin the same purchase transaction. Its ID is returned on the order item and remains stable\nthrough checkout and delivery. One order may create several subscriptions, such as an instance,\nits system disk and its address; it has no single subscription ID.\n\nPending and provisioning do not grant service or accrue usage. A service-owned subscription\nbecomes provisioning when the owning service accepts the order, and active when the service\nconfirms delivery, with started_at set to the confirmed effective time; payment changes neither. Prepaid service periods start\nthen; postpaid usage starts only when the service reports actual delivery and metering.\n\nOne-time delivery may omit a subscription. Renewals reference and extend existing subscriptions\nrather than creating another; a change keeps the subscription ID and switches its terms when it\ntakes effect. Canceling or failing an unfulfilled purchase sets its pending or provisioning\nsubscriptions to canceled without starting a service period.\nFixed renewals use the agreed recurring_amount and interval; already paid periods retain their\noriginal value. Technical state belongs to the owning service.\n\nA purchased shared capacity limit, such as a regional snapshot count quota, can have its own\nsubscription. Activating that capacity confirms delivery of the quota, not individual snapshots.\nCreating or deleting snapshots within it does not create, activate or terminate more subscriptions;\nthe owning service enforces current holdings against the purchased count.");
+    .describe("A purchase that is billed, renewed and changed on its own, separate from the owning service's resource. A new\nrecurring purchase creates a pending subscription for each order line; its ID is returned on the order item\nand stays the same through checkout, delivery, renewals and changes. A one-time purchase may create none.\n\nPending and provisioning subscriptions grant no service. A subscription becomes provisioning when the owning\nservice accepts the order, and active when the service confirms delivery, which sets started_at; payment\nchanges neither. Licensed service periods start at delivery, and metered usage is charged as the service\nreports it. Canceling or failing an undelivered purchase cancels its subscriptions without starting a period.\nRenewals use recurring_amount and the agreed interval; paid periods keep their value.\n\nA shared capacity limit, such as a regional snapshot quota, has one subscription for the purchased quantity\nrather than one per item.");

package/dist/canopy/v1/generated/validators/subscriptionCancellation.zod.js

@@ -37,7 +37,7 @@ export const SubscriptionCancellation = zod
     cancellation_id: zod
         .uuid()
         .optional()
-        .describe("The cancellation this request belongs to, with the other subscriptions released together."),
+        .describe("The cancellation this item belongs to, with the other subscriptions released together."),
     id: zod.uuid(),
     subscription_id: zod.uuid(),
     status: zod.enum(["requested", "scheduled", "releasing", "failed", "completed", "canceled"]),
@@ -52,4 +52,4 @@ export const SubscriptionCancellation = zod
     failure_code: zod.string().optional(),
     failure_reason: zod.string().optional(),
 })
-    .describe("The latest cancellation that includes the subscription, with this subscription's item. `id` is the\nitem; `cancellation_id` is the cancellation. scheduled_at is the intended time; effective_at is the\nconfirmed end of service. A cancellation alone does not stop metering or issue a refund.");
+    .describe("The latest cancellation including the subscription, with this subscription's item: `id` is the item and `cancellation_id` the cancellation. scheduled_at is the intended time and effective_at the confirmed end of service.");

package/dist/canopy/v1/generated/validators/subscriptionList.zod.d.ts

@@ -35,11 +35,15 @@ export declare const SubscriptionList: zod.ZodObject<{
     items: zod.ZodArray<zod.ZodObject<{
         renewal_discounts_enabled: zod.ZodOptional<zod.ZodBoolean>;
         currency: 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";
+        }>;
+        dimensions: zod.ZodRecord<zod.ZodString, zod.ZodString>;
         interval: zod.ZodEnum<{
             none: "none";
             day: "day";

package/dist/canopy/v1/generated/validators/subscriptionRestriction.zod.js

@@ -39,4 +39,4 @@ export const SubscriptionRestriction = zod
     "billing.subscriptions.cancel",
     "billing.subscriptions.terminate",
 ])
-    .describe("An operation Leaflow prevents on a subscription. billing.subscriptions.use stops the service. renew prevents renewal and payment of a renewal order. modify prevents placing a change order. cancel prevents cancellation. terminate prevents immediate termination.");
+    .describe("An operation prevented on the subscription. `billing.subscriptions.use` stops the service. `renew` prevents renewal and paying a renewal order. `modify` prevents placing a change order. `cancel` prevents cancellation. `terminate` prevents immediate termination.");

package/dist/canopy/v1/generated/validators/terminationPolicy.zod.js

@@ -33,4 +33,4 @@
 import * as zod from "zod";
 export const TerminationPolicy = zod
     .enum(["immediate", "period_end"])
-    .describe("Whether a fulfilled purchase may end immediately or only after its paid term. Does not grant a refund. When absent, the terms are not configured and termination requires review.");
+    .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.");

package/dist/canopy/v1/generated/validators/tier.zod.js

@@ -36,7 +36,7 @@ export const Tier = zod.strictObject({
     up_to: zod
         .string()
         .nullish()
-        .describe("The upper bound of this band. Null on the last band, which has no bound."),
+        .describe("The band's inclusive upper bound; null for the last band."),
     unit_amount: Money,
     flat_amount: Money.optional().describe("Charged once when this band is reached, in addition to the per-unit amount."),
 });

package/dist/canopy/v1/generated/validators/topUp.zod.js

@@ -40,12 +40,12 @@ export const TopUp = zod
     id: zod.uuid(),
     billing_account_id: zod.int(),
     account: AccountIdentity,
-    amount: Money.describe("What is credited to the account, in the account's own currency."),
+    amount: Money.describe("What is credited to the account, in its currency."),
     currency: zod.string(),
-    remaining_amount: Money.optional().describe("The part of this top-up still held in the balance. Pending refunds can temporarily\nreserve part of it; it is not a promise that the whole amount is immediately withdrawable."),
+    remaining_amount: Money.optional().describe("The part of this top-up still in the balance. Pending refunds may hold part of it, so not all of it is necessarily withdrawable."),
     status: zod
         .enum(["pending", "succeeded", "failed", "canceled"])
-        .describe("`pending` until the payment gateway reaches a result. The balance increases on `succeeded`.\n\n`failed` means the gateway declined the payment. A declined attempt ends the top-up at once\nand the payment is withdrawn at the gateway; to pay another way, create a new top-up.\n`canceled` means the attempt was withdrawn without collecting money; `cancellation_reason`\nsays why. Unknown gateway outcomes remain `pending`, and a browser redirect is not proof of\npayment.\n\n`failed` and `canceled` are final. If the gateway nevertheless collects payment for such an\nattempt, the amount is credited as a separate `succeeded` top-up."),
+        .describe("`pending` until the payment gateway reaches a result; the balance increases on `succeeded`. `failed`: the gateway declined the payment, which is withdrawn at the gateway; create a new top-up to pay another way. `canceled`: withdrawn without collecting money, for the reason in `cancellation_reason`. Unknown gateway outcomes stay `pending`; a browser redirect is not proof of payment. `failed` and `canceled` are final; a payment the gateway collects afterwards is credited as a separate `succeeded` top-up."),
     cancellation_reason: PaymentCancellationReason.optional(),
     payment_gateway: zod.string().optional().describe("Which payment gateway collected it."),
     method_type: zod
@@ -55,17 +55,17 @@ export const TopUp = zod
     presentment_currency: zod
         .string()
         .optional()
-        .describe("The currency the customer was actually charged in, when the checkout page collected a\nlocal one. Absent when it was the same as the account's."),
-    presentment_amount: Money.optional().describe("What was charged, in `presentment_currency`. It will not equal `amount`, and it is\nthe figure that appears on the customer's card or wallet statement."),
+        .describe("The currency the customer was charged in when the checkout collected a local currency; absent when it is the account's."),
+    presentment_amount: Money.optional().describe("The amount charged in `presentment_currency`, as shown on the customer's statement."),
     failure_reason: zod
         .string()
         .optional()
-        .describe("Why the gateway declined it. Present with `failed`. The value is the gateway's own code,\npassed on unchanged: the card issuer's decline code when there is one (Stripe's decline_code,\nsuch as insufficient_funds or lost_card), otherwise the gateway's error code (Stripe's code,\nsuch as card_declined, expired_card or payment_intent_authentication_failure). Clients map it\nto their own wording and treat an unknown value as a generic decline."),
+        .describe("Why the gateway declined it; present with `failed`. The gateway's code unchanged: the issuer's decline code when there is one (Stripe decline_code, such as insufficient_funds), otherwise the gateway's error code (Stripe code, such as card_declined). Treat an unknown value as a generic decline."),
     action: PaymentAction.optional(),
     created_at: zod.iso.datetime({ offset: true }),
     settled_at: zod.iso
         .datetime({ offset: true })
         .nullish()
-        .describe("When the funds arrived. Later than `created_at` — by days for a bank transfer — so\nreconciling against a statement uses this rather than the moment it was started.\nAbsent until the payment completes."),
+        .describe("When the funds arrived, possibly days after `created_at`. Absent until the payment completes."),
 })
-    .describe("A top-up attempt and its outcome. A successful top-up adds a traceable amount to the balance; it is not a credit grant and has no associated invoice.");
+    .describe("A top-up attempt and its outcome. A successful top-up adds to the balance; it is not a credit grant and has no invoice.");

package/dist/canopy/v1/generated/validators/topUpCreate.zod.js

@@ -40,7 +40,7 @@ export const TopUpCreate = zod.strictObject({
         .string()
         .min(1)
         .max(topUpCreatePaymentGatewayMax)
-        .describe("The gateway explicitly selected from the available payment options."),
+        .describe("The gateway selected from the available payment options."),
     method_type: zod
         .string()
         .min(1)
@@ -48,12 +48,12 @@ export const TopUpCreate = zod.strictObject({
         .describe("The selected method, such as card, wechat_pay or alipay."),
     id: zod
         .uuid()
-        .describe("The ID of this top-up attempt. Keep it before submitting and query it after an uncertain response."),
+        .describe("The top-up ID, chosen by the caller. Read it after an uncertain response."),
     billing_account_id: zod.int(),
-    amount: Money.and(zod.string().regex(topUpCreateAmountTwoRegExp)).describe("In the account's currency, and no finer than that currency's smallest unit:\ntwo decimals for most, none for the yen. A finer amount is refused here rather\nthan at the checkout page, where the customer would see the gateway's own wording\ninstead of an explanation.\n\nThere is a minimum, which differs by currency. Below it the gateway's fee\nexceeds the top-up itself, so such a payment costs more to accept than it brings.\nThe minimum in force is returned with the rejection."),
+    amount: Money.and(zod.string().regex(topUpCreateAmountTwoRegExp)).describe("In the account's currency, no finer than its smallest unit (two decimals for most currencies, none for JPY). An amount below the currency's minimum top-up is refused, and the minimum is returned with the error."),
     payment_method_id: zod
         .uuid()
         .optional()
-        .describe("Charge a saved method instead of opening a checkout page."),
+        .describe("Charge a saved payment method instead of opening a checkout page."),
     return_url: zod.string().optional().describe("Where to send the customer after checkout."),
 });

package/dist/canopy/v1/generated/validators/transaction.zod.js

@@ -48,26 +48,26 @@ export const Transaction = zod
     refund_destination: zod
         .enum(["balance", "credit", "gateway"])
         .optional()
-        .describe("Present on refunds. Where this part of the refund goes.\n\n- `balance`: back to the account balance.\n- `credit`: back to the credit grant that paid, which keeps its original expiry.\n- `gateway`: back to the payment method it was paid with."),
+        .describe("Present on refunds: where this part goes. `balance`: the account balance. `credit`: the credit grant that paid, keeping its original expiry. `gateway`: the payment method it was paid with."),
     status: zod
         .enum(["pending", "succeeded", "failed", "canceled"])
         .optional()
-        .describe("`failed` means the operation did not succeed; for a gateway payment, that the gateway declined\nit. `canceled` means a gateway payment was withdrawn without collecting money. After either,\nan invoice the payment was meant to pay remains open for another payment."),
+        .describe("`failed`: the operation did not succeed; for a gateway payment, the gateway declined it. `canceled`: a gateway payment was withdrawn without collecting money. Either way, the invoice it was for stays open."),
     cancellation_reason: PaymentCancellationReason.optional(),
     payment_gateway: zod.string().optional(),
     method_type: zod.string().optional(),
     failure_reason: zod
         .string()
         .optional()
-        .describe("Why it failed. Present with `failed`. For a declined gateway payment the value is the\ngateway's own code, passed on unchanged: the card issuer's decline code when there is one\n(Stripe's decline_code, such as insufficient_funds or lost_card), otherwise the gateway's\nerror code (Stripe's code, such as card_declined, expired_card or\npayment_intent_authentication_failure). Clients map it to their own wording and treat an\nunknown value as a generic decline."),
+        .describe("Why it failed; present with `failed`. For a declined gateway payment, the gateway's code unchanged: the issuer's decline code when there is one (Stripe decline_code, such as insufficient_funds), otherwise the gateway's error code (Stripe code, such as card_declined). Treat an unknown value as a generic decline."),
     settled_at: zod.iso.datetime({ offset: true }).optional(),
     id: zod.uuid(),
     billing_account_id: zod.int().optional(),
     type: TransactionType,
-    amount: Money.describe("Signed by type: positive for `topup` and `payment`, negative for `refund`.\nAn `adjustment` is positive when it adds to the balance and negative when it takes from\nit. For the other types the sign does not tell the effect on the balance: a payment from\nthe balance lowers it, while a payment by gateway or by credit leaves it unchanged."),
-    remaining_amount: Money.describe("How much of this transaction is still available in the balance. Only top-ups, positive\nadjustments and gateway payments later returned to the balance can be non-zero."),
+    amount: Money.describe("Signed by type: positive for `topup` and `payment`, negative for `refund`. An `adjustment` is positive when it adds to the balance and negative when it takes from it. For other types the sign does not show the effect on the balance: a payment from balance lowers it, a payment by gateway or credit does not."),
+    remaining_amount: Money.describe("How much of this transaction is still in the balance. Only top-ups, positive adjustments and gateway payments returned to the balance can be non-zero."),
     currency: zod.string(),
     reason: zod.string().optional(),
     created_at: zod.iso.datetime({ offset: true }),
 })
-    .describe("A funds operation. Each payment has one source; refunds identify the original successful transaction. Unknown gateway results remain pending. Payments from the balance or a gateway are distinct from credit-grant payments.");
+    .describe("A funds movement with one source. Refunds name the original transaction. Unknown gateway results stay pending.");

package/dist/canopy/v1/generated/validators/usageCharge.zod.js

@@ -42,7 +42,7 @@ export const UsageCharge = zod.strictObject({
     project: zod
         .union([NamedIdentity, zod.null()])
         .optional()
-        .describe("The project and its current name, for display. Absent when the project no longer exists or its\ndetails cannot be read at the moment; `project_id` still identifies it."),
+        .describe("The project and its current name. Absent when the project cannot be read; `project_id` still identifies it."),
     product: Product,
     resource_id: zod
         .string()
@@ -53,20 +53,17 @@ export const UsageCharge = zod.strictObject({
     dimensions: zod
         .record(zod.string(), zod.string())
         .optional()
-        .describe("The attributes the rate was chosen by, such as region and machine type."),
+        .describe("The dimension values the rate was matched by, such as region and machine type."),
     window_start: zod.iso.datetime({ offset: true }),
     window_end: zod.iso.datetime({ offset: true }).describe("Exclusive."),
-    gross_quantity: zod
-        .string()
-        .optional()
-        .describe("How much was used, before any included allowance."),
+    gross_quantity: zod.string().optional().describe("Quantity used before allowances."),
     deducted_quantity: zod
         .string()
         .optional()
         .describe("How much of that was covered by an allowance."),
     quantity: zod
         .string()
-        .describe("What was charged for — the gross quantity less the part covered."),
+        .describe("The quantity charged: gross quantity less the part covered by allowances."),
     unit_amount: Money.optional(),
     amount: Money,
     currency: zod.string(),