@deeprelay/sdk 0.1.0 → 0.1.2

package/.openapi-generator/FILES

@@ -21,6 +21,7 @@ docs/ImagesResponse.md
 docs/ImagesResponseDataInner.md
 docs/ImagesResponseUsage.md
 docs/InferenceApi.md
+docs/InferencePreflight.md
 docs/ListDeposits200Response.md
 docs/MetaApi.md
 docs/Model.md
@@ -36,10 +37,16 @@ docs/OperationResult.md
 docs/OperationsApi.md
 docs/PeakWindow.md
 docs/Problem.md
+docs/RefereeStatus.md
+docs/Referral.md
 docs/SpendingLimit.md
 docs/StreamOptions.md
 docs/Subscription.md
+docs/SubscriptionCheckoutRequest.md
+docs/SubscriptionCheckoutSession.md
 docs/SubscriptionPlan.md
+docs/SubscriptionPortalRequest.md
+docs/SubscriptionPortalSession.md
 docs/SubscriptionPrice.md
 docs/SubscriptionQuota.md
 docs/SubscriptionUsage.md
@@ -81,6 +88,7 @@ src/models/ImagesGenerationsRequest.ts
 src/models/ImagesResponse.ts
 src/models/ImagesResponseDataInner.ts
 src/models/ImagesResponseUsage.ts
+src/models/InferencePreflight.ts
 src/models/ListDeposits200Response.ts
 src/models/Model.ts
 src/models/ModelList.ts
@@ -94,10 +102,16 @@ src/models/OperationError.ts
 src/models/OperationResult.ts
 src/models/PeakWindow.ts
 src/models/Problem.ts
+src/models/RefereeStatus.ts
+src/models/Referral.ts
 src/models/SpendingLimit.ts
 src/models/StreamOptions.ts
 src/models/Subscription.ts
+src/models/SubscriptionCheckoutRequest.ts
+src/models/SubscriptionCheckoutSession.ts
 src/models/SubscriptionPlan.ts
+src/models/SubscriptionPortalRequest.ts
+src/models/SubscriptionPortalSession.ts
 src/models/SubscriptionPrice.ts
 src/models/SubscriptionQuota.ts
 src/models/SubscriptionUsage.ts

package/README.md

@@ -1,4 +1,4 @@
-# @deeprelay/sdk@0.1.0
+# @deeprelay/sdk@0.1.2
 
 A TypeScript SDK client for the api.deeprelay.ai API.
 
@@ -55,8 +55,11 @@ All URIs are relative to *https://api.deeprelay.ai/v1*
 | Class | Method | HTTP request | Description
 | ----- | ------ | ------------ | -------------
 *BillingApi* | [**createCryptoDeposit**](docs/BillingApi.md#createcryptodepositoperation) | **POST** /billing/deposits/crypto | Create a stablecoin deposit
+*BillingApi* | [**createSubscriptionCheckout**](docs/BillingApi.md#createsubscriptioncheckout) | **POST** /billing/subscription/checkout | Start a subscription checkout session
+*BillingApi* | [**createSubscriptionPortal**](docs/BillingApi.md#createsubscriptionportal) | **POST** /billing/subscription/portal | Open the billing portal to cancel or manage the subscription
 *BillingApi* | [**getBalance**](docs/BillingApi.md#getbalance) | **GET** /billing/balance | Get the org credit balance
 *BillingApi* | [**getDeposit**](docs/BillingApi.md#getdeposit) | **GET** /billing/deposits/{id} | Get one stablecoin deposit
+*BillingApi* | [**getReferral**](docs/BillingApi.md#getreferral) | **GET** /referrals | Get the org referral code, invite link, terms and stats
 *BillingApi* | [**getSpendingLimit**](docs/BillingApi.md#getspendinglimit) | **GET** /billing/spending-limit | Get the org spending limit
 *BillingApi* | [**getSubscription**](docs/BillingApi.md#getsubscription) | **GET** /billing/subscription | Get the org subscription status and quota usage
 *BillingApi* | [**listDeposits**](docs/BillingApi.md#listdeposits) | **GET** /billing/deposits | List stablecoin deposits
@@ -69,6 +72,7 @@ All URIs are relative to *https://api.deeprelay.ai/v1*
 *InferenceApi* | [**getModel**](docs/InferenceApi.md#getmodel) | **GET** /models/{id} | Get a specific model (OpenAI-compatible)
 *InferenceApi* | [**getVideo**](docs/InferenceApi.md#getvideo) | **GET** /videos/{id} | Get a video generation job
 *InferenceApi* | [**getVideoContent**](docs/InferenceApi.md#getvideocontent) | **GET** /videos/{id}/content | Download a completed video artifact
+*InferenceApi* | [**inferencePreflight**](docs/InferenceApi.md#inferencepreflight) | **GET** /inference/preflight | Check whether a model request would be served, and at whose expense
 *InferenceApi* | [**listModels**](docs/InferenceApi.md#listmodels) | **GET** /models | List available models (OpenAI-compatible)
 *InferenceApi* | [**listVideos**](docs/InferenceApi.md#listvideos) | **GET** /videos | List video generation jobs
 *MetaApi* | [**getHealth**](docs/MetaApi.md#gethealth) | **GET** /health | Liveness probe
@@ -101,6 +105,7 @@ All URIs are relative to *https://api.deeprelay.ai/v1*
 - [ImagesResponse](docs/ImagesResponse.md)
 - [ImagesResponseDataInner](docs/ImagesResponseDataInner.md)
 - [ImagesResponseUsage](docs/ImagesResponseUsage.md)
+- [InferencePreflight](docs/InferencePreflight.md)
 - [ListDeposits200Response](docs/ListDeposits200Response.md)
 - [Model](docs/Model.md)
 - [ModelList](docs/ModelList.md)
@@ -114,10 +119,16 @@ All URIs are relative to *https://api.deeprelay.ai/v1*
 - [OperationResult](docs/OperationResult.md)
 - [PeakWindow](docs/PeakWindow.md)
 - [Problem](docs/Problem.md)
+- [RefereeStatus](docs/RefereeStatus.md)
+- [Referral](docs/Referral.md)
 - [SpendingLimit](docs/SpendingLimit.md)
 - [StreamOptions](docs/StreamOptions.md)
 - [Subscription](docs/Subscription.md)
+- [SubscriptionCheckoutRequest](docs/SubscriptionCheckoutRequest.md)
+- [SubscriptionCheckoutSession](docs/SubscriptionCheckoutSession.md)
 - [SubscriptionPlan](docs/SubscriptionPlan.md)
+- [SubscriptionPortalRequest](docs/SubscriptionPortalRequest.md)
+- [SubscriptionPortalSession](docs/SubscriptionPortalSession.md)
 - [SubscriptionPrice](docs/SubscriptionPrice.md)
 - [SubscriptionQuota](docs/SubscriptionQuota.md)
 - [SubscriptionUsage](docs/SubscriptionUsage.md)
@@ -148,7 +159,7 @@ and is automatically generated by the
 [OpenAPI Generator](https://openapi-generator.tech) project:
 
 - API version: `1.0.0`
-- Package version: `0.1.0`
+- Package version: `0.1.2`
 - Generator version: `7.24.0`
 - Build package: `org.openapitools.codegen.languages.TypeScriptFetchClientCodegen`
 

package/dist/apis/BillingApi.d.ts

@@ -14,12 +14,23 @@ import { type Balance } from '../models/Balance';
 import { type CreateCryptoDepositRequest } from '../models/CreateCryptoDepositRequest';
 import { type CryptoDeposit } from '../models/CryptoDeposit';
 import { type ListDeposits200Response } from '../models/ListDeposits200Response';
+import { type Referral } from '../models/Referral';
 import { type SpendingLimit } from '../models/SpendingLimit';
 import { type Subscription } from '../models/Subscription';
+import { type SubscriptionCheckoutRequest } from '../models/SubscriptionCheckoutRequest';
+import { type SubscriptionCheckoutSession } from '../models/SubscriptionCheckoutSession';
+import { type SubscriptionPortalRequest } from '../models/SubscriptionPortalRequest';
+import { type SubscriptionPortalSession } from '../models/SubscriptionPortalSession';
 import { type UpdateSpendingLimitRequest } from '../models/UpdateSpendingLimitRequest';
 export interface CreateCryptoDepositOperationRequest {
     createCryptoDepositRequest: CreateCryptoDepositRequest;
 }
+export interface CreateSubscriptionCheckoutRequest {
+    subscriptionCheckoutRequest?: SubscriptionCheckoutRequest;
+}
+export interface CreateSubscriptionPortalRequest {
+    subscriptionPortalRequest?: SubscriptionPortalRequest;
+}
 export interface GetDepositRequest {
     id: string;
 }
@@ -44,6 +55,34 @@ export declare class BillingApi extends runtime.BaseAPI {
      * Create a stablecoin deposit
      */
     createCryptoDeposit(requestParameters: CreateCryptoDepositOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CryptoDeposit>;
+    /**
+     * Creates request options for createSubscriptionCheckout without sending the request
+     */
+    createSubscriptionCheckoutRequestOpts(requestParameters: CreateSubscriptionCheckoutRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Opens a hosted checkout session for the flat tier and returns its URL. Requires the `billing:write` scope AND organization-admin privileges — subscribing spends organization money.  This endpoint does NOT subscribe anyone. Checkout is a hosted page that needs a browser and a card, so the caller\'s job is to put the returned URL in front of a human. The subscription becomes active when payment completes, which is not synchronous with this call: poll `/billing/subscription` to confirm.  `success_url` and `cancel_url` are optional and fall back to the deployment\'s configured redirects, which is what lets a command-line client start a purchase without having any URLs of its own. An empty request body is valid and means \"use every default\".  `plan_key`, when sent, pins the plan the client DISPLAYED: an unknown key is a 400 rather than a silent purchase of a different tier. Today there is one tier, so the only accepted value is its key — but sending it is the forward-compatible choice.  One flat tier means at most one subscription per organization: a second checkout while an entitling subscription exists is a 409.
+     * Start a subscription checkout session
+     */
+    createSubscriptionCheckoutRaw(requestParameters: CreateSubscriptionCheckoutRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SubscriptionCheckoutSession>>;
+    /**
+     * Opens a hosted checkout session for the flat tier and returns its URL. Requires the `billing:write` scope AND organization-admin privileges — subscribing spends organization money.  This endpoint does NOT subscribe anyone. Checkout is a hosted page that needs a browser and a card, so the caller\'s job is to put the returned URL in front of a human. The subscription becomes active when payment completes, which is not synchronous with this call: poll `/billing/subscription` to confirm.  `success_url` and `cancel_url` are optional and fall back to the deployment\'s configured redirects, which is what lets a command-line client start a purchase without having any URLs of its own. An empty request body is valid and means \"use every default\".  `plan_key`, when sent, pins the plan the client DISPLAYED: an unknown key is a 400 rather than a silent purchase of a different tier. Today there is one tier, so the only accepted value is its key — but sending it is the forward-compatible choice.  One flat tier means at most one subscription per organization: a second checkout while an entitling subscription exists is a 409.
+     * Start a subscription checkout session
+     */
+    createSubscriptionCheckout(requestParameters?: CreateSubscriptionCheckoutRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SubscriptionCheckoutSession>;
+    /**
+     * Creates request options for createSubscriptionPortal without sending the request
+     */
+    createSubscriptionPortalRequestOpts(requestParameters: CreateSubscriptionPortalRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Returns a URL for the hosted billing portal: where a customer cancels the subscription, resumes one they cancelled, changes payment method, or downloads invoices. Requires the `billing:write` scope AND organization-admin privileges.  Cancellation lives here rather than on its own endpoint because it is one surface with the rest of the billing lifecycle. The common reason a subscription is about to lapse is a declined card, and the fix for that is a new card, not a cancellation — sending a customer somewhere that can only cancel would lose renewals.  Cancelling in the portal ends the subscription at the close of the current period; coverage continues until then and `/billing/subscription` reports `cancel_at_period_end: true`.  An organization that has never paid for anything gets 404: there is no billing account to manage, and this endpoint deliberately does not create one as a side effect of looking.
+     * Open the billing portal to cancel or manage the subscription
+     */
+    createSubscriptionPortalRaw(requestParameters: CreateSubscriptionPortalRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SubscriptionPortalSession>>;
+    /**
+     * Returns a URL for the hosted billing portal: where a customer cancels the subscription, resumes one they cancelled, changes payment method, or downloads invoices. Requires the `billing:write` scope AND organization-admin privileges.  Cancellation lives here rather than on its own endpoint because it is one surface with the rest of the billing lifecycle. The common reason a subscription is about to lapse is a declined card, and the fix for that is a new card, not a cancellation — sending a customer somewhere that can only cancel would lose renewals.  Cancelling in the portal ends the subscription at the close of the current period; coverage continues until then and `/billing/subscription` reports `cancel_at_period_end: true`.  An organization that has never paid for anything gets 404: there is no billing account to manage, and this endpoint deliberately does not create one as a side effect of looking.
+     * Open the billing portal to cancel or manage the subscription
+     */
+    createSubscriptionPortal(requestParameters?: CreateSubscriptionPortalRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SubscriptionPortalSession>;
     /**
      * Creates request options for getBalance without sending the request
      */
@@ -72,6 +111,20 @@ export declare class BillingApi extends runtime.BaseAPI {
      * Get one stablecoin deposit
      */
     getDeposit(requestParameters: GetDepositRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CryptoDeposit>;
+    /**
+     * Creates request options for getReferral without sending the request
+     */
+    getReferralRequestOpts(): Promise<runtime.RequestOpts>;
+    /**
+     * Returns the organization\'s shareable referral code and invite link (minting the code on first read), the program terms, the referrer\'s stats, and — when this organization itself signed up through someone else\'s link — its own progress toward the referee reward. Requires the `billing:read` scope. The organization is taken from the authenticated API key, never from a parameter.  The program: share the invite link; when a friend signs up through it and spends `qualify_spend_cents` on inference, the referrer receives `reward_cents` and the friend receives `referee_reward_cents`, both as non-withdrawable credit, after a `hold_days` chargeback hold. The terms ride on the wire so a client never hard-codes the amounts.  `referred` is ABSENT (not null) for an organization nobody referred — key on its presence. This is the same contract the dashboard\'s referral card reads.
+     * Get the org referral code, invite link, terms and stats
+     */
+    getReferralRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Referral>>;
+    /**
+     * Returns the organization\'s shareable referral code and invite link (minting the code on first read), the program terms, the referrer\'s stats, and — when this organization itself signed up through someone else\'s link — its own progress toward the referee reward. Requires the `billing:read` scope. The organization is taken from the authenticated API key, never from a parameter.  The program: share the invite link; when a friend signs up through it and spends `qualify_spend_cents` on inference, the referrer receives `reward_cents` and the friend receives `referee_reward_cents`, both as non-withdrawable credit, after a `hold_days` chargeback hold. The terms ride on the wire so a client never hard-codes the amounts.  `referred` is ABSENT (not null) for an organization nobody referred — key on its presence. This is the same contract the dashboard\'s referral card reads.
+     * Get the org referral code, invite link, terms and stats
+     */
+    getReferral(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Referral>;
     /**
      * Creates request options for getSpendingLimit without sending the request
      */

package/dist/apis/BillingApi.js

@@ -28,8 +28,13 @@ const Balance_1 = require("../models/Balance");
 const CreateCryptoDepositRequest_1 = require("../models/CreateCryptoDepositRequest");
 const CryptoDeposit_1 = require("../models/CryptoDeposit");
 const ListDeposits200Response_1 = require("../models/ListDeposits200Response");
+const Referral_1 = require("../models/Referral");
 const SpendingLimit_1 = require("../models/SpendingLimit");
 const Subscription_1 = require("../models/Subscription");
+const SubscriptionCheckoutRequest_1 = require("../models/SubscriptionCheckoutRequest");
+const SubscriptionCheckoutSession_1 = require("../models/SubscriptionCheckoutSession");
+const SubscriptionPortalRequest_1 = require("../models/SubscriptionPortalRequest");
+const SubscriptionPortalSession_1 = require("../models/SubscriptionPortalSession");
 const UpdateSpendingLimitRequest_1 = require("../models/UpdateSpendingLimitRequest");
 /**
  *
@@ -84,6 +89,98 @@ class BillingApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for createSubscriptionCheckout without sending the request
+     */
+    createSubscriptionCheckoutRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = `/billing/subscription/checkout`;
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: (0, SubscriptionCheckoutRequest_1.SubscriptionCheckoutRequestToJSON)(requestParameters['subscriptionCheckoutRequest']),
+            };
+        });
+    }
+    /**
+     * Opens a hosted checkout session for the flat tier and returns its URL. Requires the `billing:write` scope AND organization-admin privileges — subscribing spends organization money.  This endpoint does NOT subscribe anyone. Checkout is a hosted page that needs a browser and a card, so the caller\'s job is to put the returned URL in front of a human. The subscription becomes active when payment completes, which is not synchronous with this call: poll `/billing/subscription` to confirm.  `success_url` and `cancel_url` are optional and fall back to the deployment\'s configured redirects, which is what lets a command-line client start a purchase without having any URLs of its own. An empty request body is valid and means \"use every default\".  `plan_key`, when sent, pins the plan the client DISPLAYED: an unknown key is a 400 rather than a silent purchase of a different tier. Today there is one tier, so the only accepted value is its key — but sending it is the forward-compatible choice.  One flat tier means at most one subscription per organization: a second checkout while an entitling subscription exists is a 409.
+     * Start a subscription checkout session
+     */
+    createSubscriptionCheckoutRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.createSubscriptionCheckoutRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, SubscriptionCheckoutSession_1.SubscriptionCheckoutSessionFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Opens a hosted checkout session for the flat tier and returns its URL. Requires the `billing:write` scope AND organization-admin privileges — subscribing spends organization money.  This endpoint does NOT subscribe anyone. Checkout is a hosted page that needs a browser and a card, so the caller\'s job is to put the returned URL in front of a human. The subscription becomes active when payment completes, which is not synchronous with this call: poll `/billing/subscription` to confirm.  `success_url` and `cancel_url` are optional and fall back to the deployment\'s configured redirects, which is what lets a command-line client start a purchase without having any URLs of its own. An empty request body is valid and means \"use every default\".  `plan_key`, when sent, pins the plan the client DISPLAYED: an unknown key is a 400 rather than a silent purchase of a different tier. Today there is one tier, so the only accepted value is its key — but sending it is the forward-compatible choice.  One flat tier means at most one subscription per organization: a second checkout while an entitling subscription exists is a 409.
+     * Start a subscription checkout session
+     */
+    createSubscriptionCheckout() {
+        return __awaiter(this, arguments, void 0, function* (requestParameters = {}, initOverrides) {
+            const response = yield this.createSubscriptionCheckoutRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for createSubscriptionPortal without sending the request
+     */
+    createSubscriptionPortalRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = `/billing/subscription/portal`;
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: (0, SubscriptionPortalRequest_1.SubscriptionPortalRequestToJSON)(requestParameters['subscriptionPortalRequest']),
+            };
+        });
+    }
+    /**
+     * Returns a URL for the hosted billing portal: where a customer cancels the subscription, resumes one they cancelled, changes payment method, or downloads invoices. Requires the `billing:write` scope AND organization-admin privileges.  Cancellation lives here rather than on its own endpoint because it is one surface with the rest of the billing lifecycle. The common reason a subscription is about to lapse is a declined card, and the fix for that is a new card, not a cancellation — sending a customer somewhere that can only cancel would lose renewals.  Cancelling in the portal ends the subscription at the close of the current period; coverage continues until then and `/billing/subscription` reports `cancel_at_period_end: true`.  An organization that has never paid for anything gets 404: there is no billing account to manage, and this endpoint deliberately does not create one as a side effect of looking.
+     * Open the billing portal to cancel or manage the subscription
+     */
+    createSubscriptionPortalRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.createSubscriptionPortalRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, SubscriptionPortalSession_1.SubscriptionPortalSessionFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Returns a URL for the hosted billing portal: where a customer cancels the subscription, resumes one they cancelled, changes payment method, or downloads invoices. Requires the `billing:write` scope AND organization-admin privileges.  Cancellation lives here rather than on its own endpoint because it is one surface with the rest of the billing lifecycle. The common reason a subscription is about to lapse is a declined card, and the fix for that is a new card, not a cancellation — sending a customer somewhere that can only cancel would lose renewals.  Cancelling in the portal ends the subscription at the close of the current period; coverage continues until then and `/billing/subscription` reports `cancel_at_period_end: true`.  An organization that has never paid for anything gets 404: there is no billing account to manage, and this endpoint deliberately does not create one as a side effect of looking.
+     * Open the billing portal to cancel or manage the subscription
+     */
+    createSubscriptionPortal() {
+        return __awaiter(this, arguments, void 0, function* (requestParameters = {}, initOverrides) {
+            const response = yield this.createSubscriptionPortalRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for getBalance without sending the request
      */
@@ -176,6 +273,50 @@ class BillingApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for getReferral without sending the request
+     */
+    getReferralRequestOpts() {
+        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 = `/referrals`;
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Returns the organization\'s shareable referral code and invite link (minting the code on first read), the program terms, the referrer\'s stats, and — when this organization itself signed up through someone else\'s link — its own progress toward the referee reward. Requires the `billing:read` scope. The organization is taken from the authenticated API key, never from a parameter.  The program: share the invite link; when a friend signs up through it and spends `qualify_spend_cents` on inference, the referrer receives `reward_cents` and the friend receives `referee_reward_cents`, both as non-withdrawable credit, after a `hold_days` chargeback hold. The terms ride on the wire so a client never hard-codes the amounts.  `referred` is ABSENT (not null) for an organization nobody referred — key on its presence. This is the same contract the dashboard\'s referral card reads.
+     * Get the org referral code, invite link, terms and stats
+     */
+    getReferralRaw(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getReferralRequestOpts();
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, Referral_1.ReferralFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Returns the organization\'s shareable referral code and invite link (minting the code on first read), the program terms, the referrer\'s stats, and — when this organization itself signed up through someone else\'s link — its own progress toward the referee reward. Requires the `billing:read` scope. The organization is taken from the authenticated API key, never from a parameter.  The program: share the invite link; when a friend signs up through it and spends `qualify_spend_cents` on inference, the referrer receives `reward_cents` and the friend receives `referee_reward_cents`, both as non-withdrawable credit, after a `hold_days` chargeback hold. The terms ride on the wire so a client never hard-codes the amounts.  `referred` is ABSENT (not null) for an organization nobody referred — key on its presence. This is the same contract the dashboard\'s referral card reads.
+     * Get the org referral code, invite link, terms and stats
+     */
+    getReferral(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getReferralRaw(initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for getSpendingLimit without sending the request
      */

package/dist/apis/InferenceApi.d.ts

@@ -16,6 +16,7 @@ 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 InferencePreflight } from '../models/InferencePreflight';
 import { type Model } from '../models/Model';
 import { type ModelList } from '../models/ModelList';
 import { type VideoCreateRequest } from '../models/VideoCreateRequest';
@@ -47,6 +48,9 @@ export interface GetVideoRequest {
 export interface GetVideoContentRequest {
     id: string;
 }
+export interface InferencePreflightRequest {
+    model: string;
+}
 export interface ListModelsRequest {
     modality?: ListModelsModalityEnum;
 }
@@ -162,6 +166,20 @@ export declare class InferenceApi extends runtime.BaseAPI {
      * Download a completed video artifact
      */
     getVideoContent(requestParameters: GetVideoContentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Blob>;
+    /**
+     * Creates request options for inferencePreflight without sending the request
+     */
+    inferencePreflightRequestOpts(requestParameters: InferencePreflightRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Answers \"what happens if I call this model right now?\" before the call is made: whether the plan covers the model, whether the organization is subscribed, and whether there is credit to pay if it is not covered. Requires the `serverless:read` scope.  Nothing is sent, counted, charged, or reserved. The verdict is computed from the state of the SAME gates that judge the real request — plan coverage, subscription entitlement, remaining plan quota, credit balance and self-set spending caps — so the advice cannot drift from enforcement. It is deliberately NOT a dry run: no per-request cost estimate is quoted, because that figure changes with every prompt and quoting it would invite clients to cache it.  The gates consulted depend on the model\'s MODALITY, because the endpoints do not all meet the same ones. Chat, embeddings and image requests meet the full gate (balance, then the organization\'s opt-in daily cap, then its monthly cap). Video creation meets only the balance check, so an organization past its own spending cap but holding credit is reported as fundable for video — which is what the video endpoint will in fact do. Predicting the strictest gate rather than the applicable one would make this endpoint refuse requests the API accepts.  The same is true of the plan: video creation does not run the subscription gate, so `plan_covered` is false for a video model even if an operator has placed it on the plan\'s covered list. That is a deliberate divergence from the same-named field on `/v1/models`, which reports the platform\'s configuration. Here it means \"the plan covers this REQUEST\" — describing what will happen is the entire job of a preflight.  One caveat on \"read-only\": resolving the balance creates the organization\'s balance row if it has never had one (idempotent, org-scoped, and the same row the first real request would create). Nothing else is written.  The case this exists for is `warn` / `not_plan_covered`. A subscriber calling a model outside the plan IS served and IS charged pay-as-you-go, and nothing in the response to that request says so — the first signal used to be the invoice.  `funded` is a boolean and never a figure. This route is on the inference read scope, so it must not disclose the organization\'s balance; use `/billing/balance` for the number.  Failure posture is the opposite of the request gate\'s: any gate that cannot be read degrades the verdict toward `ok`, never toward `block`. A false `block` would stop a customer whose request would have succeeded, while a false `ok` costs them one honest error from the real call.
+     * Check whether a model request would be served, and at whose expense
+     */
+    inferencePreflightRaw(requestParameters: InferencePreflightRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<InferencePreflight>>;
+    /**
+     * Answers \"what happens if I call this model right now?\" before the call is made: whether the plan covers the model, whether the organization is subscribed, and whether there is credit to pay if it is not covered. Requires the `serverless:read` scope.  Nothing is sent, counted, charged, or reserved. The verdict is computed from the state of the SAME gates that judge the real request — plan coverage, subscription entitlement, remaining plan quota, credit balance and self-set spending caps — so the advice cannot drift from enforcement. It is deliberately NOT a dry run: no per-request cost estimate is quoted, because that figure changes with every prompt and quoting it would invite clients to cache it.  The gates consulted depend on the model\'s MODALITY, because the endpoints do not all meet the same ones. Chat, embeddings and image requests meet the full gate (balance, then the organization\'s opt-in daily cap, then its monthly cap). Video creation meets only the balance check, so an organization past its own spending cap but holding credit is reported as fundable for video — which is what the video endpoint will in fact do. Predicting the strictest gate rather than the applicable one would make this endpoint refuse requests the API accepts.  The same is true of the plan: video creation does not run the subscription gate, so `plan_covered` is false for a video model even if an operator has placed it on the plan\'s covered list. That is a deliberate divergence from the same-named field on `/v1/models`, which reports the platform\'s configuration. Here it means \"the plan covers this REQUEST\" — describing what will happen is the entire job of a preflight.  One caveat on \"read-only\": resolving the balance creates the organization\'s balance row if it has never had one (idempotent, org-scoped, and the same row the first real request would create). Nothing else is written.  The case this exists for is `warn` / `not_plan_covered`. A subscriber calling a model outside the plan IS served and IS charged pay-as-you-go, and nothing in the response to that request says so — the first signal used to be the invoice.  `funded` is a boolean and never a figure. This route is on the inference read scope, so it must not disclose the organization\'s balance; use `/billing/balance` for the number.  Failure posture is the opposite of the request gate\'s: any gate that cannot be read degrades the verdict toward `ok`, never toward `block`. A false `block` would stop a customer whose request would have succeeded, while a false `ok` costs them one honest error from the real call.
+     * Check whether a model request would be served, and at whose expense
+     */
+    inferencePreflight(requestParameters: InferencePreflightRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InferencePreflight>;
     /**
      * Creates request options for listModels without sending the request
      */

package/dist/apis/InferenceApi.js

@@ -30,6 +30,7 @@ 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 InferencePreflight_1 = require("../models/InferencePreflight");
 const Model_1 = require("../models/Model");
 const ModelList_1 = require("../models/ModelList");
 const VideoCreateRequest_1 = require("../models/VideoCreateRequest");
@@ -425,6 +426,56 @@ class InferenceApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for inferencePreflight without sending the request
+     */
+    inferencePreflightRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['model'] == null) {
+                throw new runtime.RequiredError('model', 'Required parameter "model" was null or undefined when calling inferencePreflight().');
+            }
+            const queryParameters = {};
+            if (requestParameters['model'] != null) {
+                queryParameters['model'] = requestParameters['model'];
+            }
+            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 = `/inference/preflight`;
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Answers \"what happens if I call this model right now?\" before the call is made: whether the plan covers the model, whether the organization is subscribed, and whether there is credit to pay if it is not covered. Requires the `serverless:read` scope.  Nothing is sent, counted, charged, or reserved. The verdict is computed from the state of the SAME gates that judge the real request — plan coverage, subscription entitlement, remaining plan quota, credit balance and self-set spending caps — so the advice cannot drift from enforcement. It is deliberately NOT a dry run: no per-request cost estimate is quoted, because that figure changes with every prompt and quoting it would invite clients to cache it.  The gates consulted depend on the model\'s MODALITY, because the endpoints do not all meet the same ones. Chat, embeddings and image requests meet the full gate (balance, then the organization\'s opt-in daily cap, then its monthly cap). Video creation meets only the balance check, so an organization past its own spending cap but holding credit is reported as fundable for video — which is what the video endpoint will in fact do. Predicting the strictest gate rather than the applicable one would make this endpoint refuse requests the API accepts.  The same is true of the plan: video creation does not run the subscription gate, so `plan_covered` is false for a video model even if an operator has placed it on the plan\'s covered list. That is a deliberate divergence from the same-named field on `/v1/models`, which reports the platform\'s configuration. Here it means \"the plan covers this REQUEST\" — describing what will happen is the entire job of a preflight.  One caveat on \"read-only\": resolving the balance creates the organization\'s balance row if it has never had one (idempotent, org-scoped, and the same row the first real request would create). Nothing else is written.  The case this exists for is `warn` / `not_plan_covered`. A subscriber calling a model outside the plan IS served and IS charged pay-as-you-go, and nothing in the response to that request says so — the first signal used to be the invoice.  `funded` is a boolean and never a figure. This route is on the inference read scope, so it must not disclose the organization\'s balance; use `/billing/balance` for the number.  Failure posture is the opposite of the request gate\'s: any gate that cannot be read degrades the verdict toward `ok`, never toward `block`. A false `block` would stop a customer whose request would have succeeded, while a false `ok` costs them one honest error from the real call.
+     * Check whether a model request would be served, and at whose expense
+     */
+    inferencePreflightRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.inferencePreflightRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, InferencePreflight_1.InferencePreflightFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Answers \"what happens if I call this model right now?\" before the call is made: whether the plan covers the model, whether the organization is subscribed, and whether there is credit to pay if it is not covered. Requires the `serverless:read` scope.  Nothing is sent, counted, charged, or reserved. The verdict is computed from the state of the SAME gates that judge the real request — plan coverage, subscription entitlement, remaining plan quota, credit balance and self-set spending caps — so the advice cannot drift from enforcement. It is deliberately NOT a dry run: no per-request cost estimate is quoted, because that figure changes with every prompt and quoting it would invite clients to cache it.  The gates consulted depend on the model\'s MODALITY, because the endpoints do not all meet the same ones. Chat, embeddings and image requests meet the full gate (balance, then the organization\'s opt-in daily cap, then its monthly cap). Video creation meets only the balance check, so an organization past its own spending cap but holding credit is reported as fundable for video — which is what the video endpoint will in fact do. Predicting the strictest gate rather than the applicable one would make this endpoint refuse requests the API accepts.  The same is true of the plan: video creation does not run the subscription gate, so `plan_covered` is false for a video model even if an operator has placed it on the plan\'s covered list. That is a deliberate divergence from the same-named field on `/v1/models`, which reports the platform\'s configuration. Here it means \"the plan covers this REQUEST\" — describing what will happen is the entire job of a preflight.  One caveat on \"read-only\": resolving the balance creates the organization\'s balance row if it has never had one (idempotent, org-scoped, and the same row the first real request would create). Nothing else is written.  The case this exists for is `warn` / `not_plan_covered`. A subscriber calling a model outside the plan IS served and IS charged pay-as-you-go, and nothing in the response to that request says so — the first signal used to be the invoice.  `funded` is a boolean and never a figure. This route is on the inference read scope, so it must not disclose the organization\'s balance; use `/billing/balance` for the number.  Failure posture is the opposite of the request gate\'s: any gate that cannot be read degrades the verdict toward `ok`, never toward `block`. A false `block` would stop a customer whose request would have succeeded, while a false `ok` costs them one honest error from the real call.
+     * Check whether a model request would be served, and at whose expense
+     */
+    inferencePreflight(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.inferencePreflightRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for listModels without sending the request
      */

package/dist/esm/apis/BillingApi.d.ts

@@ -14,12 +14,23 @@ import { type Balance } from '../models/Balance';
 import { type CreateCryptoDepositRequest } from '../models/CreateCryptoDepositRequest';
 import { type CryptoDeposit } from '../models/CryptoDeposit';
 import { type ListDeposits200Response } from '../models/ListDeposits200Response';
+import { type Referral } from '../models/Referral';
 import { type SpendingLimit } from '../models/SpendingLimit';
 import { type Subscription } from '../models/Subscription';
+import { type SubscriptionCheckoutRequest } from '../models/SubscriptionCheckoutRequest';
+import { type SubscriptionCheckoutSession } from '../models/SubscriptionCheckoutSession';
+import { type SubscriptionPortalRequest } from '../models/SubscriptionPortalRequest';
+import { type SubscriptionPortalSession } from '../models/SubscriptionPortalSession';
 import { type UpdateSpendingLimitRequest } from '../models/UpdateSpendingLimitRequest';
 export interface CreateCryptoDepositOperationRequest {
     createCryptoDepositRequest: CreateCryptoDepositRequest;
 }
+export interface CreateSubscriptionCheckoutRequest {
+    subscriptionCheckoutRequest?: SubscriptionCheckoutRequest;
+}
+export interface CreateSubscriptionPortalRequest {
+    subscriptionPortalRequest?: SubscriptionPortalRequest;
+}
 export interface GetDepositRequest {
     id: string;
 }
@@ -44,6 +55,34 @@ export declare class BillingApi extends runtime.BaseAPI {
      * Create a stablecoin deposit
      */
     createCryptoDeposit(requestParameters: CreateCryptoDepositOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CryptoDeposit>;
+    /**
+     * Creates request options for createSubscriptionCheckout without sending the request
+     */
+    createSubscriptionCheckoutRequestOpts(requestParameters: CreateSubscriptionCheckoutRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Opens a hosted checkout session for the flat tier and returns its URL. Requires the `billing:write` scope AND organization-admin privileges — subscribing spends organization money.  This endpoint does NOT subscribe anyone. Checkout is a hosted page that needs a browser and a card, so the caller\'s job is to put the returned URL in front of a human. The subscription becomes active when payment completes, which is not synchronous with this call: poll `/billing/subscription` to confirm.  `success_url` and `cancel_url` are optional and fall back to the deployment\'s configured redirects, which is what lets a command-line client start a purchase without having any URLs of its own. An empty request body is valid and means \"use every default\".  `plan_key`, when sent, pins the plan the client DISPLAYED: an unknown key is a 400 rather than a silent purchase of a different tier. Today there is one tier, so the only accepted value is its key — but sending it is the forward-compatible choice.  One flat tier means at most one subscription per organization: a second checkout while an entitling subscription exists is a 409.
+     * Start a subscription checkout session
+     */
+    createSubscriptionCheckoutRaw(requestParameters: CreateSubscriptionCheckoutRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SubscriptionCheckoutSession>>;
+    /**
+     * Opens a hosted checkout session for the flat tier and returns its URL. Requires the `billing:write` scope AND organization-admin privileges — subscribing spends organization money.  This endpoint does NOT subscribe anyone. Checkout is a hosted page that needs a browser and a card, so the caller\'s job is to put the returned URL in front of a human. The subscription becomes active when payment completes, which is not synchronous with this call: poll `/billing/subscription` to confirm.  `success_url` and `cancel_url` are optional and fall back to the deployment\'s configured redirects, which is what lets a command-line client start a purchase without having any URLs of its own. An empty request body is valid and means \"use every default\".  `plan_key`, when sent, pins the plan the client DISPLAYED: an unknown key is a 400 rather than a silent purchase of a different tier. Today there is one tier, so the only accepted value is its key — but sending it is the forward-compatible choice.  One flat tier means at most one subscription per organization: a second checkout while an entitling subscription exists is a 409.
+     * Start a subscription checkout session
+     */
+    createSubscriptionCheckout(requestParameters?: CreateSubscriptionCheckoutRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SubscriptionCheckoutSession>;
+    /**
+     * Creates request options for createSubscriptionPortal without sending the request
+     */
+    createSubscriptionPortalRequestOpts(requestParameters: CreateSubscriptionPortalRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Returns a URL for the hosted billing portal: where a customer cancels the subscription, resumes one they cancelled, changes payment method, or downloads invoices. Requires the `billing:write` scope AND organization-admin privileges.  Cancellation lives here rather than on its own endpoint because it is one surface with the rest of the billing lifecycle. The common reason a subscription is about to lapse is a declined card, and the fix for that is a new card, not a cancellation — sending a customer somewhere that can only cancel would lose renewals.  Cancelling in the portal ends the subscription at the close of the current period; coverage continues until then and `/billing/subscription` reports `cancel_at_period_end: true`.  An organization that has never paid for anything gets 404: there is no billing account to manage, and this endpoint deliberately does not create one as a side effect of looking.
+     * Open the billing portal to cancel or manage the subscription
+     */
+    createSubscriptionPortalRaw(requestParameters: CreateSubscriptionPortalRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SubscriptionPortalSession>>;
+    /**
+     * Returns a URL for the hosted billing portal: where a customer cancels the subscription, resumes one they cancelled, changes payment method, or downloads invoices. Requires the `billing:write` scope AND organization-admin privileges.  Cancellation lives here rather than on its own endpoint because it is one surface with the rest of the billing lifecycle. The common reason a subscription is about to lapse is a declined card, and the fix for that is a new card, not a cancellation — sending a customer somewhere that can only cancel would lose renewals.  Cancelling in the portal ends the subscription at the close of the current period; coverage continues until then and `/billing/subscription` reports `cancel_at_period_end: true`.  An organization that has never paid for anything gets 404: there is no billing account to manage, and this endpoint deliberately does not create one as a side effect of looking.
+     * Open the billing portal to cancel or manage the subscription
+     */
+    createSubscriptionPortal(requestParameters?: CreateSubscriptionPortalRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SubscriptionPortalSession>;
     /**
      * Creates request options for getBalance without sending the request
      */
@@ -72,6 +111,20 @@ export declare class BillingApi extends runtime.BaseAPI {
      * Get one stablecoin deposit
      */
     getDeposit(requestParameters: GetDepositRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CryptoDeposit>;
+    /**
+     * Creates request options for getReferral without sending the request
+     */
+    getReferralRequestOpts(): Promise<runtime.RequestOpts>;
+    /**
+     * Returns the organization\'s shareable referral code and invite link (minting the code on first read), the program terms, the referrer\'s stats, and — when this organization itself signed up through someone else\'s link — its own progress toward the referee reward. Requires the `billing:read` scope. The organization is taken from the authenticated API key, never from a parameter.  The program: share the invite link; when a friend signs up through it and spends `qualify_spend_cents` on inference, the referrer receives `reward_cents` and the friend receives `referee_reward_cents`, both as non-withdrawable credit, after a `hold_days` chargeback hold. The terms ride on the wire so a client never hard-codes the amounts.  `referred` is ABSENT (not null) for an organization nobody referred — key on its presence. This is the same contract the dashboard\'s referral card reads.
+     * Get the org referral code, invite link, terms and stats
+     */
+    getReferralRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Referral>>;
+    /**
+     * Returns the organization\'s shareable referral code and invite link (minting the code on first read), the program terms, the referrer\'s stats, and — when this organization itself signed up through someone else\'s link — its own progress toward the referee reward. Requires the `billing:read` scope. The organization is taken from the authenticated API key, never from a parameter.  The program: share the invite link; when a friend signs up through it and spends `qualify_spend_cents` on inference, the referrer receives `reward_cents` and the friend receives `referee_reward_cents`, both as non-withdrawable credit, after a `hold_days` chargeback hold. The terms ride on the wire so a client never hard-codes the amounts.  `referred` is ABSENT (not null) for an organization nobody referred — key on its presence. This is the same contract the dashboard\'s referral card reads.
+     * Get the org referral code, invite link, terms and stats
+     */
+    getReferral(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Referral>;
     /**
      * Creates request options for getSpendingLimit without sending the request
      */