@leaflow/sdk 0.120.0 → 0.122.0

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

@@ -47,6 +47,365 @@ export const CheckoutMode = {
     automatic: "automatic",
     deferred: "deferred",
 };
+export const InvoiceStatus = {
+    draft: "draft",
+    open: "open",
+    paid: "paid",
+    void: "void",
+    uncollectible: "uncollectible",
+};
+export const ContactTaxExempt = {
+    none: "none",
+    exempt: "exempt",
+    reverse: "reverse",
+};
+export const TerminationPolicy = {
+    immediate: "immediate",
+    period_end: "period_end",
+};
+export const RefundPolicy = {
+    none: "none",
+    prorated: "prorated",
+};
+export const QuoteRenewalInterval = {
+    day: "day",
+    month: "month",
+    year: "year",
+};
+export const QuoteRenewalResultInterval = {
+    day: "day",
+    month: "month",
+    year: "year",
+};
+export const QuotedDiscountType = {
+    promotion_code: "promotion_code",
+    account_discount: "account_discount",
+};
+export const CancellationRefundPreviewItemChargeType = {
+    postpaid: "postpaid",
+    prepaid: "prepaid",
+    one_time: "one_time",
+};
+export const CancellationStatus = {
+    requested: "requested",
+    scheduled: "scheduled",
+    releasing: "releasing",
+    completed: "completed",
+    canceled: "canceled",
+    failed: "failed",
+};
+export const CancellationOrigin = {
+    customer: "customer",
+    operator: "operator",
+    project_deletion: "project_deletion",
+};
+export const CancellationItemChargeType = {
+    postpaid: "postpaid",
+    prepaid: "prepaid",
+    one_time: "one_time",
+};
+export const CancellationItemStatus = {
+    requested: "requested",
+    scheduled: "scheduled",
+    releasing: "releasing",
+    completed: "completed",
+    canceled: "canceled",
+    failed: "failed",
+};
+export const SubscriptionCancellationStatus = {
+    requested: "requested",
+    scheduled: "scheduled",
+    releasing: "releasing",
+    failed: "failed",
+    completed: "completed",
+    canceled: "canceled",
+};
+export const SubscriptionCancellationMode = {
+    immediate: "immediate",
+    period_end: "period_end",
+};
+export const BillingAccountStatus = {
+    active: "active",
+    suspended: "suspended",
+    closed: "closed",
+};
+export const PriceOptionBillingScheme = {
+    per_unit: "per_unit",
+    tiered: "tiered",
+    rated: "rated",
+};
+export const PriceOptionType = {
+    postpaid: "postpaid",
+    prepaid: "prepaid",
+    one_time: "one_time",
+};
+export const PriceOptionInterval = {
+    none: "none",
+    day: "day",
+    month: "month",
+    year: "year",
+};
+export const PurchaseOperation = {
+    new: "new",
+    renew: "renew",
+    modify: "modify",
+};
+export const TopUpStatus = {
+    pending: "pending",
+    succeeded: "succeeded",
+    failed: "failed",
+    canceled: "canceled",
+};
+export const PaymentCancellationReason = {
+    abandoned: "abandoned",
+    requested_by_customer: "requested_by_customer",
+};
+export const PaymentActionType = {
+    redirect: "redirect",
+    qr_code: "qr_code",
+    sdk: "sdk",
+};
+export const PaymentMethodStatus = {
+    active: "active",
+    expired: "expired",
+    removed: "removed",
+};
+export const PaymentStatus = {
+    succeeded: "succeeded",
+    processing: "processing",
+    requires_action: "requires_action",
+    failed: "failed",
+};
+export const TransactionRefundDestination = {
+    balance: "balance",
+    credit: "credit",
+    gateway: "gateway",
+};
+export const TransactionStatus = {
+    pending: "pending",
+    succeeded: "succeeded",
+    failed: "failed",
+    canceled: "canceled",
+};
+export const TransactionType = {
+    topup: "topup",
+    payment: "payment",
+    refund: "refund",
+    adjustment: "adjustment",
+};
+export const InvoiceCustomerTaxExempt = {
+    none: "none",
+    exempt: "exempt",
+    reverse: "reverse",
+};
+export const InvoiceItemType = {
+    usage: "usage",
+    subscription: "subscription",
+    one_time: "one_time",
+    setup: "setup",
+    adjustment: "adjustment",
+};
+export const CreditGrantStatus = {
+    active: "active",
+    depleted: "depleted",
+    expired: "expired",
+    voided: "voided",
+};
+export const CreditNoteStatus = {
+    issued: "issued",
+    void: "void",
+};
+export const CreditNoteReason = {
+    provisioning_failed: "provisioning_failed",
+    order_expired: "order_expired",
+    order_canceled: "order_canceled",
+    change_canceled: "change_canceled",
+    change_expired: "change_expired",
+    subscription_canceled: "subscription_canceled",
+    usage_true_up: "usage_true_up",
+    operator: "operator",
+};
+export const RefundDestination = {
+    balance: "balance",
+    gateway: "gateway",
+};
+export const RefundStatus = {
+    pending: "pending",
+    processing: "processing",
+    succeeded: "succeeded",
+    failed: "failed",
+};
+export const RefundReason = {
+    provisioning_failed: "provisioning_failed",
+    order_expired: "order_expired",
+    order_canceled: "order_canceled",
+    change_canceled: "change_canceled",
+    change_expired: "change_expired",
+    subscription_canceled: "subscription_canceled",
+    future_period_canceled: "future_period_canceled",
+    downgrade_difference: "downgrade_difference",
+    usage_true_up: "usage_true_up",
+    payment_not_applied: "payment_not_applied",
+    operator: "operator",
+};
+export const SubscriptionChargeType = {
+    postpaid: "postpaid",
+    prepaid: "prepaid",
+    one_time: "one_time",
+};
+export const SubscriptionInterval = {
+    none: "none",
+    day: "day",
+    month: "month",
+    year: "year",
+};
+export const SubscriptionStatus = {
+    pending: "pending",
+    provisioning: "provisioning",
+    active: "active",
+    suspended: "suspended",
+    canceled: "canceled",
+    terminated: "terminated",
+};
+export const RenewalPriceInterval = {
+    day: "day",
+    month: "month",
+    year: "year",
+};
+export const RenewRequestInterval = {
+    day: "day",
+    month: "month",
+    year: "year",
+};
+export const RenewalOrderRequestInterval = {
+    day: "day",
+    month: "month",
+    year: "year",
+};
+export const OrderStatus = {
+    pending: "pending",
+    accepted: "accepted",
+    completed: "completed",
+    partially_completed: "partially_completed",
+    failed: "failed",
+    canceled: "canceled",
+};
+export const OrderItemStatus = {
+    pending: "pending",
+    completed: "completed",
+    failed: "failed",
+    canceled: "canceled",
+};
+export const OrderType = {
+    new: "new",
+    renew: "renew",
+    modify: "modify",
+};
+export const OrderChangeEffective = {
+    none: "none",
+    immediate: "immediate",
+    period_end: "period_end",
+};
+export const OrderItemInterval = {
+    none: "none",
+    day: "day",
+    month: "month",
+    year: "year",
+};
+export const OrderItemChargeType = {
+    postpaid: "postpaid",
+    prepaid: "prepaid",
+    one_time: "one_time",
+};
+export const DiscountStatus = {
+    scheduled: "scheduled",
+    active: "active",
+    expired: "expired",
+    voided: "voided",
+};
+export const DiscountType = {
+    percentage: "percentage",
+    fixed_amount: "fixed_amount",
+    price_override: "price_override",
+    free_setup: "free_setup",
+};
+export const DiscountFrequency = {
+    once: "once",
+    recurring: "recurring",
+    forever: "forever",
+};
+export const AllowanceCategory = {
+    paid: "paid",
+    promotional: "promotional",
+};
+export const AllowanceStatus = {
+    active: "active",
+    depleted: "depleted",
+    expired: "expired",
+    voided: "voided",
+};
+export const FeatureGrantStatus = {
+    scheduled: "scheduled",
+    active: "active",
+    expired: "expired",
+    voided: "voided",
+};
+export const PriceType = {
+    postpaid: "postpaid",
+    prepaid: "prepaid",
+    one_time: "one_time",
+};
+export const PriceBillingScheme = {
+    per_unit: "per_unit",
+    tiered: "tiered",
+    rated: "rated",
+};
+export const PriceTiersMode = {
+    none: "none",
+    graduated: "graduated",
+    volume: "volume",
+};
+export const PriceInterval = {
+    none: "none",
+    day: "day",
+    month: "month",
+    year: "year",
+};
+export const RateBillingScheme = {
+    per_unit: "per_unit",
+    tiered: "tiered",
+};
+export const RateTiersMode = {
+    none: "none",
+    graduated: "graduated",
+    volume: "volume",
+};
+export const QuoteItemInputPriceType = {
+    postpaid: "postpaid",
+    prepaid: "prepaid",
+    one_time: "one_time",
+};
+export const QuoteItemInputInterval = {
+    none: "none",
+    day: "day",
+    month: "month",
+    year: "year",
+};
+export const ActiveResourceStatus = {
+    active: "active",
+    suspended: "suspended",
+    closing: "closing",
+    closed: "closed",
+};
+export const StatementStatus = {
+    open: "open",
+    closed: "closed",
+};
+export const StatementSummaryGroupBy = {
+    project: "project",
+    product: "product",
+    meter: "meter",
+};
 export const ListApiKeysStatus = {
     active: "active",
     disabled: "disabled",

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

@@ -0,0 +1,146 @@
+/**
+ * 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 AccountBalance: zod.ZodObject<{
+    available_credit: zod.ZodString;
+    unbilled_amount: zod.ZodString;
+    billing_account_id: zod.ZodInt;
+    currency: zod.ZodString;
+    balance: zod.ZodString;
+    credits: zod.ZodString;
+    restricted_credits: zod.ZodString;
+    credit_groups: zod.ZodArray<zod.ZodObject<{
+        applies_to: zod.ZodObject<{
+            products: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+                id: zod.ZodString;
+                name: zod.ZodString;
+                description: zod.ZodOptional<zod.ZodString>;
+            }, zod.z.core.$strict>>>;
+            plans: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+                id: zod.ZodUUID;
+                name: zod.ZodString;
+                active: zod.ZodBoolean;
+            }, zod.z.core.$strict>>>;
+            prices: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+                product: zod.ZodObject<{
+                    id: zod.ZodString;
+                    name: zod.ZodString;
+                    description: zod.ZodOptional<zod.ZodString>;
+                }, zod.z.core.$strict>;
+                plan: zod.ZodObject<{
+                    lookup_key: zod.ZodOptional<zod.ZodString>;
+                    id: zod.ZodUUID;
+                    name: zod.ZodString;
+                }, zod.z.core.$strict>;
+                billing_scheme: zod.ZodEnum<{
+                    per_unit: "per_unit";
+                    tiered: "tiered";
+                    rated: "rated";
+                }>;
+                unit_quantity: zod.ZodString;
+                id: zod.ZodUUID;
+                currency: zod.ZodString;
+                type: zod.ZodEnum<{
+                    postpaid: "postpaid";
+                    prepaid: "prepaid";
+                    one_time: "one_time";
+                }>;
+                interval: zod.ZodEnum<{
+                    none: "none";
+                    day: "day";
+                    month: "month";
+                    year: "year";
+                }>;
+                interval_count: zod.ZodOptional<zod.ZodInt>;
+                unit_amount: zod.ZodOptional<zod.ZodString>;
+                active: zod.ZodBoolean;
+            }, zod.z.core.$strict>>>;
+            price_types: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+            operations: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
+                new: "new";
+                renew: "renew";
+                modify: "modify";
+            }>>>;
+            min_term_months: zod.ZodOptional<zod.ZodInt>;
+            max_term_months: zod.ZodOptional<zod.ZodInt>;
+            excluded_products: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+                id: zod.ZodString;
+                name: zod.ZodString;
+                description: zod.ZodOptional<zod.ZodString>;
+            }, zod.z.core.$strict>>>;
+            excluded_plans: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+                id: zod.ZodUUID;
+                name: zod.ZodString;
+                active: zod.ZodBoolean;
+            }, zod.z.core.$strict>>>;
+            excluded_prices: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+                product: zod.ZodObject<{
+                    id: zod.ZodString;
+                    name: zod.ZodString;
+                    description: zod.ZodOptional<zod.ZodString>;
+                }, zod.z.core.$strict>;
+                plan: zod.ZodObject<{
+                    lookup_key: zod.ZodOptional<zod.ZodString>;
+                    id: zod.ZodUUID;
+                    name: zod.ZodString;
+                }, zod.z.core.$strict>;
+                billing_scheme: zod.ZodEnum<{
+                    per_unit: "per_unit";
+                    tiered: "tiered";
+                    rated: "rated";
+                }>;
+                unit_quantity: zod.ZodString;
+                id: zod.ZodUUID;
+                currency: zod.ZodString;
+                type: zod.ZodEnum<{
+                    postpaid: "postpaid";
+                    prepaid: "prepaid";
+                    one_time: "one_time";
+                }>;
+                interval: zod.ZodEnum<{
+                    none: "none";
+                    day: "day";
+                    month: "month";
+                    year: "year";
+                }>;
+                interval_count: zod.ZodOptional<zod.ZodInt>;
+                unit_amount: zod.ZodOptional<zod.ZodString>;
+                active: zod.ZodBoolean;
+            }, zod.z.core.$strict>>>;
+        }, zod.z.core.$strict>;
+        first_purchase_only: zod.ZodOptional<zod.ZodBoolean>;
+        amount: zod.ZodString;
+    }, zod.z.core.$strict>>;
+    due: zod.ZodString;
+    pending_returns_amount: zod.ZodString;
+}, zod.z.core.$strict>;
+export type AccountBalance = zod.input<typeof AccountBalance>;
+export type AccountBalanceOutput = zod.output<typeof AccountBalance>;

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

@@ -0,0 +1,49 @@
+/**
+ * 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";
+import { CreditGroup } from "./creditGroup.zod.js";
+import { Money } from "./money.zod.js";
+export const AccountBalance = zod
+    .strictObject({
+    available_credit: Money.describe("Balance minus pending balance returns, unbilled usage estimates and issued unpaid amounts. Credit grants are excluded; the result may be negative."),
+    unbilled_amount: Money.describe("Current estimate of rated usage that has not been invoiced. Final pricing and tax are fixed at issuance."),
+    billing_account_id: zod.int(),
+    currency: zod.string(),
+    balance: Money.describe("Prepaid funds in the account currency, excluding credits. May be negative after a payment\ndispute. Outstanding charges are reported separately in due; this value is not a withdrawal quote."),
+    credits: Money.describe("The recorded remaining credit, including restricted grants. It is not withdrawable\nand is not part of balance. credit_groups describes currently valid credit by permitted use; a positive\ncredits balance does not imply that due is zero."),
+    restricted_credits: Money.describe("Currently valid credit whose use has applicable product, operation or eligibility conditions. Included in credits, separate from the balance."),
+    credit_groups: zod
+        .array(CreditGroup)
+        .describe("Currently valid, unspent credit grouped by permitted use. Restrictions and\nvalidity dates determine which charges a group can cover, so these groups are not a general\nspendable balance and may differ from the recorded credits total."),
+    due: Money.describe("Amount still payable on issued invoices. Unbilled usage is reported separately; arrears depend on actual eligible funding and grace terms."),
+    pending_returns_amount: Money,
+})
+    .describe("Account balance, credits, and unpaid charges are reported separately.");

package/dist/canopy/v1/generated/validators/accountIdentity.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 AccountIdentity: zod.ZodObject<{
+    id: zod.ZodInt;
+    name: zod.ZodString;
+    currency: zod.ZodString;
+}, zod.z.core.$strict>;
+export type AccountIdentity = zod.input<typeof AccountIdentity>;
+export type AccountIdentityOutput = zod.output<typeof AccountIdentity>;

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

@@ -0,0 +1,36 @@
+/**
+ * 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 AccountIdentity = zod.strictObject({
+    id: zod.int(),
+    name: zod.string(),
+    currency: zod.string(),
+});