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

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

@@ -53,11 +53,9 @@ export const InvoiceItem = zod.strictObject({
     project: zod
         .union([NamedIdentity, zod.null()])
         .optional()
-        .describe("The project the charge was for and its current name, for display. Absent when the line is\nnot for a project, and when the project no longer exists or its details cannot be read at\nthe moment; `project_id` still identifies it then."),
+        .describe("The project the charge was for and its current name. Absent when the line has no project or the project cannot be read; `project_id` still identifies it."),
     resource_id: zod.string().optional(),
-    description: zod
-        .string()
-        .describe("The wording as recorded when the invoice was issued. It is not re-translated\nafterwards, so that an invoice continues to read as it did when it was sent."),
+    description: zod.string().describe("The line's wording as recorded when the invoice was issued."),
     unit: zod.string().optional(),
     quantity: zod.string().optional(),
     deducted_quantity: zod
@@ -69,6 +67,10 @@ export const InvoiceItem = zod.strictObject({
     currency: zod.string(),
     period_start: zod.iso.datetime({ offset: true }).nullish(),
     period_end: zod.iso.datetime({ offset: true }).nullish(),
+    dimensions: zod
+        .record(zod.string(), zod.string())
+        .optional()
+        .describe("For a usage line, the values of its meter's presentation dimensions, such as the model and token kind. Empty for other lines."),
     prorations: zod
         .array(InvoiceItemProration)
         .optional()

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

@@ -62,6 +62,7 @@ export declare const InvoiceItemList: zod.ZodObject<{
         currency: zod.ZodString;
         period_start: zod.ZodOptional<zod.ZodNullable<zod.z.ZodISODateTime>>;
         period_end: zod.ZodOptional<zod.ZodNullable<zod.z.ZodISODateTime>>;
+        dimensions: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodString>>;
         prorations: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
             credited_invoice_item_id: zod.ZodUUID;
             description: zod.ZodString;

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

@@ -37,9 +37,7 @@ export const InvoiceItemProration = zod
     credited_invoice_item_id: zod
         .uuid()
         .describe("The earlier invoice line that paid for the period."),
-    description: zod
-        .string()
-        .describe("The wording of the earlier invoice line as recorded when this invoice was created."),
+    description: zod.string().describe("The earlier invoice line's wording as recorded."),
     period_start: zod.iso.datetime({ offset: true }),
     period_end: zod.iso.datetime({ offset: true }).describe("Exclusive."),
     remaining_amount: Money.describe("Before tax and discounts, the new configuration for the period."),

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

@@ -56,7 +56,6 @@ export declare const InvoiceList: zod.ZodObject<{
             open: "open";
             draft: "draft";
             paid: "paid";
-            uncollectible: "uncollectible";
         }>;
         subtotal: zod.ZodOptional<zod.ZodString>;
         discount_amount: zod.ZodOptional<zod.ZodString>;

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

@@ -36,7 +36,6 @@ export declare const InvoiceStatus: zod.ZodEnum<{
     open: "open";
     draft: "draft";
     paid: "paid";
-    uncollectible: "uncollectible";
 }>;
 export type InvoiceStatus = zod.input<typeof InvoiceStatus>;
 export type InvoiceStatusOutput = zod.output<typeof InvoiceStatus>;

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

@@ -32,5 +32,5 @@
  */
 import * as zod from "zod";
 export const InvoiceStatus = zod
-    .enum(["draft", "open", "paid", "void", "uncollectible"])
-    .describe("A draft is not yet issued. The draft invoice of an order shows base prices until it is paid, when\nthe discount is applied and it is issued; other drafts are private to administrators.\nAn issued invoice is open until settled; a zero-total issued invoice is immediately paid.\nUnbilled usage remains separate from invoices until it is invoiced.\nA refund does not change the status: a paid invoice stays paid, with the refunded part in\namount_refunded. void means collection has stopped and any funds received have been returned.");
+    .enum(["draft", "open", "paid", "void"])
+    .describe("`draft`: not yet issued; an order's draft invoice shows base prices until it is paid, when the discount is applied and it is issued. Other drafts are visible only to operators. `open`: issued and not yet settled; a zero-total invoice is paid at once. `paid` stays paid after a refund, with the refunded part in amount_refunded. `void`: collection has stopped and any funds received have been returned. Usage not yet invoiced is not on any invoice.");

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

@@ -41,7 +41,6 @@ export declare const InvoiceSummary: zod.ZodObject<{
         open: "open";
         draft: "draft";
         paid: "paid";
-        uncollectible: "uncollectible";
     }>;
     subtotal: zod.ZodString;
     discount_amount: zod.ZodString;

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

@@ -47,8 +47,8 @@ export const InvoiceSummary = zod
     tax_amount: zod.string(),
     total: zod.string(),
     amount_paid: zod.string(),
-    pre_payment_credit_notes_amount: Money.describe("Issued, non-void credit notes that reduced unpaid receivables. Does not rewrite the original invoice total."),
-    post_payment_credit_notes_amount: Money.describe("Issued credit notes against payments already received. This is a return obligation, not evidence of completed refunds."),
+    pre_payment_credit_notes_amount: Money.describe("Issued credit notes that reduced unpaid receivables; the original invoice total is unchanged."),
+    post_payment_credit_notes_amount: Money.describe("Issued credit notes against payments already received; their refunds may not have completed."),
     amount_due: zod
         .string()
         .regex(invoiceSummaryAmountDueRegExp)
@@ -56,4 +56,4 @@ export const InvoiceSummary = zod
     amount_refunded: zod.string(),
     due_at: zod.iso.datetime({ offset: true }).optional(),
 })
-    .describe("Purchase-related invoice amounts, without account contact details or payment methods. Every order\nhas an invoice from placement. A draft shows base prices until it is paid, when the discount is\napplied and it is issued; a zero-total invoice is issued and paid at placement whatever the\ncheckout mode. Neither establishes acceptance or delivery.");
+    .describe("An order's invoice amounts, without contact details or payment methods. A draft shows base prices until it is paid, when the discount is applied and it is issued; a zero-total invoice is issued and paid at placement.");

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

@@ -41,7 +41,7 @@ export const MonthlyStatement = zod
     period_end: zod.iso.datetime({ offset: true }),
     finalized: zod
         .boolean()
-        .describe("True after the period's final closing, which applies minimum charges for the whole month. Usage priced later is still billed in supplement statements and added here."),
+        .describe("True after the period's final closing, which applies the month's minimum charges. Usage priced later is billed in supplement statements and added here."),
     finalized_at: zod.iso.datetime({ offset: true }).optional(),
     statement_count: zod.int().describe("Statements of the period, including the open one."),
     billed: StatementAmounts,
@@ -52,4 +52,4 @@ export const MonthlyStatement = zod
     amount_due: Money,
     amount_refunded: Money,
 })
-    .describe("One billing account's usage billing for one UTC calendar month, summed over the month's statements. It is a summary, not something to pay; each closing's invoice is collected on its own.");
+    .describe("One billing account's usage billing for one UTC calendar month, summed over its statements. Not payable itself; each statement's invoice is collected on its own.");

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

@@ -37,4 +37,4 @@ export const ObjectIdentity = zod
     id: zod.uuid(),
     name: zod.string(),
 })
-    .describe("A catalog object inlined for display.");
+    .describe("A catalog object, inlined for display.");

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

@@ -50,7 +50,6 @@ export declare const Order: zod.ZodObject<{
             open: "open";
             draft: "draft";
             paid: "paid";
-            uncollectible: "uncollectible";
         }>;
         subtotal: zod.ZodString;
         discount_amount: zod.ZodString;
@@ -130,11 +129,15 @@ export declare const Order: zod.ZodObject<{
         refund_hourly_amount: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
         recurring_amount: zod.ZodOptional<zod.ZodString>;
         setup_amount: zod.ZodOptional<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>;
         tax_amount: zod.ZodOptional<zod.ZodString>;
         tax_included_amount: zod.ZodOptional<zod.ZodString>;
         id: zod.ZodUUID;

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

@@ -46,7 +46,7 @@ export const Order = zod
     promotion_code: zod
         .string()
         .optional()
-        .describe("Code text frozen when the coupon was applied. Absent for an account discount."),
+        .describe("The promotion code applied. Absent for an account discount."),
     invoice_id: zod.uuid().describe("The order's invoice, the same as invoice.id."),
     invoice: InvoiceSummary,
     paid_with: PaidWith.optional().describe("How the order was paid. Absent until it is paid."),
@@ -56,35 +56,33 @@ export const Order = zod
     project_id: zod
         .uuid()
         .nullish()
-        .describe("Which project it was bought for. Absent for a purchase made at account level, such\nas a membership."),
+        .describe("The project it was bought 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."),
     billing_account_id: zod
         .int()
         .optional()
-        .describe("The billing account the order was placed with. It does not change when the project is later\nlinked to another billing account. While this account is suspended or closed the order cannot\nbe accepted, and the invoice of a change scheduled for the end of a period is not issued and the change is called off\nwhen the current period ends; such requests fail with BILLING_ACCOUNT_UNAVAILABLE."),
+        .describe("The billing account the order was placed with, unchanged when the project is later linked to another account. While it is suspended or closed, the order cannot be accepted, and a period-end change's invoice is not issued and the change is called off when the current period ends; such requests fail with `BILLING_ACCOUNT_UNAVAILABLE`."),
     currency: zod.string(),
     type: zod
         .enum(["new", "renew", "modify"])
-        .describe("`new` buys, `renew` extends a prepaid subscription, `modify` changes a subscription's configuration or billing terms."),
+        .describe("`new` buys, `renew` extends a licensed subscription, `modify` changes a subscription's configuration or billing terms."),
     status: OrderStatus,
     change_effective: zod
         .enum(["none", "immediate", "period_end"])
         .optional()
-        .describe("When a plan change takes effect. `none` on anything that is not a change.\n\n`period_end` orders stay pending until the first period at the new price is paid. That period\nis invoiced shortly before the current paid period ends and starts when it ends; if the\ninvoice is still unpaid by then, the order is canceled and the subscription renews or ends as\nusual. Renewing in the meantime moves all of this along with it."),
+        .describe("When a plan change takes effect; `none` for anything that is not a change. A `period_end` order stays pending until the first period at the new price is paid. That period is invoiced shortly before the current paid period ends and starts when it ends; if the invoice is unpaid by then, the order is canceled and the subscription renews or ends as usual. A renewal in the meantime moves the change to the end of the renewed period."),
     expires_at: zod.iso
         .datetime({ offset: true })
         .nullish()
-        .describe("Acceptance deadline. Pending orders can expire automatically."),
+        .describe("Acceptance deadline; a pending order expires after it."),
     checkout_confirmed_at: zod.iso
         .datetime({ offset: true })
         .nullish()
-        .describe("When the discount and amount were fixed: at placement for automatic checkout and for a\nzero total, otherwise when the invoice was first paid. Null while a deferred order awaits payment."),
+        .describe("When the discount and amount were fixed: at placement for automatic checkout or a zero total, otherwise when the invoice was first paid. Null while a deferred order awaits payment."),
     created_at: zod.iso.datetime({ offset: true }),
-    items: zod
-        .array(OrderItem)
-        .describe("What was bought. Present on a single order and on every order in a list, so a list\ncan be rendered without a further request per row."),
+    items: zod.array(OrderItem).describe("What was bought."),
 })
-    .describe("A recorded purchase with its invoice from placement; a zero-total invoice, such as for postpaid\nadmission, is issued and paid at placement whatever the checkout mode. Until checkout_confirmed_at is set, the\ninvoice is a draft at base prices: paying it fixes the discount and amount, issues it and collects it, and the\norder cannot be accepted before then. Coupon fields describe the discount fixed at that point and are absent\nbefore it; a quote never populates them. Payment and acceptance remain separate from resource delivery.");
+    .describe("A recorded purchase with its invoice from placement; a zero-total invoice, such as for a metered purchase, is issued and paid at placement in either checkout mode. Until checkout_confirmed_at is set, the invoice is a draft at base prices: paying it fixes the discount and amount, issues it and collects it, and the order cannot be accepted before then. Coupon fields describe the discount fixed then and are absent before. Payment and acceptance do not mean the resources were delivered.");

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

@@ -57,11 +57,15 @@ export declare const OrderItem: zod.ZodObject<{
     refund_hourly_amount: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
     recurring_amount: zod.ZodOptional<zod.ZodString>;
     setup_amount: zod.ZodOptional<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>;
     tax_amount: zod.ZodOptional<zod.ZodString>;
     tax_included_amount: zod.ZodOptional<zod.ZodString>;
     id: zod.ZodUUID;

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

@@ -33,10 +33,12 @@
 import * as zod from "zod";
 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
     .strictObject({
@@ -53,7 +55,7 @@ export const OrderItem = zod
     subscription_id: zod
         .uuid()
         .optional()
-        .describe("Stable Billing subscription ID. A new prepaid or postpaid service purchase returns the\npending subscription here; renewals and changes reference the existing subscription, which\nkeeps its ID. Absent for delivery without a subscription. This is not a business resource ID."),
+        .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(),
@@ -61,16 +63,18 @@ export const OrderItem = zod
     refund_monthly_amount: zod
         .string()
         .nullish()
-        .describe("Prepaid items only: the plan's one-month prepaid price for this item's quantity before tax, frozen\nat purchase, used to value time used under a prorated refund or a downgrade. Null when the plan has\nno prepaid period shorter than the one bought."),
+        .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
         .string()
         .nullish()
-        .describe("Prepaid items only: the plan's postpaid hourly price for this item's quantity before tax, frozen at\npurchase, used for time used short of a full month. Null when the plan has no postpaid price."),
+        .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."),
     recurring_amount: zod.string().optional(),
     setup_amount: zod.string().optional(),
-    charge_type: zod
-        .enum(["postpaid", "prepaid", "one_time"])
-        .describe("The payment timing of the selected price."),
+    type: PriceType,
+    usage_type: UsageType,
+    dimensions: zod
+        .record(zod.string(), zod.string())
+        .describe("The dimension values the line was bought with, such as region and instance type. Empty when the purchase gave none."),
     tax_amount: zod
         .string()
         .optional()
@@ -85,23 +89,21 @@ export const OrderItem = zod
     product_id: ProductID.optional(),
     product: Product.optional(),
     plan_id: zod.uuid().describe("Which plan was bought."),
-    plan_name: zod
-        .string()
-        .describe("What it was called when bought. It does not follow later catalogue renames and is\nnot translated."),
+    plan_name: zod.string().describe("The name when bought."),
     quantity: zod.string(),
-    unit_amount: Money.optional().describe("The unit amount of the price this line is charged under. Absent for a tiered price, which has no\nsingle unit amount, and for a change that takes effect at once, which is charged as `gross_amount`\ndescribes."),
-    gross_amount: Money.optional().describe("Before discounts: the price applied to the quantity, which for a per-unit price is `unit_amount`\ntimes `quantity`; a minimum charge can make it higher. For an upgrade that takes effect at once it is\nthe new price for the time left in the paid period, at the subscription's own period price, minus\nthe amount paid for that time, and the period end does not move; a downgrade charges nothing and may refund the\ndifference instead. A change between equal period prices charges and refunds nothing. The setup fee is not part of it; see `setup_amount`.\n\nUnder an inclusive tax rate it includes tax, as the price does, and the included part is\n`tax_included_amount`. A renewal at the agreed terms is the exception: the agreed amount excludes\ntax, and tax is added to it."),
-    discount_amount: Money.optional().describe("The reduction on this line: from the coupon the order uses and, for a renewal at the agreed terms,\nfrom the discount the subscription carries.\n\nA carried discount is part of the agreed amount. It is listed here, and `gross_amount` is then\n`unit_amount` times `quantity`, except in two cases where `gross_amount` is the agreed amount and\nthe carried discount is already reflected in it: the renewal order also uses a coupon the account\nholds, or the account's tax rate is inclusive."),
+    unit_amount: Money.optional().describe("The unit amount of the price the line is charged under. Absent for a tiered price, and for an immediate change, which is charged as `gross_amount` describes."),
+    gross_amount: Money.optional().describe("Before discounts and setup fees: the price applied to the quantity, `unit_amount` times `quantity` for a per-\nunit price, raised by any minimum charge. For an immediate upgrade it is the new price for the rest of the\npaid period minus the amount paid for that time; a downgrade, or a change between equal period prices, charges\nnothing.\n\nUnder an inclusive tax rate it includes tax, shown in `tax_included_amount`, except for a renewal at agreed\nterms, whose amount excludes tax."),
+    discount_amount: Money.optional().describe("The reduction on this line, from the order's coupon and, for a renewal at agreed terms, from the subscription's carried discount. With a carried discount, `gross_amount` is `unit_amount` times `quantity`, except when the renewal order also uses an account coupon or the tax rate is inclusive: then `gross_amount` is the agreed amount, which already reflects the carried discount."),
     amount: Money.optional().describe("`gross_amount` less `discount_amount`."),
     currency: zod.string(),
     period_start: zod.iso
         .datetime({ offset: true })
         .nullish()
-        .describe("The start of the service period this line paid for. Frozen at placement for renewals and period-end changes; for a prepaid line of a new purchase, fixed from the second its invoice is paid and kept when delivery is confirmed. Absent for postpaid and one-time lines."),
+        .describe("The start of the service period this line paid for. Fixed at placement for renewals and period-end changes, and for a licensed line of a new purchase when its invoice is paid. Absent for metered and one-time lines."),
     period_end: zod.iso
         .datetime({ offset: true })
         .nullish()
         .describe("The end of that service period, exclusive."),
     status: OrderItemStatus,
 })
-    .describe("Frozen purchase terms. Monetary fields come from related invoice-line snapshots and are zero\nfor a line with no immediate charge, such as postpaid admission. Later catalog changes do not reprice this line. A new service\npurchase creates its pending subscription when this item is recorded, not when payment succeeds.");
+    .describe("The purchase terms frozen at placement. Monetary fields come from the order's invoice lines and are zero without an immediate charge, such as for a metered purchase. Later catalog changes do not reprice the line. A new service purchase has its pending subscription from placement.");

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

@@ -57,11 +57,15 @@ export declare const OrderItemList: zod.ZodObject<{
         refund_hourly_amount: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
         recurring_amount: zod.ZodOptional<zod.ZodString>;
         setup_amount: zod.ZodOptional<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>;
         tax_amount: zod.ZodOptional<zod.ZodString>;
         tax_included_amount: zod.ZodOptional<zod.ZodString>;
         id: zod.ZodUUID;

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

@@ -33,4 +33,4 @@
 import * as zod from "zod";
 export const OrderItemStatus = zod
     .enum(["pending", "completed", "failed", "canceled"])
-    .describe("`pending` is waiting to be set up. `completed` was confirmed by the service.\n`failed` was not set up and its amount was refunded to the original payment sources.\n`canceled` was confirmed withdrawn without delivery; any collected amount is returned. A completed item is ended by canceling\nits subscription.");
+    .describe("`pending`: waiting to be set up. `completed`: set up, as confirmed by the service. `failed`: not set up; its amount was refunded to the original payment sources. `canceled`: withdrawn without delivery; any collected amount is returned. A completed item ends when its subscription is canceled.");

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

@@ -51,7 +51,6 @@ export declare const OrderList: zod.ZodObject<{
                 open: "open";
                 draft: "draft";
                 paid: "paid";
-                uncollectible: "uncollectible";
             }>;
             subtotal: zod.ZodString;
             discount_amount: zod.ZodString;
@@ -131,11 +130,15 @@ export declare const OrderList: zod.ZodObject<{
             refund_hourly_amount: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
             recurring_amount: zod.ZodOptional<zod.ZodString>;
             setup_amount: zod.ZodOptional<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>;
             tax_amount: zod.ZodOptional<zod.ZodString>;
             tax_included_amount: zod.ZodOptional<zod.ZodString>;
             id: zod.ZodUUID;

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

@@ -40,4 +40,4 @@ export const OrderRefundQuote = zod
     credit_amount: Money,
     currency: zod.string(),
 })
-    .describe("An estimated refund to original payment sources. Before acceptance, cancellation returns the\ncollected amount. For delivered service, only value funded by this order is included; renewals\nare evaluated under their own orders and the agreed termination terms apply. An unknown\ndelivery outcome is not evidence that a refund is eligible. This calculation does not create\na refund; the amount returned is determined 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 termination terms. Nothing is refunded by the quote; the amount is fixed when cancellation or termination is confirmed.");

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

@@ -42,4 +42,4 @@ export const OrderRefundQuoteInput = zod
         .optional()
         .describe("Estimate only these items. Omit to estimate the whole order. Every item must belong to the order."),
 })
-    .describe("An estimate of the refundable value of one order or selected items. This does not cancel the order, stop service or create a refund.");
+    .describe("An estimate of the refundable value of an order or selected items; nothing is canceled or refunded.");

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

@@ -33,4 +33,4 @@
 import * as zod from "zod";
 export const OrderStatus = zod
     .enum(["pending", "accepted", "completed", "partially_completed", "failed", "canceled"])
-    .describe("Follows the items. `pending` is not yet accepted and may be unpaid or paid; its invoice shows\nwhether payment is still needed, and it can expire or be canceled. `accepted` is accepted with items still\nbeing set up. `completed` means every item was set up. `partially_completed` means some items were set up\nand the others failed or were canceled and were refunded to their original payment sources. `failed` means\nno item was delivered and at least one failed; collected amounts for the undelivered items are refunded.\n`canceled` means every item was withdrawn without delivery; collected amounts are returned to their original\npayment sources. No status establishes service delivery by itself.");
+    .describe("Follows the items. `pending`: not yet accepted, paid or unpaid; its invoice shows whether payment is needed, and it can expire or be canceled. `accepted`: items are being set up. `completed`: every item was set up. `partially_completed`: some items were set up and the others failed or were canceled and refunded to their original payment sources. `failed`: no item was delivered and at least one failed; amounts collected for undelivered items are refunded. `canceled`: every item was withdrawn without delivery; collected amounts are returned to their original payment sources. No status by itself means the service was delivered.");

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

@@ -47,4 +47,4 @@ export const PaidWith = zod
     brand: zod.string().optional(),
     last4: zod.string().optional(),
 })
-    .describe("How it was paid. Removing the payment method afterwards does not change it; `payment_method_id`\nthen names a removed payment method.");
+    .describe("How it was paid. `payment_method_id` still names the payment method after it is removed.");

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

@@ -45,7 +45,7 @@ export const PayInvoiceRequest = zod
         .min(1)
         .max(payInvoiceRequestPaymentGatewayMax)
         .optional()
-        .describe("Required to collect an online remainder. An existing attempt keeps its original gateway."),
+        .describe("Required to collect an online remainder. An existing attempt keeps its gateway."),
     method_type: zod
         .string()
         .min(1)
@@ -55,24 +55,24 @@ export const PayInvoiceRequest = zod
     payment_method_id: zod
         .uuid()
         .optional()
-        .describe("Optional saved card owned by this billing account and belonging to the selected gateway. Omit to complete payment interactively."),
+        .describe("A saved card of this billing account at the selected gateway. Omit to pay interactively."),
     use_balance: zod
         .boolean()
         .default(payInvoiceRequestUseBalanceDefault)
-        .describe("Whether to apply the available balance. Credit grants are controlled separately by use_credits."),
+        .describe("Whether to apply the balance; credit grants are controlled by use_credits."),
     use_credits: zod
         .boolean()
         .default(payInvoiceRequestUseCreditsDefault)
-        .describe("Apply eligible, unexpired credit grants before using the balance. This never withdraws grants or converts them into balance."),
+        .describe("Apply eligible, unexpired credit grants before the balance. Grants are never converted into balance."),
     return_url: zod.string().optional(),
     promotion_code: zod
         .string()
         .min(1)
         .max(payInvoiceRequestPromotionCodeMax)
         .optional()
-        .describe("The code to apply while the order's terms are not yet fixed. Omit to apply the best applicable\naccount discount, or to keep the discount already recorded."),
+        .describe("The code to apply while the order's terms are not fixed. Omit to apply the best applicable account discount, or to keep the discount already recorded."),
     expected_amount: Money.and(zod.string().regex(payInvoiceRequestExpectedAmountTwoRegExp))
         .optional()
-        .describe("The invoice total to expect, after discounts and tax and before credit grants or balance, as the\npayment preview or an order quote gave it. A different total fails with BILLING_AMOUNT_CHANGED\nand nothing is charged. Omit to skip the comparison; an explicit zero is compared."),
+        .describe("The invoice total to expect, after discounts and tax and before credit grants or balance, as the payment preview or an order quote gave it. A different total fails with `BILLING_AMOUNT_CHANGED` and nothing is charged. Omit to skip the check; zero is checked."),
 })
     .describe("Applies eligible credit grants and the available balance as requested, then collects only the remainder\nthrough the selected gateway. Grants restricted to other purchases are not counted as available funds.\nAn unresolved channel payment is reused; retries do not apply the grant or balance portions twice.\nWithout a gateway selection, insufficient account funds fail without starting an online payment.\n\n`payment_gateway` and `method_type` are given together, and `payment_method_id` only with both;\notherwise the request is refused with `BILLING_PURCHASE_INVALID`.");

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

@@ -41,6 +41,6 @@ export const PayTogetherRequest = zod
     order_ids: zod.array(zod.uuid()).max(payTogetherRequestOrderIdsMax).optional(),
     expected_amount: Money.and(zod.string().regex(payTogetherRequestExpectedAmountTwoRegExp))
         .optional()
-        .describe("The amount due to expect across all of them, before credit grants or balance, as preview-pay-together\ngave it. A different amount fails with BILLING_AMOUNT_CHANGED and nothing is charged. Omit to skip\nthe comparison."),
+        .describe("The amount due across all invoices, before credit grants or balance, as preview-pay-together gave it. A different amount fails with `BILLING_AMOUNT_CHANGED` and nothing is charged. Omit to skip the check."),
 })
-    .describe("Name at least one invoice or order. They must all belong to the same account and share\nits currency; anything else is refused rather than partly paid.");
+    .describe("Name at least one invoice or order. All must belong to one account in its currency.");

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

@@ -37,13 +37,13 @@ export const PaymentAction = zod
     provider: zod
         .string()
         .optional()
-        .describe("Identifies the browser adapter for an SDK action, for example stripe."),
+        .describe("The browser adapter for the action, for example stripe."),
     url: zod.url().optional(),
-    qr_code: zod.string().optional().describe("QR content to render and scan, not an image URL."),
+    qr_code: zod.string().optional().describe("QR content to render, not an image URL."),
     client_secret: zod
         .string()
         .optional()
-        .describe("Short-lived client credential for this payment's browser confirmation."),
+        .describe("Short-lived client credential for confirming this payment in the browser."),
     public_key: zod.string().optional(),
 })
-    .describe("The customer's next interaction. The gateway reports the actual payment outcome separately.");
+    .describe("The customer's next step; the payment outcome is reported separately.");

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

@@ -33,4 +33,4 @@
 import * as zod from "zod";
 export const PaymentCancellationReason = zod
     .enum(["abandoned", "requested_by_customer"])
-    .describe("Why a gateway payment was withdrawn. `abandoned` means the customer did not complete it within the time\nallowed for payment. `requested_by_customer` means the customer canceled it.");
+    .describe("Why a gateway payment was withdrawn: `abandoned` when the customer did not complete it in time, `requested_by_customer` when the customer canceled it.");

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

@@ -34,10 +34,8 @@ import * as zod from "zod";
 import { PaymentAction } from "./paymentAction.zod.js";
 export const PaymentMethodSetupResult = zod
     .strictObject({
-    setup_id: zod
-        .string()
-        .describe("The gateway's identifier for this attempt. Use it to tell a reloaded page apart\nfrom a second attempt."),
+    setup_id: zod.string().describe("The gateway's identifier for this attempt."),
     payment_gateway: zod.string(),
     action: PaymentAction,
 })
-    .describe("What the payment gateway's browser library needs in order to collect a card. There is\nno address to redirect to: the form is rendered in the page, and the card goes straight\nfrom the browser to the gateway.");
+    .describe("What the payment gateway's browser library needs to collect a card in the page; the card goes from the browser straight to the gateway.");

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

@@ -37,4 +37,4 @@ export const PaymentOption = zod
     payment_gateway: zod.string().describe("The value to send as `payment_gateway`."),
     methods: zod.array(PaymentOptionMethod),
 })
-    .describe("A payment gateway that accepts payment in the account's currency, with the methods it accepts.");
+    .describe("A gateway accepting the account's currency, with its payment methods.");

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

@@ -37,5 +37,5 @@ export const PaymentOptionMethod = zod.strictObject({
         .describe("The value to send as `method_type`, such as card, wechat_pay or alipay."),
     reusable: zod
         .boolean()
-        .describe("Whether a method of this type can be saved with create-payment-method-setup and charged later\nwithout the customer present. Methods that are not reusable are paid anew each time."),
+        .describe("Whether this method type can be saved with create-payment-method-setup and charged later without the customer."),
 });

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

@@ -43,13 +43,13 @@ export const PaymentPreview = zod
     credit_applied: Money.describe("What credit grants would pay. Grants restricted to other purchases pay nothing here."),
     credit_grants: zod
         .array(AppliedCredit)
-        .describe("The credit grants that would pay, in the order they would be used."),
+        .describe("The credit grants that would pay, in the order used."),
     balance_applied: Money.describe("What the balance would pay."),
-    gateway_amount: Money.describe("What would remain to be paid online. Paying without a gateway is refused with `BILLING_INSUFFICIENT_FUNDS` while this is above zero."),
+    gateway_amount: Money.describe("What would remain to pay online. Paying without a gateway is refused with `BILLING_INSUFFICIENT_FUNDS` while this is above zero."),
     balance_after: Money.describe("The available balance after paying."),
     invoices: zod
         .array(PaymentPreviewInvoice)
         .optional()
-        .describe("Paying together only. Each invoice, in the order it would be paid."),
+        .describe("Paying together only: each invoice, in payment order."),
 })
-    .describe("What paying would take, computed as paying computes it. Nothing is charged or reserved.");
+    .describe("What paying would take, calculated as paying does. Nothing is charged or reserved.");

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

@@ -37,28 +37,25 @@ import { PaymentStatus } from "./paymentStatus.zod.js";
 import { Transaction } from "./transaction.zod.js";
 export const PaymentResult = zod.strictObject({
     transactions: zod.array(Transaction),
-    transaction_id: zod
-        .uuid()
-        .optional()
-        .describe("The gateway transaction, when one is involved. Balance and credit-grant payments are separate transactions."),
+    transaction_id: zod.uuid().optional().describe("The gateway transaction, when one is involved."),
     status: PaymentStatus,
     amount_paid: Money,
-    amount_due: Money.describe("What is still outstanding. Zero once the payment succeeds. Unchanged while\n`processing`: nothing is collected until the gateway confirms it."),
+    amount_due: Money.describe("What is still outstanding: zero once the payment succeeds, unchanged while `processing`."),
     currency: zod.string(),
     credit_applied: Money.optional(),
     gateway_amount: Money.optional(),
     payment_gateway: zod.string().optional(),
     method_type: zod.string().optional(),
-    balance_applied: Money.optional().describe("The amount already paid from the account's balance toward this invoice. Retrying an online remainder\ndoes not debit it again. A canceled purchase returns funds through its refund process."),
+    balance_applied: Money.optional().describe("The amount already paid from balance toward this invoice; retrying the online remainder does not debit it again."),
     action: PaymentAction.optional(),
     retriable: zod
         .boolean()
         .optional()
-        .describe("Whether paying again is worth attempting. False for a refusal that will keep\nhappening — a closed account, an amount over a limit — so that a client does not\nretry in a loop."),
+        .describe("Whether paying again can succeed. False for a refusal that will repeat, such as a closed account or an amount over a limit."),
     invoice_id: zod.uuid().nullish(),
     order_id: zod.uuid().nullish(),
     failure_reason: zod
         .string()
         .optional()
-        .describe("Why the payment did not go through. Present with `failed`. For a declined gateway payment the\nvalue is the gateway's own code, passed on unchanged: the card issuer's decline code when\nthere is one (Stripe's decline_code, such as insufficient_funds or lost_card), otherwise the\ngateway's error 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 the payment 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."),
 });

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

@@ -33,4 +33,4 @@
 import * as zod from "zod";
 export const PaymentStatus = zod
     .enum(["succeeded", "processing", "requires_action", "failed"])
-    .describe("The current payment outcome.\n\nsucceeded means payment is complete. processing means confirmation is pending; poll the invoice or\norder rather than submitting another payment. requires_action means the customer must complete the\nsupplied action. failed means the attempt did not succeed and failure_reason explains the outcome; a\ndeclined gateway payment is withdrawn at the gateway, and paying again starts a new payment with the\nsame or another method.");
+    .describe("`succeeded`: paid. `processing`: confirmation is pending; poll the invoice or order instead of paying again. `requires_action`: the customer must complete the returned action. `failed`: the attempt did not succeed, for the reason in failure_reason; a declined gateway payment is withdrawn, and paying again starts a new payment.");

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

@@ -43,7 +43,6 @@ export declare const PlacedOrder: zod.ZodObject<{
             open: "open";
             draft: "draft";
             paid: "paid";
-            uncollectible: "uncollectible";
         }>;
         subtotal: zod.ZodString;
         discount_amount: zod.ZodString;