@gpuai/sdk 0.3.13 → 0.3.15

package/dist/apis/BillingApi.js

@@ -24,6 +24,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BillingApi = void 0;
 const runtime = require("../runtime");
+const Balance_1 = require("../models/Balance");
 const CreateCryptoDepositRequest_1 = require("../models/CreateCryptoDepositRequest");
 const CryptoDeposit_1 = require("../models/CryptoDeposit");
 const ListDeposits200Response_1 = require("../models/ListDeposits200Response");
@@ -82,6 +83,50 @@ class BillingApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for getBalance without sending the request
+     */
+    getBalanceRequestOpts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/billing/balance`;
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Returns the organization\'s credit balance, its auto-pay configuration, and the live burn rate. Requires the `billing:read` scope. The organization is taken from the authenticated API key, never from a parameter.  Divide `balance_cents` by `burn_cents_per_hour` for the remaining runway in hours. The quotient is undefined in three cases a caller must keep apart: `burn_cents_per_hour` is 0 (nothing running, so the balance funds unbounded idle time), it is `null` (the burn rate could not be determined — NOT the same as idle), or the balance is already at or below zero.  This is the balance itself — for spend against a configured cap see `/billing/spending-limit`, and for past consumption see `/usage`.
+     * Get the org credit balance
+     */
+    getBalanceRaw(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getBalanceRequestOpts();
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, Balance_1.BalanceFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Returns the organization\'s credit balance, its auto-pay configuration, and the live burn rate. Requires the `billing:read` scope. The organization is taken from the authenticated API key, never from a parameter.  Divide `balance_cents` by `burn_cents_per_hour` for the remaining runway in hours. The quotient is undefined in three cases a caller must keep apart: `burn_cents_per_hour` is 0 (nothing running, so the balance funds unbounded idle time), it is `null` (the burn rate could not be determined — NOT the same as idle), or the balance is already at or below zero.  This is the balance itself — for spend against a configured cap see `/billing/spending-limit`, and for past consumption see `/usage`.
+     * Get the org credit balance
+     */
+    getBalance(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getBalanceRaw(initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for getDeposit without sending the request
      */

package/dist/apis/MarketApi.d.ts

@@ -0,0 +1,56 @@
+/**
+ * GPU.ai Public Developer API
+ * Programmatic API for GPU.ai. Authenticate with API keys minted from the dashboard. See https://gpu.ai/docs for details.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: support@gpu.ai
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import * as runtime from '../runtime';
+import { type MarketHistoryResponse } from '../models/MarketHistoryResponse';
+export interface GetMarketHistoryRequest {
+    gpuModel: string;
+    region?: string;
+    capacityClass?: GetMarketHistoryCapacityClassEnum;
+    bucket?: GetMarketHistoryBucketEnum;
+    from?: Date;
+    to?: Date;
+}
+/**
+ *
+ */
+export declare class MarketApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for getMarketHistory without sending the request
+     */
+    getMarketHistoryRequestOpts(requestParameters: GetMarketHistoryRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Returns GPU.ai\'s own price and obtainable capacity for one GPU model over a window, at 15-minute or daily resolution. Requires the `market:read` scope (or `full_access`).  THE NULL CONTRACT. `price_per_gpu_hour` and `available_count` are nullable, and the two states are different facts that must not be collapsed:  * a real `0` means we sampled that bucket and the market was sold out; * `null` means we did NOT sample that bucket — a failed poll, a skipped cycle, an incident on our side. It says nothing about supply.  The response materializes the full bucket grid across the window, so a gap has visible width. Do not interpolate across a null: that asserts a continuity the data does not have, and reading one as a zero reports our own outages as supplier stockouts.  PER-GPU NORMALIZATION. `price_per_gpu_hour` is always a per-GPU rate. When it was divided out of a whole-node price, `node_price_per_hour` and `gpu_count` are present and describe that derivation; they are absent for single-GPU capacity. A per-GPU figure presented without that context implies single-GPU rentability that whole-node capacity does not offer.  WINDOW CAPS. `bucket=1d` is capped at 365 days (the retention window). `bucket=15m` is capped at 90 days when BOTH `region` and `capacity_class` are supplied, and at 31 days when either is omitted, because an unscoped 15-minute series scans every region and class in every bucket. An over-wide window is a 400 naming the cap and both escapes, never a silent truncation.  This series carries no upstream supplier identity of any kind: the price is GPU.ai\'s own floor and the count is an aggregate.
+     * Get a GPU\'s price and availability over time
+     */
+    getMarketHistoryRaw(requestParameters: GetMarketHistoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MarketHistoryResponse>>;
+    /**
+     * Returns GPU.ai\'s own price and obtainable capacity for one GPU model over a window, at 15-minute or daily resolution. Requires the `market:read` scope (or `full_access`).  THE NULL CONTRACT. `price_per_gpu_hour` and `available_count` are nullable, and the two states are different facts that must not be collapsed:  * a real `0` means we sampled that bucket and the market was sold out; * `null` means we did NOT sample that bucket — a failed poll, a skipped cycle, an incident on our side. It says nothing about supply.  The response materializes the full bucket grid across the window, so a gap has visible width. Do not interpolate across a null: that asserts a continuity the data does not have, and reading one as a zero reports our own outages as supplier stockouts.  PER-GPU NORMALIZATION. `price_per_gpu_hour` is always a per-GPU rate. When it was divided out of a whole-node price, `node_price_per_hour` and `gpu_count` are present and describe that derivation; they are absent for single-GPU capacity. A per-GPU figure presented without that context implies single-GPU rentability that whole-node capacity does not offer.  WINDOW CAPS. `bucket=1d` is capped at 365 days (the retention window). `bucket=15m` is capped at 90 days when BOTH `region` and `capacity_class` are supplied, and at 31 days when either is omitted, because an unscoped 15-minute series scans every region and class in every bucket. An over-wide window is a 400 naming the cap and both escapes, never a silent truncation.  This series carries no upstream supplier identity of any kind: the price is GPU.ai\'s own floor and the count is an aggregate.
+     * Get a GPU\'s price and availability over time
+     */
+    getMarketHistory(requestParameters: GetMarketHistoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MarketHistoryResponse>;
+}
+/**
+ * @export
+ */
+export declare const GetMarketHistoryCapacityClassEnum: {
+    readonly Secure: "secure";
+    readonly Community: "community";
+};
+export type GetMarketHistoryCapacityClassEnum = typeof GetMarketHistoryCapacityClassEnum[keyof typeof GetMarketHistoryCapacityClassEnum];
+/**
+ * @export
+ */
+export declare const GetMarketHistoryBucketEnum: {
+    readonly _15m: "15m";
+    readonly _1d: "1d";
+};
+export type GetMarketHistoryBucketEnum = typeof GetMarketHistoryBucketEnum[keyof typeof GetMarketHistoryBucketEnum];

package/dist/apis/MarketApi.js

@@ -0,0 +1,112 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * GPU.ai Public Developer API
+ * Programmatic API for GPU.ai. Authenticate with API keys minted from the dashboard. See https://gpu.ai/docs for details.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: support@gpu.ai
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetMarketHistoryBucketEnum = exports.GetMarketHistoryCapacityClassEnum = exports.MarketApi = void 0;
+const runtime = require("../runtime");
+const MarketHistoryResponse_1 = require("../models/MarketHistoryResponse");
+/**
+ *
+ */
+class MarketApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for getMarketHistory without sending the request
+     */
+    getMarketHistoryRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['gpuModel'] == null) {
+                throw new runtime.RequiredError('gpuModel', 'Required parameter "gpuModel" was null or undefined when calling getMarketHistory().');
+            }
+            const queryParameters = {};
+            if (requestParameters['gpuModel'] != null) {
+                queryParameters['gpu_model'] = requestParameters['gpuModel'];
+            }
+            if (requestParameters['region'] != null) {
+                queryParameters['region'] = requestParameters['region'];
+            }
+            if (requestParameters['capacityClass'] != null) {
+                queryParameters['capacity_class'] = requestParameters['capacityClass'];
+            }
+            if (requestParameters['bucket'] != null) {
+                queryParameters['bucket'] = requestParameters['bucket'];
+            }
+            if (requestParameters['from'] != null) {
+                queryParameters['from'] = requestParameters['from'].toISOString();
+            }
+            if (requestParameters['to'] != null) {
+                queryParameters['to'] = requestParameters['to'].toISOString();
+            }
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/market-history`;
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Returns GPU.ai\'s own price and obtainable capacity for one GPU model over a window, at 15-minute or daily resolution. Requires the `market:read` scope (or `full_access`).  THE NULL CONTRACT. `price_per_gpu_hour` and `available_count` are nullable, and the two states are different facts that must not be collapsed:  * a real `0` means we sampled that bucket and the market was sold out; * `null` means we did NOT sample that bucket — a failed poll, a skipped cycle, an incident on our side. It says nothing about supply.  The response materializes the full bucket grid across the window, so a gap has visible width. Do not interpolate across a null: that asserts a continuity the data does not have, and reading one as a zero reports our own outages as supplier stockouts.  PER-GPU NORMALIZATION. `price_per_gpu_hour` is always a per-GPU rate. When it was divided out of a whole-node price, `node_price_per_hour` and `gpu_count` are present and describe that derivation; they are absent for single-GPU capacity. A per-GPU figure presented without that context implies single-GPU rentability that whole-node capacity does not offer.  WINDOW CAPS. `bucket=1d` is capped at 365 days (the retention window). `bucket=15m` is capped at 90 days when BOTH `region` and `capacity_class` are supplied, and at 31 days when either is omitted, because an unscoped 15-minute series scans every region and class in every bucket. An over-wide window is a 400 naming the cap and both escapes, never a silent truncation.  This series carries no upstream supplier identity of any kind: the price is GPU.ai\'s own floor and the count is an aggregate.
+     * Get a GPU\'s price and availability over time
+     */
+    getMarketHistoryRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getMarketHistoryRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, MarketHistoryResponse_1.MarketHistoryResponseFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Returns GPU.ai\'s own price and obtainable capacity for one GPU model over a window, at 15-minute or daily resolution. Requires the `market:read` scope (or `full_access`).  THE NULL CONTRACT. `price_per_gpu_hour` and `available_count` are nullable, and the two states are different facts that must not be collapsed:  * a real `0` means we sampled that bucket and the market was sold out; * `null` means we did NOT sample that bucket — a failed poll, a skipped cycle, an incident on our side. It says nothing about supply.  The response materializes the full bucket grid across the window, so a gap has visible width. Do not interpolate across a null: that asserts a continuity the data does not have, and reading one as a zero reports our own outages as supplier stockouts.  PER-GPU NORMALIZATION. `price_per_gpu_hour` is always a per-GPU rate. When it was divided out of a whole-node price, `node_price_per_hour` and `gpu_count` are present and describe that derivation; they are absent for single-GPU capacity. A per-GPU figure presented without that context implies single-GPU rentability that whole-node capacity does not offer.  WINDOW CAPS. `bucket=1d` is capped at 365 days (the retention window). `bucket=15m` is capped at 90 days when BOTH `region` and `capacity_class` are supplied, and at 31 days when either is omitted, because an unscoped 15-minute series scans every region and class in every bucket. An over-wide window is a 400 naming the cap and both escapes, never a silent truncation.  This series carries no upstream supplier identity of any kind: the price is GPU.ai\'s own floor and the count is an aggregate.
+     * Get a GPU\'s price and availability over time
+     */
+    getMarketHistory(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getMarketHistoryRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+}
+exports.MarketApi = MarketApi;
+/**
+ * @export
+ */
+exports.GetMarketHistoryCapacityClassEnum = {
+    Secure: 'secure',
+    Community: 'community'
+};
+/**
+ * @export
+ */
+exports.GetMarketHistoryBucketEnum = {
+    _15m: '15m',
+    _1d: '1d'
+};

package/dist/apis/WatchApi.d.ts

@@ -0,0 +1,109 @@
+/**
+ * GPU.ai Public Developer API
+ * Programmatic API for GPU.ai. Authenticate with API keys minted from the dashboard. See https://gpu.ai/docs for details.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: support@gpu.ai
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import * as runtime from '../runtime';
+import { type WatchRule } from '../models/WatchRule';
+import { type WatchRuleCreate } from '../models/WatchRuleCreate';
+import { type WatchRulePage } from '../models/WatchRulePage';
+import { type WatchRuleUpdate } from '../models/WatchRuleUpdate';
+export interface CreateWatchRuleRequest {
+    watchRuleCreate: WatchRuleCreate;
+    idempotencyKey?: string;
+}
+export interface DeleteWatchRuleRequest {
+    id: string;
+}
+export interface GetWatchRuleRequest {
+    id: string;
+}
+export interface ListWatchRulesRequest {
+    cursor?: string;
+    limit?: number;
+}
+export interface UpdateWatchRuleRequest {
+    id: string;
+    watchRuleUpdate: WatchRuleUpdate;
+}
+/**
+ *
+ */
+export declare class WatchApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for createWatchRule without sending the request
+     */
+    createWatchRuleRequestOpts(requestParameters: CreateWatchRuleRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Creates a rule that notifies you when the market moves on a GPU model. Requires the `watch:write` scope (or `full_access`).  A watch rule ONLY notifies. It cannot launch capacity and cannot spend money: there is no field on this resource that provisions anything. Automatic launching is a separate resource with its own spend-consent gate.  Targeting is dimensional — a GPU model plus optional canonical region and capacity class. It is deliberately NOT possible to pin a rule to a specific catalog listing: listing identity is unstable, so a pinned rule can silently match nothing and never fire.  Delivery is to the organization\'s registered webhook endpoints, plus an email to the rule\'s creator. `webhook_endpoint_override_id` routes one rule to one specific endpoint and is the id of an endpoint already registered via `/webhook-endpoints` — the resource accepts no URL of any kind.  Organizations are limited to 50 ENABLED rules; the 422 names the limit.
+     * Create a watch rule
+     */
+    createWatchRuleRaw(requestParameters: CreateWatchRuleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WatchRule>>;
+    /**
+     * Creates a rule that notifies you when the market moves on a GPU model. Requires the `watch:write` scope (or `full_access`).  A watch rule ONLY notifies. It cannot launch capacity and cannot spend money: there is no field on this resource that provisions anything. Automatic launching is a separate resource with its own spend-consent gate.  Targeting is dimensional — a GPU model plus optional canonical region and capacity class. It is deliberately NOT possible to pin a rule to a specific catalog listing: listing identity is unstable, so a pinned rule can silently match nothing and never fire.  Delivery is to the organization\'s registered webhook endpoints, plus an email to the rule\'s creator. `webhook_endpoint_override_id` routes one rule to one specific endpoint and is the id of an endpoint already registered via `/webhook-endpoints` — the resource accepts no URL of any kind.  Organizations are limited to 50 ENABLED rules; the 422 names the limit.
+     * Create a watch rule
+     */
+    createWatchRule(requestParameters: CreateWatchRuleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WatchRule>;
+    /**
+     * Creates request options for deleteWatchRule without sending the request
+     */
+    deleteWatchRuleRequestOpts(requestParameters: DeleteWatchRuleRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Deletes a watch rule. Requires the `watch:write` scope (or `full_access`). Deleting an already-deleted rule returns 404.
+     * Delete a watch rule
+     */
+    deleteWatchRuleRaw(requestParameters: DeleteWatchRuleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Deletes a watch rule. Requires the `watch:write` scope (or `full_access`). Deleting an already-deleted rule returns 404.
+     * Delete a watch rule
+     */
+    deleteWatchRule(requestParameters: DeleteWatchRuleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Creates request options for getWatchRule without sending the request
+     */
+    getWatchRuleRequestOpts(requestParameters: GetWatchRuleRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Fetches one watch rule. Requires the `watch:read` scope (or `full_access`). A rule belonging to another organization returns 404 — the same answer as an id that does not exist.
+     * Get a watch rule
+     */
+    getWatchRuleRaw(requestParameters: GetWatchRuleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WatchRule>>;
+    /**
+     * Fetches one watch rule. Requires the `watch:read` scope (or `full_access`). A rule belonging to another organization returns 404 — the same answer as an id that does not exist.
+     * Get a watch rule
+     */
+    getWatchRule(requestParameters: GetWatchRuleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WatchRule>;
+    /**
+     * Creates request options for listWatchRules without sending the request
+     */
+    listWatchRulesRequestOpts(requestParameters: ListWatchRulesRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Lists this organization\'s watch rules. Requires the `watch:read` scope (or `full_access`). Rules belonging to other organizations are never returned.
+     * List watch rules
+     */
+    listWatchRulesRaw(requestParameters: ListWatchRulesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WatchRulePage>>;
+    /**
+     * Lists this organization\'s watch rules. Requires the `watch:read` scope (or `full_access`). Rules belonging to other organizations are never returned.
+     * List watch rules
+     */
+    listWatchRules(requestParameters?: ListWatchRulesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WatchRulePage>;
+    /**
+     * Creates request options for updateWatchRule without sending the request
+     */
+    updateWatchRuleRequestOpts(requestParameters: UpdateWatchRuleRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Partially updates a watch rule. Requires the `watch:write` scope (or `full_access`).  An ABSENT key keeps the stored value; an explicit `null` on `region`, `capacity_class` or `webhook_endpoint_override_id` CLEARS it back to \"any\" / \"organization default\". The two are distinguished by which keys the body carries, so send only the keys you mean to change.  Editing a rule RE-ARMS it: the fired latch describes the condition that was replaced, so carrying it across an edit would suppress the first alert on the new one.
+     * Update a watch rule
+     */
+    updateWatchRuleRaw(requestParameters: UpdateWatchRuleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WatchRule>>;
+    /**
+     * Partially updates a watch rule. Requires the `watch:write` scope (or `full_access`).  An ABSENT key keeps the stored value; an explicit `null` on `region`, `capacity_class` or `webhook_endpoint_override_id` CLEARS it back to \"any\" / \"organization default\". The two are distinguished by which keys the body carries, so send only the keys you mean to change.  Editing a rule RE-ARMS it: the fired latch describes the condition that was replaced, so carrying it across an edit would suppress the first alert on the new one.
+     * Update a watch rule
+     */
+    updateWatchRule(requestParameters: UpdateWatchRuleRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WatchRule>;
+}

package/dist/apis/WatchApi.js

@@ -0,0 +1,286 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * GPU.ai Public Developer API
+ * Programmatic API for GPU.ai. Authenticate with API keys minted from the dashboard. See https://gpu.ai/docs for details.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: support@gpu.ai
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchApi = void 0;
+const runtime = require("../runtime");
+const WatchRule_1 = require("../models/WatchRule");
+const WatchRuleCreate_1 = require("../models/WatchRuleCreate");
+const WatchRulePage_1 = require("../models/WatchRulePage");
+const WatchRuleUpdate_1 = require("../models/WatchRuleUpdate");
+/**
+ *
+ */
+class WatchApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for createWatchRule without sending the request
+     */
+    createWatchRuleRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['watchRuleCreate'] == null) {
+                throw new runtime.RequiredError('watchRuleCreate', 'Required parameter "watchRuleCreate" was null or undefined when calling createWatchRule().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (requestParameters['idempotencyKey'] != null) {
+                headerParameters['Idempotency-Key'] = String(requestParameters['idempotencyKey']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/watch-rules`;
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: (0, WatchRuleCreate_1.WatchRuleCreateToJSON)(requestParameters['watchRuleCreate']),
+            };
+        });
+    }
+    /**
+     * Creates a rule that notifies you when the market moves on a GPU model. Requires the `watch:write` scope (or `full_access`).  A watch rule ONLY notifies. It cannot launch capacity and cannot spend money: there is no field on this resource that provisions anything. Automatic launching is a separate resource with its own spend-consent gate.  Targeting is dimensional — a GPU model plus optional canonical region and capacity class. It is deliberately NOT possible to pin a rule to a specific catalog listing: listing identity is unstable, so a pinned rule can silently match nothing and never fire.  Delivery is to the organization\'s registered webhook endpoints, plus an email to the rule\'s creator. `webhook_endpoint_override_id` routes one rule to one specific endpoint and is the id of an endpoint already registered via `/webhook-endpoints` — the resource accepts no URL of any kind.  Organizations are limited to 50 ENABLED rules; the 422 names the limit.
+     * Create a watch rule
+     */
+    createWatchRuleRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.createWatchRuleRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, WatchRule_1.WatchRuleFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Creates a rule that notifies you when the market moves on a GPU model. Requires the `watch:write` scope (or `full_access`).  A watch rule ONLY notifies. It cannot launch capacity and cannot spend money: there is no field on this resource that provisions anything. Automatic launching is a separate resource with its own spend-consent gate.  Targeting is dimensional — a GPU model plus optional canonical region and capacity class. It is deliberately NOT possible to pin a rule to a specific catalog listing: listing identity is unstable, so a pinned rule can silently match nothing and never fire.  Delivery is to the organization\'s registered webhook endpoints, plus an email to the rule\'s creator. `webhook_endpoint_override_id` routes one rule to one specific endpoint and is the id of an endpoint already registered via `/webhook-endpoints` — the resource accepts no URL of any kind.  Organizations are limited to 50 ENABLED rules; the 422 names the limit.
+     * Create a watch rule
+     */
+    createWatchRule(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.createWatchRuleRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for deleteWatchRule without sending the request
+     */
+    deleteWatchRuleRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteWatchRule().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/watch-rules/{id}`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            return {
+                path: urlPath,
+                method: 'DELETE',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Deletes a watch rule. Requires the `watch:write` scope (or `full_access`). Deleting an already-deleted rule returns 404.
+     * Delete a watch rule
+     */
+    deleteWatchRuleRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.deleteWatchRuleRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Deletes a watch rule. Requires the `watch:write` scope (or `full_access`). Deleting an already-deleted rule returns 404.
+     * Delete a watch rule
+     */
+    deleteWatchRule(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.deleteWatchRuleRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Creates request options for getWatchRule without sending the request
+     */
+    getWatchRuleRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getWatchRule().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/watch-rules/{id}`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Fetches one watch rule. Requires the `watch:read` scope (or `full_access`). A rule belonging to another organization returns 404 — the same answer as an id that does not exist.
+     * Get a watch rule
+     */
+    getWatchRuleRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getWatchRuleRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, WatchRule_1.WatchRuleFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Fetches one watch rule. Requires the `watch:read` scope (or `full_access`). A rule belonging to another organization returns 404 — the same answer as an id that does not exist.
+     * Get a watch rule
+     */
+    getWatchRule(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getWatchRuleRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for listWatchRules without sending the request
+     */
+    listWatchRulesRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameters = {};
+            if (requestParameters['cursor'] != null) {
+                queryParameters['cursor'] = requestParameters['cursor'];
+            }
+            if (requestParameters['limit'] != null) {
+                queryParameters['limit'] = requestParameters['limit'];
+            }
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/watch-rules`;
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Lists this organization\'s watch rules. Requires the `watch:read` scope (or `full_access`). Rules belonging to other organizations are never returned.
+     * List watch rules
+     */
+    listWatchRulesRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.listWatchRulesRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, WatchRulePage_1.WatchRulePageFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Lists this organization\'s watch rules. Requires the `watch:read` scope (or `full_access`). Rules belonging to other organizations are never returned.
+     * List watch rules
+     */
+    listWatchRules() {
+        return __awaiter(this, arguments, void 0, function* (requestParameters = {}, initOverrides) {
+            const response = yield this.listWatchRulesRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for updateWatchRule without sending the request
+     */
+    updateWatchRuleRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateWatchRule().');
+            }
+            if (requestParameters['watchRuleUpdate'] == null) {
+                throw new runtime.RequiredError('watchRuleUpdate', 'Required parameter "watchRuleUpdate" was null or undefined when calling updateWatchRule().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/watch-rules/{id}`;
+            urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
+            return {
+                path: urlPath,
+                method: 'PATCH',
+                headers: headerParameters,
+                query: queryParameters,
+                body: (0, WatchRuleUpdate_1.WatchRuleUpdateToJSON)(requestParameters['watchRuleUpdate']),
+            };
+        });
+    }
+    /**
+     * Partially updates a watch rule. Requires the `watch:write` scope (or `full_access`).  An ABSENT key keeps the stored value; an explicit `null` on `region`, `capacity_class` or `webhook_endpoint_override_id` CLEARS it back to \"any\" / \"organization default\". The two are distinguished by which keys the body carries, so send only the keys you mean to change.  Editing a rule RE-ARMS it: the fired latch describes the condition that was replaced, so carrying it across an edit would suppress the first alert on the new one.
+     * Update a watch rule
+     */
+    updateWatchRuleRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.updateWatchRuleRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, WatchRule_1.WatchRuleFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Partially updates a watch rule. Requires the `watch:write` scope (or `full_access`).  An ABSENT key keeps the stored value; an explicit `null` on `region`, `capacity_class` or `webhook_endpoint_override_id` CLEARS it back to \"any\" / \"organization default\". The two are distinguished by which keys the body carries, so send only the keys you mean to change.  Editing a rule RE-ARMS it: the fired latch describes the condition that was replaced, so carrying it across an edit would suppress the first alert on the new one.
+     * Update a watch rule
+     */
+    updateWatchRule(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.updateWatchRuleRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+}
+exports.WatchApi = WatchApi;

package/dist/apis/index.d.ts

@@ -1,3 +1,4 @@
+export * from './AutolaunchApi';
 export * from './BillingApi';
 export * from './CommunityApi';
 export * from './EnvironmentsApi';
@@ -5,6 +6,7 @@ export * from './FineTuningApi';
 export * from './GpuTypesApi';
 export * from './InferenceApi';
 export * from './InstancesApi';
+export * from './MarketApi';
 export * from './MetaApi';
 export * from './OperationsApi';
 export * from './PricingApi';
@@ -12,4 +14,5 @@ export * from './RegistryCredentialsApi';
 export * from './SshKeysApi';
 export * from './TemplatesApi';
 export * from './UsageApi';
+export * from './WatchApi';
 export * from './WebhooksApi';