@leaflow/sdk 0.125.0 → 0.126.0

package/dist/billing/type/order/v1/generated/models.d.ts

@@ -2880,7 +2880,16 @@ export declare const StatementStatus: {
     readonly closed: "closed";
 };
 /**
- * An account's consumption for one billing period, collected at one closing. The first statement of a period (sequence 1) closes after the period ends. Usage priced after that closing is collected in a later statement for the same period, which closes and invoices separately; a closed statement is never rewritten. Payments apply to issued invoices.
+ * 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.
+ */
+export type StatementType = (typeof StatementType)[keyof typeof StatementType];
+export declare const StatementType: {
+    readonly interim: "interim";
+    readonly final: "final";
+    readonly supplement: "supplement";
+};
+/**
+ * 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.
  */
 export interface Statement {
     id: string;
@@ -2888,10 +2897,11 @@ export interface Statement {
     currency: string;
     period_start: string;
     period_end: string;
-    /** 1 for the first closing of the period; higher for statements that collect usage priced after an earlier closing. */
+    /** Increases with each closing of the period. */
     sequence: number;
     status: StatementStatus;
-    /** 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 closing, and a tier reduction larger than this statement's own charges is credited to earlier invoices of the period at closing. */
+    type: StatementType;
+    /** 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. */
     estimated: boolean;
     amounts: StatementAmounts;
     closed_at?: string;

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

@@ -352,6 +352,11 @@ export const StatementStatus = {
     open: "open",
     closed: "closed",
 };
+export const StatementType = {
+    interim: "interim",
+    final: "final",
+    supplement: "supplement",
+};
 export const StatementSummaryGroupBy = {
     project: "project",
     product: "product",

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

@@ -17,6 +17,11 @@ export declare const Statement: zod.ZodObject<{
         open: "open";
         closed: "closed";
     }>;
+    type: zod.ZodEnum<{
+        interim: "interim";
+        final: "final";
+        supplement: "supplement";
+    }>;
     estimated: zod.ZodBoolean;
     amounts: zod.ZodObject<{
         subtotal: zod.ZodString;

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

@@ -9,6 +9,7 @@ import * as zod from "zod";
 import { Money } from "./money.zod.js";
 import { StatementAmounts } from "./statementAmounts.zod.js";
 import { StatementStatus } from "./statementStatus.zod.js";
+import { StatementType } from "./statementType.zod.js";
 export const Statement = zod
     .strictObject({
     id: zod.uuid(),
@@ -16,13 +17,12 @@ export const Statement = zod
     currency: zod.string(),
     period_start: zod.iso.datetime({ offset: true }),
     period_end: zod.iso.datetime({ offset: true }),
-    sequence: zod
-        .int()
-        .describe("1 for the first closing of the period; higher for statements that collect usage priced after an earlier closing."),
+    sequence: zod.int().describe("Increases with each closing of the period."),
     status: StatementStatus,
+    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 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 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."),
     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. The first statement of a period (sequence 1) closes after the period ends. Usage priced after that closing is collected in a later statement for the same period, which closes and invoices separately; a closed statement is never rewritten. Payments apply to issued invoices.");
+    .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.");

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

@@ -18,6 +18,11 @@ export declare const StatementList: zod.ZodObject<{
             open: "open";
             closed: "closed";
         }>;
+        type: zod.ZodEnum<{
+            interim: "interim";
+            final: "final";
+            supplement: "supplement";
+        }>;
         estimated: zod.ZodBoolean;
         amounts: zod.ZodObject<{
             subtotal: zod.ZodString;

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

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

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

@@ -0,0 +1,11 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Billing Order Types
+ * The Billing order a product purchase placed. Types only; this document declares no operations.
+ * OpenAPI spec version: v1
+ */
+import * as zod from "zod";
+export const 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.");

package/dist/billing/v1/generated/functions.d.ts

@@ -617,7 +617,10 @@ export declare const getPayInvoiceUrl: (invoiceId: string) => string;
  * payment deadline has passed, with `BILLING_ORDER_EXPIRED`. A renewal invoice is also refused with
  * `BILLING_INVOICE_NOT_PAYABLE` while its subscription is being canceled, is being reclaimed or has
  * ended, with `meta.reason` `subscription_canceling`, `subscription_reclaiming` or
- * `subscription_ended` respectively.
+ * `subscription_ended` respectively. A usage invoice is billed to the smallest fraction a balance can
+ * hold, finer than a payment method can charge, so paying one online is refused with
+ * `BILLING_INVOICE_NOT_PAYABLE` and `meta.reason` `usage_invoice`; it is collected from credit grants
+ * and balance automatically, including right after a top-up.
  * @summary Pay an invoice
  */
 export declare const payInvoice: (invoiceId: string, payInvoiceRequest?: PayInvoiceRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<payInvoiceResponse>;

package/dist/billing/v1/generated/functions.js

@@ -648,7 +648,10 @@ export const getPayInvoiceUrl = (invoiceId) => {
  * payment deadline has passed, with `BILLING_ORDER_EXPIRED`. A renewal invoice is also refused with
  * `BILLING_INVOICE_NOT_PAYABLE` while its subscription is being canceled, is being reclaimed or has
  * ended, with `meta.reason` `subscription_canceling`, `subscription_reclaiming` or
- * `subscription_ended` respectively.
+ * `subscription_ended` respectively. A usage invoice is billed to the smallest fraction a balance can
+ * hold, finer than a payment method can charge, so paying one online is refused with
+ * `BILLING_INVOICE_NOT_PAYABLE` and `meta.reason` `usage_invoice`; it is collected from credit grants
+ * and balance automatically, including right after a top-up.
  * @summary Pay an invoice
  */
 export const payInvoice = async (invoiceId, payInvoiceRequest, options, fetchFn) => {

package/dist/billing/v1/generated/models.d.ts

@@ -2864,7 +2864,16 @@ export declare const StatementStatus: {
     readonly closed: "closed";
 };
 /**
- * An account's consumption for one billing period, collected at one closing. The first statement of a period (sequence 1) closes after the period ends. Usage priced after that closing is collected in a later statement for the same period, which closes and invoices separately; a closed statement is never rewritten. Payments apply to issued invoices.
+ * 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.
+ */
+export type StatementType = (typeof StatementType)[keyof typeof StatementType];
+export declare const StatementType: {
+    readonly interim: "interim";
+    readonly final: "final";
+    readonly supplement: "supplement";
+};
+/**
+ * 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.
  */
 export interface Statement {
     id: string;
@@ -2872,10 +2881,11 @@ export interface Statement {
     currency: string;
     period_start: string;
     period_end: string;
-    /** 1 for the first closing of the period; higher for statements that collect usage priced after an earlier closing. */
+    /** Increases with each closing of the period. */
     sequence: number;
     status: StatementStatus;
-    /** 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 closing, and a tier reduction larger than this statement's own charges is credited to earlier invoices of the period at closing. */
+    type: StatementType;
+    /** 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. */
     estimated: boolean;
     amounts: StatementAmounts;
     closed_at?: string;

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

@@ -352,6 +352,11 @@ export const StatementStatus = {
     open: "open",
     closed: "closed",
 };
+export const StatementType = {
+    interim: "interim",
+    final: "final",
+    supplement: "supplement",
+};
 export const StatementSummaryGroupBy = {
     project: "project",
     product: "product",

package/dist/billing/v1/generated/schemas.zod.d.ts

@@ -344,7 +344,10 @@ export declare const DeletePaymentMethodParams: zod.ZodObject<{
  * payment deadline has passed, with `BILLING_ORDER_EXPIRED`. A renewal invoice is also refused with
  * `BILLING_INVOICE_NOT_PAYABLE` while its subscription is being canceled, is being reclaimed or has
  * ended, with `meta.reason` `subscription_canceling`, `subscription_reclaiming` or
- * `subscription_ended` respectively.
+ * `subscription_ended` respectively. A usage invoice is billed to the smallest fraction a balance can
+ * hold, finer than a payment method can charge, so paying one online is refused with
+ * `BILLING_INVOICE_NOT_PAYABLE` and `meta.reason` `usage_invoice`; it is collected from credit grants
+ * and balance automatically, including right after a top-up.
  * @summary Pay an invoice
  */
 export declare const PayInvoiceParams: zod.ZodObject<{

package/dist/billing/v1/generated/schemas.zod.js

@@ -399,7 +399,10 @@ export const DeletePaymentMethodParams = zod.strictObject({
  * payment deadline has passed, with `BILLING_ORDER_EXPIRED`. A renewal invoice is also refused with
  * `BILLING_INVOICE_NOT_PAYABLE` while its subscription is being canceled, is being reclaimed or has
  * ended, with `meta.reason` `subscription_canceling`, `subscription_reclaiming` or
- * `subscription_ended` respectively.
+ * `subscription_ended` respectively. A usage invoice is billed to the smallest fraction a balance can
+ * hold, finer than a payment method can charge, so paying one online is refused with
+ * `BILLING_INVOICE_NOT_PAYABLE` and `meta.reason` `usage_invoice`; it is collected from credit grants
+ * and balance automatically, including right after a top-up.
  * @summary Pay an invoice
  */
 export const PayInvoiceParams = zod.strictObject({

package/dist/billing/v1/generated/validators/statement.zod.d.ts

@@ -17,6 +17,11 @@ export declare const Statement: zod.ZodObject<{
         open: "open";
         closed: "closed";
     }>;
+    type: zod.ZodEnum<{
+        interim: "interim";
+        final: "final";
+        supplement: "supplement";
+    }>;
     estimated: zod.ZodBoolean;
     amounts: zod.ZodObject<{
         subtotal: zod.ZodString;

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

@@ -9,6 +9,7 @@ import * as zod from "zod";
 import { Money } from "./money.zod.js";
 import { StatementAmounts } from "./statementAmounts.zod.js";
 import { StatementStatus } from "./statementStatus.zod.js";
+import { StatementType } from "./statementType.zod.js";
 export const Statement = zod
     .strictObject({
     id: zod.uuid(),
@@ -16,13 +17,12 @@ export const Statement = zod
     currency: zod.string(),
     period_start: zod.iso.datetime({ offset: true }),
     period_end: zod.iso.datetime({ offset: true }),
-    sequence: zod
-        .int()
-        .describe("1 for the first closing of the period; higher for statements that collect usage priced after an earlier closing."),
+    sequence: zod.int().describe("Increases with each closing of the period."),
     status: StatementStatus,
+    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 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 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."),
     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. The first statement of a period (sequence 1) closes after the period ends. Usage priced after that closing is collected in a later statement for the same period, which closes and invoices separately; a closed statement is never rewritten. Payments apply to issued invoices.");
+    .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.");

package/dist/billing/v1/generated/validators/statementList.zod.d.ts

@@ -18,6 +18,11 @@ export declare const StatementList: zod.ZodObject<{
             open: "open";
             closed: "closed";
         }>;
+        type: zod.ZodEnum<{
+            interim: "interim";
+            final: "final";
+            supplement: "supplement";
+        }>;
         estimated: zod.ZodBoolean;
         amounts: zod.ZodObject<{
             subtotal: zod.ZodString;

package/dist/billing/v1/generated/validators/statementType.zod.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Billing API
+ * Products, prices, orders, subscriptions and account billing. Financial operations require an account access token and billing-account authorization. Public catalogue operations declare no security requirement.
+ * OpenAPI spec version: v1
+ */
+import * as zod from "zod";
+export declare const StatementType: zod.ZodEnum<{
+    interim: "interim";
+    final: "final";
+    supplement: "supplement";
+}>;
+export type StatementType = zod.input<typeof StatementType>;
+export type StatementTypeOutput = zod.output<typeof StatementType>;

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

@@ -0,0 +1,11 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Billing API
+ * Products, prices, orders, subscriptions and account billing. Financial operations require an account access token and billing-account authorization. Public catalogue operations declare no security requirement.
+ * OpenAPI spec version: v1
+ */
+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.");

package/dist/canopy/v1/generated/models.d.ts

@@ -3348,7 +3348,16 @@ export declare const StatementStatus: {
     readonly closed: "closed";
 };
 /**
- * An account's consumption for one billing period, collected at one closing. The first statement of a period (sequence 1) closes after the period ends. Usage priced after that closing is collected in a later statement for the same period, which closes and invoices separately; a closed statement is never rewritten. Payments apply to issued invoices.
+ * 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.
+ */
+export type StatementType = (typeof StatementType)[keyof typeof StatementType];
+export declare const StatementType: {
+    readonly interim: "interim";
+    readonly final: "final";
+    readonly supplement: "supplement";
+};
+/**
+ * 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.
  */
 export interface Statement {
     id: string;
@@ -3356,10 +3365,11 @@ export interface Statement {
     currency: string;
     period_start: string;
     period_end: string;
-    /** 1 for the first closing of the period; higher for statements that collect usage priced after an earlier closing. */
+    /** Increases with each closing of the period. */
     sequence: number;
     status: StatementStatus;
-    /** 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 closing, and a tier reduction larger than this statement's own charges is credited to earlier invoices of the period at closing. */
+    type: StatementType;
+    /** 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. */
     estimated: boolean;
     amounts: StatementAmounts;
     closed_at?: string;

package/dist/canopy/v1/generated/models.js

@@ -401,6 +401,11 @@ export const StatementStatus = {
     open: "open",
     closed: "closed",
 };
+export const StatementType = {
+    interim: "interim",
+    final: "final",
+    supplement: "supplement",
+};
 export const StatementSummaryGroupBy = {
     project: "project",
     product: "product",

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

@@ -40,6 +40,11 @@ export declare const Statement: zod.ZodObject<{
         open: "open";
         closed: "closed";
     }>;
+    type: zod.ZodEnum<{
+        interim: "interim";
+        final: "final";
+        supplement: "supplement";
+    }>;
     estimated: zod.ZodBoolean;
     amounts: zod.ZodObject<{
         subtotal: zod.ZodString;

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

@@ -32,6 +32,7 @@ import * as zod from "zod";
 import { Money } from "./money.zod.js";
 import { StatementAmounts } from "./statementAmounts.zod.js";
 import { StatementStatus } from "./statementStatus.zod.js";
+import { StatementType } from "./statementType.zod.js";
 export const Statement = zod
     .strictObject({
     id: zod.uuid(),
@@ -39,13 +40,12 @@ export const Statement = zod
     currency: zod.string(),
     period_start: zod.iso.datetime({ offset: true }),
     period_end: zod.iso.datetime({ offset: true }),
-    sequence: zod
-        .int()
-        .describe("1 for the first closing of the period; higher for statements that collect usage priced after an earlier closing."),
+    sequence: zod.int().describe("Increases with each closing of the period."),
     status: StatementStatus,
+    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 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 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."),
     amounts: StatementAmounts,
     closed_at: zod.iso.datetime({ offset: true }).optional(),
     invoice_id: zod
@@ -56,4 +56,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. The first statement of a period (sequence 1) closes after the period ends. Usage priced after that closing is collected in a later statement for the same period, which closes and invoices separately; a closed statement is never rewritten. Payments apply to issued invoices.");
+    .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.");

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

@@ -41,6 +41,11 @@ export declare const StatementList: zod.ZodObject<{
             open: "open";
             closed: "closed";
         }>;
+        type: zod.ZodEnum<{
+            interim: "interim";
+            final: "final";
+            supplement: "supplement";
+        }>;
         estimated: zod.ZodBoolean;
         amounts: zod.ZodObject<{
             subtotal: zod.ZodString;

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

@@ -0,0 +1,38 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Canopy API
+ * Management of API keys, together with the models available and the usage recorded against them.
+ *
+ * **These endpoints do not perform inference.** Requests are issued to the forwarding address, which accepts the OpenAI, Anthropic and Gemini request formats:
+ *
+ * ```
+ * POST /v1/chat/completions                    OpenAI
+ * POST /v1/messages                            Anthropic
+ * POST /v1beta/models/{model}:generateContent  Gemini
+ * ```
+ *
+ * ## Authentication
+ *
+ * Every request carries a scoped token; see the `bearerAuth` security scheme.
+ *
+ * These endpoints do not accept an API key, and the forwarding endpoints do not accept a scoped token.
+ *
+ * ## Conventions
+ *
+ * - **The plaintext of an API key is returned once.** The `secret` appears in the response that issues it and is returned by no other endpoint. A key that has been lost has to be revoked and reissued.
+ * - **Disabling and revoking are distinct.** A disabled key may be enabled again at any time, while a revocation is irreversible and is intended for a key that has been exposed. Neither removes the record, and the usage the key accrued remains readable.
+ * - **A usage query must carry a time range**, spanning no more than 31 days. `from` and `to` carry a timezone offset, which the server does not infer.
+ * - **The request and response bodies do not appear in the ledger.** They are not recorded. Quote the `upstream_request_id` from the response when reporting a problem.
+ * - **Usage may be estimated.** The upstream provider does not report usage on every request. Where it does not, `usage_source` is `estimated` and the figures are derived from the character classes of the payload, to within roughly fifteen per cent.
+ * - **The service is enabled before use.** A project enables the model platform once, through `create-service`; the forwarding endpoints refuse its requests until the service is `active`. Requests are then billed under the service's subscription by the tokens they use, at the rates stated in each model's `pricing`.
+ * OpenAPI spec version: 1.0.0
+ */
+import * as zod from "zod";
+export declare const StatementType: zod.ZodEnum<{
+    interim: "interim";
+    final: "final";
+    supplement: "supplement";
+}>;
+export type StatementType = zod.input<typeof StatementType>;
+export type StatementTypeOutput = zod.output<typeof StatementType>;

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

@@ -0,0 +1,34 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Canopy API
+ * Management of API keys, together with the models available and the usage recorded against them.
+ *
+ * **These endpoints do not perform inference.** Requests are issued to the forwarding address, which accepts the OpenAI, Anthropic and Gemini request formats:
+ *
+ * ```
+ * POST /v1/chat/completions                    OpenAI
+ * POST /v1/messages                            Anthropic
+ * POST /v1beta/models/{model}:generateContent  Gemini
+ * ```
+ *
+ * ## Authentication
+ *
+ * Every request carries a scoped token; see the `bearerAuth` security scheme.
+ *
+ * These endpoints do not accept an API key, and the forwarding endpoints do not accept a scoped token.
+ *
+ * ## Conventions
+ *
+ * - **The plaintext of an API key is returned once.** The `secret` appears in the response that issues it and is returned by no other endpoint. A key that has been lost has to be revoked and reissued.
+ * - **Disabling and revoking are distinct.** A disabled key may be enabled again at any time, while a revocation is irreversible and is intended for a key that has been exposed. Neither removes the record, and the usage the key accrued remains readable.
+ * - **A usage query must carry a time range**, spanning no more than 31 days. `from` and `to` carry a timezone offset, which the server does not infer.
+ * - **The request and response bodies do not appear in the ledger.** They are not recorded. Quote the `upstream_request_id` from the response when reporting a problem.
+ * - **Usage may be estimated.** The upstream provider does not report usage on every request. Where it does not, `usage_source` is `estimated` and the figures are derived from the character classes of the payload, to within roughly fifteen per cent.
+ * - **The service is enabled before use.** A project enables the model platform once, through `create-service`; the forwarding endpoints refuse its requests until the service is `active`. Requests are then billed under the service's subscription by the tokens they use, at the rates stated in each model's `pricing`.
+ * OpenAPI spec version: 1.0.0
+ */
+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.");

package/dist/compute/v1/generated/models.d.ts

@@ -5294,7 +5294,16 @@ export declare const StatementStatus: {
     readonly closed: "closed";
 };
 /**
- * An account's consumption for one billing period, collected at one closing. The first statement of a period (sequence 1) closes after the period ends. Usage priced after that closing is collected in a later statement for the same period, which closes and invoices separately; a closed statement is never rewritten. Payments apply to issued invoices.
+ * 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.
+ */
+export type StatementType = (typeof StatementType)[keyof typeof StatementType];
+export declare const StatementType: {
+    readonly interim: "interim";
+    readonly final: "final";
+    readonly supplement: "supplement";
+};
+/**
+ * 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.
  */
 export interface Statement {
     id: string;
@@ -5302,10 +5311,11 @@ export interface Statement {
     currency: string;
     period_start: string;
     period_end: string;
-    /** 1 for the first closing of the period; higher for statements that collect usage priced after an earlier closing. */
+    /** Increases with each closing of the period. */
     sequence: number;
     status: StatementStatus;
-    /** 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 closing, and a tier reduction larger than this statement's own charges is credited to earlier invoices of the period at closing. */
+    type: StatementType;
+    /** 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. */
     estimated: boolean;
     amounts: StatementAmounts;
     closed_at?: string;

package/dist/compute/v1/generated/models.js

@@ -699,6 +699,11 @@ export const StatementStatus = {
     open: "open",
     closed: "closed",
 };
+export const StatementType = {
+    interim: "interim",
+    final: "final",
+    supplement: "supplement",
+};
 export const StatementSummaryGroupBy = {
     project: "project",
     product: "product",

package/dist/compute/v1/generated/validators/statement.zod.d.ts

@@ -33,6 +33,11 @@ export declare const Statement: zod.ZodObject<{
         open: "open";
         closed: "closed";
     }>;
+    type: zod.ZodEnum<{
+        interim: "interim";
+        final: "final";
+        supplement: "supplement";
+    }>;
     estimated: zod.ZodBoolean;
     amounts: zod.ZodObject<{
         subtotal: zod.ZodString;

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

@@ -25,6 +25,7 @@ import * as zod from "zod";
 import { Money } from "./money.zod.js";
 import { StatementAmounts } from "./statementAmounts.zod.js";
 import { StatementStatus } from "./statementStatus.zod.js";
+import { StatementType } from "./statementType.zod.js";
 export const Statement = zod
     .strictObject({
     id: zod.uuid(),
@@ -32,13 +33,12 @@ export const Statement = zod
     currency: zod.string(),
     period_start: zod.iso.datetime({ offset: true }),
     period_end: zod.iso.datetime({ offset: true }),
-    sequence: zod
-        .int()
-        .describe("1 for the first closing of the period; higher for statements that collect usage priced after an earlier closing."),
+    sequence: zod.int().describe("Increases with each closing of the period."),
     status: StatementStatus,
+    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 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 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."),
     amounts: StatementAmounts,
     closed_at: zod.iso.datetime({ offset: true }).optional(),
     invoice_id: zod
@@ -49,4 +49,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. The first statement of a period (sequence 1) closes after the period ends. Usage priced after that closing is collected in a later statement for the same period, which closes and invoices separately; a closed statement is never rewritten. Payments apply to issued invoices.");
+    .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.");

package/dist/compute/v1/generated/validators/statementList.zod.d.ts

@@ -34,6 +34,11 @@ export declare const StatementList: zod.ZodObject<{
             open: "open";
             closed: "closed";
         }>;
+        type: zod.ZodEnum<{
+            interim: "interim";
+            final: "final";
+            supplement: "supplement";
+        }>;
         estimated: zod.ZodBoolean;
         amounts: zod.ZodObject<{
             subtotal: zod.ZodString;