@gpuai/sdk 0.3.12 → 0.3.14

package/dist/esm/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/esm/apis/WatchApi.js

@@ -0,0 +1,282 @@
+/* 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());
+    });
+};
+import * as runtime from '../runtime';
+import { WatchRuleFromJSON, } from '../models/WatchRule';
+import { WatchRuleCreateToJSON, } from '../models/WatchRuleCreate';
+import { WatchRulePageFromJSON, } from '../models/WatchRulePage';
+import { WatchRuleUpdateToJSON, } from '../models/WatchRuleUpdate';
+/**
+ *
+ */
+export 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: 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) => 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) => 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) => 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: 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) => 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();
+        });
+    }
+}

package/dist/esm/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';

package/dist/esm/apis/index.js

@@ -1,5 +1,6 @@
 /* tslint:disable */
 /* eslint-disable */
+export * from './AutolaunchApi';
 export * from './BillingApi';
 export * from './CommunityApi';
 export * from './EnvironmentsApi';
@@ -7,6 +8,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';
@@ -14,4 +16,5 @@ export * from './RegistryCredentialsApi';
 export * from './SshKeysApi';
 export * from './TemplatesApi';
 export * from './UsageApi';
+export * from './WatchApi';
 export * from './WebhooksApi';

package/dist/esm/models/AutolaunchRule.d.ts

@@ -0,0 +1,181 @@
+/**
+ * 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.
+ */
+/**
+ * A standing, pre-approved purchase order. It carries no upstream supplier identity, no org id, and no identifier of the API key that consented — the consenting principal is recorded in storage for the fire-time re-check, and a credential identifier has no business in a rule listing.
+ *
+ * @export
+ * @interface AutolaunchRule
+ */
+export interface AutolaunchRule {
+    /**
+     *
+     * @type {string}
+     * @memberof AutolaunchRule
+     */
+    id: string;
+    /**
+     * The GPU model the rule watches and launches, e.g. "H100".
+     * @type {string}
+     * @memberof AutolaunchRule
+     */
+    gpuModel: string;
+    /**
+     * Canonical region the rule is narrowed to, or null for every region.
+     * @type {string}
+     * @memberof AutolaunchRule
+     */
+    region: string | null;
+    /**
+     * Capacity class the rule is narrowed to, or null for both.
+     * @type {AutolaunchRuleCapacityClassEnum}
+     * @memberof AutolaunchRule
+     */
+    capacityClass: AutolaunchRuleCapacityClassEnum | null;
+    /**
+     *
+     * @type {AutolaunchRuleConditionKindEnum}
+     * @memberof AutolaunchRule
+     */
+    conditionKind: AutolaunchRuleConditionKindEnum;
+    /**
+     * The TRIGGER. Dollars PER GPU-HOUR for price_under, or a unit count for count_at_least. Null for in_stock. This is NOT the spend cap — see max_price_per_hour, which is in a different unit.
+     *
+     * @type {number}
+     * @memberof AutolaunchRule
+     */
+    threshold: number | null;
+    /**
+     * The CEILING, and the consent. Dollars per hour for the WHOLE INSTANCE, not per GPU. The launch is abandoned — never repriced — if the live price exceeds it.
+     *
+     * @type {number}
+     * @memberof AutolaunchRule
+     */
+    maxPricePerHour: number;
+    /**
+     * How long an auto-launched instance may run before the platform terminates it, enforced through the instance's own auto_terminate_hours.
+     *
+     * @type {number}
+     * @memberof AutolaunchRule
+     */
+    maxRuntimeHours: number;
+    /**
+     * The worst-case total the customer approved: max_price_per_hour × max_runtime_hours, computed by the server and echoed on every read so a client never has to derive the number it is displaying.
+     *
+     * @type {number}
+     * @memberof AutolaunchRule
+     */
+    maxTotalUsd: number;
+    /**
+     * The frozen launch spec, as READ. Every value under `env` is returned as the literal `[REDACTED]` — the key names are kept so you can see what the launch will set, but the values are not readable back on any surface, by any scope. Reading a rule needs only `autolaunch:read`, which every full_access, standard and read_only key holds, so a rule listing must not be a credential listing.
+     * This changes nothing about what the rule DOES: the stored spec keeps the real values and replays them at fire time. If you need to change a token, delete the rule and create a new one.
+     *
+     * @type {{ [key: string]: any; }}
+     * @memberof AutolaunchRule
+     */
+    spec: {
+        [key: string]: any;
+    };
+    /**
+     * armed = waiting for the condition. launching = an attempt is in flight. fired = a successful launch consumed the rule's one shot. expired = the per-edge attempt budget ran out. A lost capacity race costs nothing and does NOT consume the shot.
+     *
+     * @type {AutolaunchRuleStateEnum}
+     * @memberof AutolaunchRule
+     */
+    state: AutolaunchRuleStateEnum;
+    /**
+     * Launch attempts made since the current condition edge began.
+     * @type {number}
+     * @memberof AutolaunchRule
+     */
+    attemptsThisEdge: number;
+    /**
+     * Why the last attempt did not buy anything: over_ceiling, capacity_race, stale_reference, key_revoked, authority_revoked or validation_failed, optionally with a colon-separated detail. Match the leading token. It never carries API key material.
+     *
+     * @type {string}
+     * @memberof AutolaunchRule
+     */
+    lastFailureReason: string | null;
+    /**
+     * The instance this rule launched, once it has fired.
+     * @type {string}
+     * @memberof AutolaunchRule
+     */
+    launchedInstanceId: string | null;
+    /**
+     * Which entrance consented. A dashboard rule has no API key behind it, which is why its fire-time revocation failure is `authority_revoked` (the approving admin was demoted) rather than `key_revoked`.
+     *
+     * @type {AutolaunchRuleCreatedBySurfaceEnum}
+     * @memberof AutolaunchRule
+     */
+    createdBySurface: AutolaunchRuleCreatedBySurfaceEnum;
+    /**
+     * False once disarmed or cancelled. A disarmed rule cannot be re-armed.
+     * @type {boolean}
+     * @memberof AutolaunchRule
+     */
+    enabled: boolean;
+    /**
+     *
+     * @type {Date}
+     * @memberof AutolaunchRule
+     */
+    createdAt: Date;
+    /**
+     *
+     * @type {Date}
+     * @memberof AutolaunchRule
+     */
+    updatedAt: Date;
+}
+/**
+ * @export
+ */
+export declare const AutolaunchRuleCapacityClassEnum: {
+    readonly Secure: "secure";
+    readonly Community: "community";
+};
+export type AutolaunchRuleCapacityClassEnum = typeof AutolaunchRuleCapacityClassEnum[keyof typeof AutolaunchRuleCapacityClassEnum];
+/**
+ * @export
+ */
+export declare const AutolaunchRuleConditionKindEnum: {
+    readonly PriceUnder: "price_under";
+    readonly InStock: "in_stock";
+    readonly CountAtLeast: "count_at_least";
+};
+export type AutolaunchRuleConditionKindEnum = typeof AutolaunchRuleConditionKindEnum[keyof typeof AutolaunchRuleConditionKindEnum];
+/**
+ * @export
+ */
+export declare const AutolaunchRuleStateEnum: {
+    readonly Armed: "armed";
+    readonly Launching: "launching";
+    readonly Fired: "fired";
+    readonly Expired: "expired";
+};
+export type AutolaunchRuleStateEnum = typeof AutolaunchRuleStateEnum[keyof typeof AutolaunchRuleStateEnum];
+/**
+ * @export
+ */
+export declare const AutolaunchRuleCreatedBySurfaceEnum: {
+    readonly ApiKey: "api_key";
+    readonly Dashboard: "dashboard";
+};
+export type AutolaunchRuleCreatedBySurfaceEnum = typeof AutolaunchRuleCreatedBySurfaceEnum[keyof typeof AutolaunchRuleCreatedBySurfaceEnum];
+/**
+ * Check if a given object implements the AutolaunchRule interface.
+ */
+export declare function instanceOfAutolaunchRule(value: object): value is AutolaunchRule;
+export declare function AutolaunchRuleFromJSON(json: any): AutolaunchRule;
+export declare function AutolaunchRuleFromJSONTyped(json: any, ignoreDiscriminator: boolean): AutolaunchRule;
+export declare function AutolaunchRuleToJSON(json: any): AutolaunchRule;
+export declare function AutolaunchRuleToJSONTyped(value?: AutolaunchRule | null, ignoreDiscriminator?: boolean): any;