@leaflow/sdk 0.28.0 → 0.30.0

package/dist/billing/v1/index.d.ts

@@ -6,10 +6,20 @@ export type ListBillingAccountsResult = operations["list-billing-accounts"]["res
 export type CreateBillingAccountResult = operations["create-billing-account"]["responses"][200]["content"]["application/json"];
 /** `POST /account/v1/billing-accounts` 的请求体。 */
 export type CreateBillingAccountBody = NonNullable<operations["create-billing-account"]["requestBody"]>["content"]["application/json"];
+/** `GET /account/v1/billing-accounts/{accountKey}` 成功时的响应体。 */
+export type GetBillingAccountResult = operations["get-billing-account"]["responses"][200]["content"]["application/json"];
+/** `PUT /account/v1/billing-accounts/{accountKey}` 成功时的响应体。 */
+export type UpdateBillingAccountResult = operations["update-billing-account"]["responses"][200]["content"]["application/json"];
+/** `PUT /account/v1/billing-accounts/{accountKey}` 的请求体。 */
+export type UpdateBillingAccountBody = NonNullable<operations["update-billing-account"]["requestBody"]>["content"]["application/json"];
+/** `GET /account/v1/billing-accounts/{accountKey}/credit-transactions` 成功时的响应体。 */
+export type ListCreditTransactionsResult = operations["list-credit-transactions"]["responses"][200]["content"]["application/json"];
 /** `GET /account/v1/billing-accounts/{accountKey}/balance` 成功时的响应体。 */
 export type ReadBillingAccountBalanceResult = operations["read-billing-account-balance"]["responses"][200]["content"]["application/json"];
 /** `PUT /account/v1/billing-accounts/{accountKey}/projects/{projectId}` 成功时的响应体。 */
 export type BindProjectToBillingAccountResult = operations["bind-project-to-billing-account"]["responses"][200]["content"]["application/json"];
+/** `GET /account/v1/billing-accounts/{accountKey}/top-ups` 成功时的响应体。 */
+export type ListTopUpsResult = operations["list-top-ups"]["responses"][200]["content"]["application/json"];
 /** `POST /account/v1/billing-accounts/{accountKey}/top-ups` 成功时的响应体。 */
 export type StartTopUpResult = operations["start-top-up"]["responses"][200]["content"]["application/json"];
 /** `POST /account/v1/billing-accounts/{accountKey}/top-ups` 的请求体。 */

package/dist/billing/v1/schema.d.ts

@@ -38,6 +38,63 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/account/v1/billing-accounts/{accountKey}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Read one of my billing accounts
+         * @description One account, with the projects it currently pays for.
+         *
+         *     The list returns the same objects, so this exists for the case the list cannot serve: a link
+         *     straight to one account. Making the caller fetch every account and filter turns a bookmarked
+         *     page into a request whose cost grows with how many accounts they hold.
+         */
+        get: operations["get-billing-account"];
+        /**
+         * Rename a billing account
+         * @description Changes the display name. Nothing else about the account can be changed here.
+         *
+         *     The key is not among the fields and never will be: ownership is stated by the key, and
+         *     invoices already issued refer to it. The name is what tells two accounts apart in a list, so
+         *     a mistake made while creating one is otherwise permanent.
+         */
+        put: operations["update-billing-account"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/v1/billing-accounts/{accountKey}/credit-transactions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * How the balance got to where it is
+         * @description Every movement of credit on this account: what was added, what was spent, what expired, what
+         *     was voided. Newest first.
+         *
+         *     The balance on its own is a number with no account of itself. Asked why it is lower than
+         *     expected, it cannot answer, and the holder is left to guess between "I was charged" and
+         *     "something expired" — which lead to different next steps.
+         */
+        get: operations["list-credit-transactions"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/account/v1/billing-accounts/{accountKey}/balance": {
         parameters: {
             query?: never;
@@ -90,7 +147,21 @@ export interface paths {
          */
         put: operations["bind-project-to-billing-account"];
         post?: never;
-        delete?: never;
+        /**
+         * Stop paying for a project
+         * @description Unbinds the project from this account. Nothing pays for it afterwards, and **everything in it
+         *     is refused admission** until some account takes it on — no new machines, no forwarded
+         *     requests.
+         *
+         *     That consequence is the reason this exists rather than an argument against it: a project
+         *     bound to the wrong account has no other way out, and moving it to another of the caller's
+         *     accounts is not a correction when the answer is that this account should not be paying for
+         *     it at all.
+         *
+         *     Charges already accrued stay where they are. They were incurred while this account held the
+         *     project, and an invoice has to keep pointing at what it was based on.
+         */
+        delete: operations["unbind-project-from-billing-account"];
         options?: never;
         head?: never;
         patch?: never;
@@ -103,7 +174,16 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /**
+         * My top-ups
+         * @description Every top-up this account has made, newest first.
+         *
+         *     Reading one top-up requires already holding its identifier, and the only place that
+         *     identifier appears is the redirect that started it — so without this list a top-up becomes
+         *     unfindable the moment the browser tab is closed, which is exactly when somebody wants to
+         *     check whether their money arrived.
+         */
+        get: operations["list-top-ups"];
         put?: never;
         /**
          * Start a top-up
@@ -485,6 +565,43 @@ export interface components {
              */
             one_time?: boolean;
         };
+        UpdateBillingAccountRequestBody: {
+            display_name: string;
+        };
+        TopUpList: {
+            top_ups: components["schemas"]["TopUpStatus"][];
+        };
+        CreditTransactionList: {
+            transactions: components["schemas"]["CreditTransaction"][];
+        };
+        /**
+         * @description One movement of credit. Immutable — a correction is another movement, never an edit of this
+         *     one, which is what lets the balance be recomputed from the list at any time
+         */
+        CreditTransaction: {
+            id: string;
+            type: components["schemas"]["CreditTransactionType"];
+            /** @description A decimal string. Never a float — a balance that rounds is a balance that drifts */
+            amount: string;
+            currency: string;
+            /**
+             * Format: date-time
+             * @description When it landed on the ledger, which is not always when it was requested
+             */
+            booked_at: string;
+            /**
+             * @description What the balance became. Recorded by the metering engine rather than recomputed here —
+             *     recomputing assumes our understanding of the burn-down order matches its own, and this
+             *     is its own account of it
+             */
+            balance_after: string;
+        };
+        /**
+         * @description `funded` is credit arriving, `consumed` is it being spent, `expired` is a grant reaching the
+         *     end of its life unspent, and `voided` is one cancelled — a refund, or a correction
+         * @enum {string}
+         */
+        CreditTransactionType: "funded" | "consumed" | "expired" | "voided";
         /**
          * @description What a top-up bundle costs and what it grants. Present only on offers that sell credit.
          *
@@ -818,6 +935,115 @@ export interface operations {
             };
         };
     };
+    "get-billing-account": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BillingAccount"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "update-billing-account": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateBillingAccountRequestBody"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BillingAccount"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "list-credit-transactions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CreditTransactionList"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
     "read-billing-account-balance": {
         parameters: {
             query?: never;
@@ -890,6 +1116,76 @@ export interface operations {
             };
         };
     };
+    "unbind-project-from-billing-account": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+                /** @description The project to stop paying for */
+                projectId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Unbound */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "list-top-ups": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The account's key, of the form `u_<user_id>_<seq>`. Ownership is stated by the key itself,
+                 *     which is why the key is what addresses the account.
+                 */
+                accountKey: components["parameters"]["AccountKey"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TopUpList"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
     "start-top-up": {
         parameters: {
             query?: never;

package/dist/monitoring/v1/index.d.ts

@@ -58,6 +58,8 @@ export type GetServerSnapshotResult = operations["get-server-snapshot"]["respons
 export type ListProjectTopItemsResult = operations["list-project-top-items"]["responses"][200]["content"]["application/json"];
 /** `GET /api/v1/top-items` 的查询参数。 */
 export type ListProjectTopItemsQuery = operations["list-project-top-items"]["parameters"]["query"];
+/** `GET /api/v1/templates` 成功时的响应体。 */
+export type ListTemplatesResult = operations["list-templates"]["responses"][200]["content"]["application/json"];
 /** `GET /api/v1/servers` 成功时的响应体。 */
 export type ListServersResult = operations["list-servers"]["responses"][200]["content"]["application/json"];
 /** `GET /api/v1/servers` 的查询参数。 */

package/dist/monitoring/v1/schema.d.ts

@@ -331,6 +331,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/templates": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List the monitoring templates that can be bound to a machine
+         * @description The catalog every template binding is validated against — which templates exist, which parameters each of them accepts, and what each parameter defaults to. It is identical for every project and changes only when this deployment is upgraded. Read it rather than keeping a copy. A copy drifts, and only one of the ways it drifts fails loudly — an unknown parameter name is rejected, but a stale `default` and a stale `required` both look correct on screen.
+         */
+        get: operations["list-templates"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/servers": {
         parameters: {
             query?: never;
@@ -366,6 +386,8 @@ export interface paths {
          *     A failed call leaves the machine recorded with `monitoring_status: FAILED`; the reason is reported in `last_error` via `GET /servers/{serverId}`.
          *
          *     The `tls_psk` in the response is **returned only this once**; store it immediately. If it is lost, it must be rotated.
+         *
+         *     It is also how collection is resumed after `/disable`. On a machine that already exists, **omitting `template_bindings` keeps the bindings it already has**; it does not fall back to the default of Linux alone, which would silently drop every other template together with its parameters. Secret parameters are likewise carried over — see `parameters` on the binding.
          */
         put: operations["enable-server-monitoring"];
         post?: never;
@@ -1291,6 +1313,46 @@ export interface components {
         TopItemListResponseBody: {
             items: components["schemas"]["TopItemResource"][] | null;
         };
+        TemplateCatalogParameterResource: {
+            /** @description The value that takes effect when the parameter is omitted. An empty string is a real default, not an absent one */
+            default: string;
+            /**
+             * @description The shape of the accepted value. Surrounding whitespace is trimmed before the value is checked, and an omitted or empty value is replaced by `default` and not checked at all.
+             *
+             *     - `string` — no constraint; empty is accepted
+             *     - `non_empty_string` — must not be empty once trimmed
+             *     - `percent` — a number in the **closed** interval 0 to 100; fractions are accepted
+             *     - `positive_number` — a number **strictly** greater than 0; fractions are accepted
+             *     - `port` — an integer from 1 to 65535 inclusive; `8080/tcp` is not a port
+             *     - `host` — an IP address, or a hostname of at most 255 characters whose dot-separated labels are at most 63 characters of `A-Z a-z 0-9 - _` and neither begin nor end with `-`. A single label such as `localhost` is accepted, as is a trailing dot
+             *     - `ip_or_empty` — an IP address, or empty to mean "not specified"
+             *     - `regexp` — must compile as a **Go RE2** pattern. RE2 has no backreferences and no lookaround, so a pattern that a browser's `new RegExp()` accepts may still be rejected here. Validating client-side narrows the gap but does not close it
+             * @enum {string}
+             */
+            kind: "string" | "non_empty_string" | "percent" | "positive_number" | "port" | "host" | "ip_or_empty" | "regexp";
+            /** @description The key to use in `template_bindings[].parameters`. It is not the Zabbix macro name, which is internal and changes between Zabbix versions */
+            name: string;
+            /** @description Independent of `default`. The three NGINX connection parameters carry a default and are still required, because the template's own default (localhost:80/basic_status) is almost never right */
+            required: boolean;
+            /** @description Supplied in clear text and never returned. A configured one is reported by name only, through `configured_secret_parameters` on the bound template. When updating a machine that already has one stored, omit it to keep the stored value and supply it only to replace it — a caller cannot read it back, so requiring it on every write would make resuming collection impossible */
+            secret: boolean;
+        };
+        TemplateCatalogEntryResource: {
+            /** @description Exactly one template with this set must be bound to every machine. Binding none enrolls a machine that can never alert; binding both loads the Linux and Windows items onto one machine, half of which must fail */
+            is_base: boolean;
+            /** @description False means the template collects without an agent on the machine — ICMP_PING is pinged by the Zabbix server, PROXMOX_VE is polled over the PVE API */
+            needs_agent: boolean;
+            /** @description In declaration order — connection parameters first, thresholds after — and meant to be rendered in that order. It is deliberately not alphabetical, which would split a template's connection parameters apart with thresholds between them even though they only make sense filled in together */
+            parameters: components["schemas"]["TemplateCatalogParameterResource"][] | null;
+            /** @description Templates that must be bound alongside this one. Values are `template_key`s */
+            requires: string[] | null;
+            /** @description Whether this template may be bound when `agent_mode` is ACTIVE. It already combines both reasons it may not be — no active variant exists, or this deployment does not have one installed — because the two are rejected identically and call for the same fix */
+            supports_active_mode: boolean;
+            template_key: string;
+        };
+        TemplateCatalogResponseBody: {
+            items: components["schemas"]["TemplateCatalogEntryResource"][] | null;
+        };
         ServerTemplateResource: {
             configured_secret_parameters: string[] | null;
             parameters: {
@@ -1348,7 +1410,11 @@ export interface components {
             total: number;
         };
         TemplateBindingRequest: {
-            /** @description Parameters declared by the template. Secret parameters are supplied in clear text and returned by name only */
+            /**
+             * @description Parameters declared by the template, keyed by `name` from `GET /templates`. This is a full replacement: a parameter that is omitted takes the `default` reported there, so send back the whole `parameters` map read from the machine rather than only the field being changed.
+             *
+             *     Secret parameters are the one exception, because they are never returned and so cannot be sent back. Omit one to keep the value already stored, and supply it only to replace it. An empty or blank value counts as omitted.
+             */
             parameters?: {
                 [key: string]: string;
             };
@@ -2625,6 +2691,35 @@ export interface operations {
             };
         };
     };
+    "list-templates": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TemplateCatalogResponseBody"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
     "list-servers": {
         parameters: {
             query?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leaflow/sdk",
-  "version": "0.28.0",
+  "version": "0.30.0",
   "description": "Leaflow 平台 API 的 TypeScript SDK",
   "license": "MIT",
   "repository": {