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

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

@@ -19,5 +19,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/membership/v1/generated/validators/scheduledChange.zod.js

@@ -18,9 +18,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/membership/v1/generated/validators/spendRow.zod.d.ts

@@ -15,6 +15,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/membership/v1/generated/validators/spendRow.zod.js

@@ -7,12 +7,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/membership/v1/generated/validators/spendRowList.zod.d.ts

@@ -16,6 +16,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/membership/v1/generated/validators/spendRowList.zod.js

@@ -11,7 +11,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/membership/v1/generated/validators/statement.zod.js

@@ -22,7 +22,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
@@ -33,4 +33,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/membership/v1/generated/validators/statementItem.zod.d.ts

@@ -11,6 +11,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/membership/v1/generated/validators/statementItem.zod.js

@@ -12,6 +12,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/membership/v1/generated/validators/statementSummary.zod.d.ts

@@ -21,6 +21,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/membership/v1/generated/validators/statementType.zod.js

@@ -8,4 +8,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/membership/v1/generated/validators/subscription.zod.d.ts

@@ -10,11 +10,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/membership/v1/generated/validators/subscription.zod.js

@@ -9,6 +9,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";
@@ -16,6 +17,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({
@@ -24,13 +26,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(),
@@ -43,17 +49,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
@@ -64,11 +70,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(),
@@ -77,25 +83,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/membership/v1/generated/validators/subscriptionCancellation.zod.js

@@ -12,7 +12,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"]),
@@ -27,4 +27,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/membership/v1/generated/validators/subscriptionList.zod.d.ts

@@ -10,11 +10,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/membership/v1/generated/validators/subscriptionRestriction.zod.js

@@ -14,4 +14,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/membership/v1/generated/validators/terminationPolicy.zod.js

@@ -8,4 +8,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/membership/v1/generated/validators/tier.zod.js

@@ -11,7 +11,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/membership/v1/generated/validators/topUp.zod.js

@@ -15,12 +15,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
@@ -30,17 +30,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/membership/v1/generated/validators/topUpCreate.zod.js

@@ -15,7 +15,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)
@@ -23,12 +23,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/membership/v1/generated/validators/transaction.zod.js

@@ -23,26 +23,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/membership/v1/generated/validators/usageCharge.zod.d.ts

@@ -33,6 +33,7 @@ export declare const UsageCharge: zod.ZodObject<{
     deducted_quantity: zod.ZodOptional<zod.ZodString>;
     quantity: zod.ZodString;
     unit_amount: zod.ZodOptional<zod.ZodString>;
+    unit_quantity: zod.ZodOptional<zod.ZodString>;
     amount: zod.ZodString;
     currency: zod.ZodString;
     invoice_id: zod.ZodOptional<zod.ZodNullable<zod.ZodUUID>>;

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

@@ -17,7 +17,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()
@@ -28,21 +28,22 @@ 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(),
+    unit_quantity: zod
+        .string()
+        .optional()
+        .describe("The quantity `unit_amount` prices, such as 1000000 tokens or 3600 seconds: `amount` is `quantity` × `unit_amount` ÷ `unit_quantity`."),
     amount: Money,
     currency: zod.string(),
     invoice_id: zod

package/dist/membership/v1/generated/validators/usageChargeList.zod.d.ts

@@ -34,6 +34,7 @@ export declare const UsageChargeList: zod.ZodObject<{
         deducted_quantity: zod.ZodOptional<zod.ZodString>;
         quantity: zod.ZodString;
         unit_amount: zod.ZodOptional<zod.ZodString>;
+        unit_quantity: zod.ZodOptional<zod.ZodString>;
         amount: zod.ZodString;
         currency: zod.ZodString;
         invoice_id: zod.ZodOptional<zod.ZodNullable<zod.ZodUUID>>;

package/dist/membership/v1/generated/validators/usageType.zod.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Membership API
+ * Membership tiers and account memberships. Catalog queries support any configured currency; purchases use the billing account currency.
+ * OpenAPI spec version: 1.0.0
+ */
+import * as zod from "zod";
+export declare const UsageType: zod.ZodEnum<{
+    licensed: "licensed";
+    metered: "metered";
+}>;
+export type UsageType = zod.input<typeof UsageType>;
+export type UsageTypeOutput = zod.output<typeof UsageType>;

package/dist/membership/v1/generated/validators/usageType.zod.js

@@ -0,0 +1,11 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Membership API
+ * Membership tiers and account memberships. Catalog queries support any configured currency; purchases use the billing account currency.
+ * OpenAPI spec version: 1.0.0
+ */
+import * as zod from "zod";
+export const UsageType = zod
+    .enum(["licensed", "metered"])
+    .describe("`licensed` charges for the quantity bought, each period paid before it starts. `metered` charges for the usage\nreported, after it is settled; a metered subscription lasts until it is canceled. A one-time price is licensed.");

package/dist/membership/v1/generated/validators/withdrawal.zod.js

@@ -38,6 +38,6 @@ export const Withdrawal = zod
     created_by: zod
         .string()
         .optional()
-        .describe("Identity that submitted this withdrawal. It can differ from the billing account owner."),
+        .describe("Who submitted the withdrawal; may differ from the account owner."),
 })
-    .describe("An account withdrawal to the original payment methods of its unused top-ups. Accepted amounts are fixed. deducted_amount, settled_amount and charged_fee_amount report completed source items. Failed items release their principal and fee reservations; successful items are retained when another source fails.");
+    .describe("A withdrawal of account balance to the original payment methods of its unused top-ups. Accepted amounts are fixed. deducted_amount, settled_amount and charged_fee_amount cover completed items. A failed item releases its principal and fee; successful items stand when another item fails.");

package/dist/membership/v1/generated/validators/withdrawalItem.zod.js

@@ -32,6 +32,6 @@ export const WithdrawalItem = zod
     failure_code: zod
         .string()
         .optional()
-        .describe("The original gateway failure code when a refund failed, or refund_reversed when a completed refund was reversed. Absent while pending or successful."),
+        .describe("The gateway's failure code when a refund failed, or `refund_reversed` when a completed refund was reversed. Absent while pending or successful."),
 })
-    .describe("The fixed principal deduction, withdrawal fee and exact refund obligation for one original top-up. Each item has its own refund; payment_gateway and method_type identify the original route.");
+    .describe("For one original top-up: the principal deducted, the withdrawal fee and the amount refunded, through its own refund. payment_gateway and method_type identify the original route.");

package/dist/membership/v1/generated/validators/withdrawalSource.zod.js

@@ -20,4 +20,4 @@ export const WithdrawalSource = zod
     card_brand: zod.string().optional(),
     card_last4: zod.string().regex(withdrawalSourceCardLast4RegExp).optional(),
 })
-    .describe("The original top-up and its refund destination. Card details are included when the original payment method was saved; missing card details do not change the original refund route.");
+    .describe("The original top-up and where its refund goes. Card details are included when the original payment method was saved.");

package/dist/routes.d.ts

@@ -513,7 +513,7 @@ export declare const routes: readonly [{
 }, {
     readonly service: "billing";
     readonly contract: "billing";
-    readonly method: "POST";
+    readonly method: "QUERY";
     readonly path: "/api/v1/withdrawals/preview";
     readonly operationId: "preview-withdrawal";
     readonly securityScheme: "AccessToken";
@@ -745,7 +745,7 @@ export declare const routes: readonly [{
 }, {
     readonly service: "billing";
     readonly contract: "billing";
-    readonly method: "POST";
+    readonly method: "QUERY";
     readonly path: "/api/v1/payments/preview";
     readonly operationId: "preview-pay-together";
     readonly securityScheme: "AccessToken";
@@ -873,9 +873,9 @@ export declare const routes: readonly [{
 }, {
     readonly service: "billing";
     readonly contract: "billing";
-    readonly method: "POST";
+    readonly method: "QUERY";
     readonly path: "/api/v1/quotes";
-    readonly operationId: "create-quote";
+    readonly operationId: "get-quote";
     readonly securityScheme: "AccessToken";
     readonly upstreamUrl: "https://billing.leaflow.cloud";
 }, {