@gpuai/sdk 0.3.12 → 0.3.14

package/dist/apis/InferenceApi.d.ts

@@ -12,6 +12,8 @@
 import * as runtime from '../runtime';
 import { type ChatCompletionRequest } from '../models/ChatCompletionRequest';
 import { type ChatCompletionResponse } from '../models/ChatCompletionResponse';
+import { type EmbeddingsRequest } from '../models/EmbeddingsRequest';
+import { type EmbeddingsResponse } from '../models/EmbeddingsResponse';
 import { type ImagesGenerationsRequest } from '../models/ImagesGenerationsRequest';
 import { type ImagesResponse } from '../models/ImagesResponse';
 import { type Model } from '../models/Model';
@@ -25,6 +27,9 @@ export interface CancelVideoRequest {
 export interface CreateChatCompletionRequest {
     chatCompletionRequest: ChatCompletionRequest;
 }
+export interface CreateEmbeddingsRequest {
+    embeddingsRequest: EmbeddingsRequest;
+}
 export interface CreateImageRequest {
     imagesGenerationsRequest: ImagesGenerationsRequest;
     idempotencyKey?: string;
@@ -77,6 +82,20 @@ export declare class InferenceApi extends runtime.BaseAPI {
      * Create a chat completion (OpenAI-compatible)
      */
     createChatCompletion(requestParameters: CreateChatCompletionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ChatCompletionResponse>;
+    /**
+     * Creates request options for createEmbeddings without sending the request
+     */
+    createEmbeddingsRequestOpts(requestParameters: CreateEmbeddingsRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Synchronous text embeddings. Accepts a single string or an array of up to 2048 strings, bounded so the response stays under 64 MiB (about 680 inputs at 4096 dimensions; fewer at a larger `dimensions` value) — over-limit requests are rejected with 400 before any processing. Returns one float vector per input, in request order. Billed on the upstream\'s reported prompt tokens at the model\'s listed input rate, rounded up to the next whole cent per request; an embeddings call emits no completion tokens, so `usage` carries `prompt_tokens` and `total_tokens` only. `encoding_format` accepts only `float` — a value of `base64` is rejected with `unsupported_parameter`. A chat model id on this route returns 404 `model_not_found`: the id is valid, but not on this surface.
+     * Create embeddings (OpenAI-compatible)
+     */
+    createEmbeddingsRaw(requestParameters: CreateEmbeddingsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EmbeddingsResponse>>;
+    /**
+     * Synchronous text embeddings. Accepts a single string or an array of up to 2048 strings, bounded so the response stays under 64 MiB (about 680 inputs at 4096 dimensions; fewer at a larger `dimensions` value) — over-limit requests are rejected with 400 before any processing. Returns one float vector per input, in request order. Billed on the upstream\'s reported prompt tokens at the model\'s listed input rate, rounded up to the next whole cent per request; an embeddings call emits no completion tokens, so `usage` carries `prompt_tokens` and `total_tokens` only. `encoding_format` accepts only `float` — a value of `base64` is rejected with `unsupported_parameter`. A chat model id on this route returns 404 `model_not_found`: the id is valid, but not on this surface.
+     * Create embeddings (OpenAI-compatible)
+     */
+    createEmbeddings(requestParameters: CreateEmbeddingsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EmbeddingsResponse>;
     /**
      * Creates request options for createImage without sending the request
      */

package/dist/apis/InferenceApi.js

@@ -26,6 +26,8 @@ exports.ListModelsModalityEnum = exports.InferenceApi = void 0;
 const runtime = require("../runtime");
 const ChatCompletionRequest_1 = require("../models/ChatCompletionRequest");
 const ChatCompletionResponse_1 = require("../models/ChatCompletionResponse");
+const EmbeddingsRequest_1 = require("../models/EmbeddingsRequest");
+const EmbeddingsResponse_1 = require("../models/EmbeddingsResponse");
 const ImagesGenerationsRequest_1 = require("../models/ImagesGenerationsRequest");
 const ImagesResponse_1 = require("../models/ImagesResponse");
 const Model_1 = require("../models/Model");
@@ -130,6 +132,55 @@ class InferenceApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for createEmbeddings without sending the request
+     */
+    createEmbeddingsRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['embeddingsRequest'] == null) {
+                throw new runtime.RequiredError('embeddingsRequest', 'Required parameter "embeddingsRequest" was null or undefined when calling createEmbeddings().');
+            }
+            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 = `/embeddings`;
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: (0, EmbeddingsRequest_1.EmbeddingsRequestToJSON)(requestParameters['embeddingsRequest']),
+            };
+        });
+    }
+    /**
+     * Synchronous text embeddings. Accepts a single string or an array of up to 2048 strings, bounded so the response stays under 64 MiB (about 680 inputs at 4096 dimensions; fewer at a larger `dimensions` value) — over-limit requests are rejected with 400 before any processing. Returns one float vector per input, in request order. Billed on the upstream\'s reported prompt tokens at the model\'s listed input rate, rounded up to the next whole cent per request; an embeddings call emits no completion tokens, so `usage` carries `prompt_tokens` and `total_tokens` only. `encoding_format` accepts only `float` — a value of `base64` is rejected with `unsupported_parameter`. A chat model id on this route returns 404 `model_not_found`: the id is valid, but not on this surface.
+     * Create embeddings (OpenAI-compatible)
+     */
+    createEmbeddingsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.createEmbeddingsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, EmbeddingsResponse_1.EmbeddingsResponseFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Synchronous text embeddings. Accepts a single string or an array of up to 2048 strings, bounded so the response stays under 64 MiB (about 680 inputs at 4096 dimensions; fewer at a larger `dimensions` value) — over-limit requests are rejected with 400 before any processing. Returns one float vector per input, in request order. Billed on the upstream\'s reported prompt tokens at the model\'s listed input rate, rounded up to the next whole cent per request; an embeddings call emits no completion tokens, so `usage` carries `prompt_tokens` and `total_tokens` only. `encoding_format` accepts only `float` — a value of `base64` is rejected with `unsupported_parameter`. A chat model id on this route returns 404 `model_not_found`: the id is valid, but not on this surface.
+     * Create embeddings (OpenAI-compatible)
+     */
+    createEmbeddings(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.createEmbeddingsRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for createImage 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>;
+}