@spicyapi/sdk 0.3.0 → 0.5.0

package/dist/src/generated/openapi.d.ts

@@ -94,7 +94,7 @@ export interface paths {
          *     as a Server-Sent Events stream. Each event is a `data:` line carrying one
          *     JSON chunk; the stream ends with `data: [DONE]`.
          *
-         *     The hold is settled when the stream completes. If the upstream call fails
+         *     The hold is settled when the stream completes. If generation fails
          *     before the first event, the response is a normal JSON error and the hold is
          *     released. If it fails mid-stream the connection is terminated with an
          *     `error` event and the hold is still released — a truncated answer is never
@@ -123,7 +123,7 @@ export interface paths {
         /**
          * Create a new task from a failed or expired task
          * @description The source terminal task is never modified. Current model schema,
-         *     pricing, permissions, balance, and routing are evaluated again. An
+         *     pricing, permissions, balance, and availability are evaluated again. An
          *     optional Idempotency-Key is scoped to the source task and retry action.
          *     The source task must have been created by the same API key; unknown,
          *     cross-account, and same-account cross-key task IDs all return 404.
@@ -135,6 +135,48 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/jobs/purge": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Destroy the stored content of a finished task
+         * @description Removes the task's generated media objects, its result payload, and the
+         *     stored request text including the prompt.
+         *
+         *     **Billing evidence is never touched.** The ledger, the charged amount,
+         *     the model identifier, the state, the timestamps and the request_id all
+         *     remain, so the task stays fully auditable in billing. What is destroyed
+         *     is the content, not the spend record; the response repeats this as
+         *     `billingRetained`.
+         *
+         *     Only a finished task can be destroyed; a task that is still queued or
+         *     running returns 400. Its outputs have not landed yet, and removing half
+         *     of them is worse than removing none. An accepted generation task cannot
+         *     be stopped, so the only thing to do is wait for it to reach a terminal
+         *     state and call this endpoint then.
+         *
+         *     The call is idempotent by `taskId`: destroying an already destroyed task
+         *     returns 200 with the original `purgedAt`, so a client may safely retry
+         *     after a timeout. No `Idempotency-Key` is needed.
+         *
+         *     Media objects are removed by a background sweep within about a minute,
+         *     so `mediaDeletionPending` can be true while `contentState` is already
+         *     `purged`. Deleting them inline would let one undeletable object block the
+         *     whole request.
+         */
+        post: operations["purgeTask"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/models": {
         parameters: {
             query?: never;
@@ -191,7 +233,7 @@ export interface paths {
          * @description Returns only visible tasks created by this API key and its account,
          *     newest first by createdAt and taskId. The list contains metadata only;
          *     use recordInfo for a selected task's result. No input, output, signed
-         *     media URL, or execution-channel information is included.
+         *     media URL, or internal processing detail is included.
          *     Dates form a UTC half-open interval [from,to), up to 92 days.
          *     Default to is tomorrow in UTC; omitted from is seven days before to.
          *     Keep all filters, including explicit from/to dates, unchanged while
@@ -248,7 +290,7 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        /** Get the account balance */
+        /** Get net balance, promotional grants, and approved credit */
         get: operations["getCreditBalance"];
         put?: never;
         post?: never;
@@ -272,7 +314,7 @@ export interface paths {
          * @description The server generates the object key. Upload the exact declared number of
          *     bytes with PUT and copy every returned header. Supported media types are
          *     JPEG, PNG, WebP and GIF images (10 MiB), or MP4/WebM video and
-         *     MP3/WAV audio (100 MiB, at most 600 seconds). Audio/video commit verifies
+         *     MP3/WAV audio (90 MiB, at most 600 seconds). Audio/video commit verifies
          *     format and measurable duration; it does not inspect adult content. After PUT,
          *     call the file commit endpoint and use its spicy:// URI in task input.
          */
@@ -340,8 +382,8 @@ export interface paths {
          * List callable models in the OpenAI `model` list shape
          * @description Returns every model that can be called right now. `id` is the SpicyAPI
          *     model identifier accepted by every `/v1` and `/api/v1` operation;
-         *     `owned_by` is the model publisher (for example a research lab), never
-         *     an execution supplier. Pricing is not included; use `/api/v1/models`.
+         *     `owned_by` is the model publisher (for example a research lab).
+         *     Pricing is not included; use `/api/v1/models`.
          */
         get: operations["listOpenAIModels"];
         put?: never;
@@ -443,6 +485,61 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1beta/models/{model}:generateContent": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Google Gemini generateContent on a SpicyAPI text model
+         * @description Accepts a Google Gemini `generateContent` request (`contents` with
+         *     text / inlineData / functionCall / functionResponse parts,
+         *     `systemInstruction`, `tools.functionDeclarations`, `toolConfig`,
+         *     `generationConfig` such as `temperature`, `topP`, `maxOutputTokens`,
+         *     `stopSequences`, `responseMimeType`, `responseSchema`,
+         *     `thinkingConfig`). `{model}` is a SpicyAPI text model identifier from
+         *     `/v1/models` and may contain a slash (for example
+         *     `google/gemini-3-flash-preview`). Validation, pricing and availability are
+         *     identical to `/v1/chat/completions`. The response is one
+         *     `GenerateContentResponse`. Errors use the Google
+         *     `{error:{code,message,status}}` shape.
+         */
+        post: operations["geminiGenerateContent"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1beta/models/{model}:streamGenerateContent": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Google Gemini streamGenerateContent on a SpicyAPI text model
+         * @description Same request as `generateContent`. With `?alt=sse` (what the Google
+         *     GenAI SDKs send) the response is a server-sent event stream where each
+         *     `data:` line is one `GenerateContentResponse`; the final one carries
+         *     `finishReason` and `usageMetadata`. There is no `[DONE]` sentinel.
+         *     Without `alt=sse` the response is a JSON array of
+         *     `GenerateContentResponse` objects written progressively.
+         */
+        post: operations["geminiStreamGenerateContent"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/videos": {
         parameters: {
             query?: never;
@@ -521,6 +618,53 @@ export interface paths {
 export type webhooks = Record<string, never>;
 export interface components {
     schemas: {
+        FundingGrantItem: {
+            id: string;
+            name: string;
+            amountUsd: string;
+            availableUsd: string;
+            heldUsd: string;
+            spentUsd: string;
+            status: string;
+            /** Format: date-time */
+            startsAt: string;
+            /** Format: date-time */
+            expiresAt?: string | null;
+            /** @description Empty means all models. */
+            modelSlugs: string[];
+            customerMemo: string;
+            /** Format: date-time */
+            createdAt: string;
+        };
+        CreditFacilityItem: {
+            enabled: boolean;
+            /** @description Approved ceiling */
+            limitUsd: string;
+            availableUsd: string;
+            /** @description Outstanding settled principal. */
+            usedUsd: string;
+            /** @description Credit reserved for accepted tasks. */
+            heldUsd: string;
+            /** Format: date-time */
+            expiresAt?: string | null;
+            status: string;
+            /** Format: int64 */
+            version: number;
+        };
+        FundingOverview: {
+            /** @description Net wallet available balance; may be negative for approved credit consumption or external payment recovery. */
+            balanceUsd: string;
+            heldUsd: string;
+            /** @description Unrestricted prepaid or legacy available funds. */
+            prepaidAvailableUsd: string;
+            /** @description Active available grants; model applicability is checked at task admission. */
+            grantAvailableUsd: string;
+            /** @description External payment recovery shortfall that cannot be covered by grants or credit. */
+            cashShortfallUsd: string;
+            credit: components["schemas"]["CreditFacilityItem"];
+            grants: components["schemas"]["FundingGrantItem"][];
+            grantsHasMore: boolean;
+        };
         EnvelopeBase: {
             code: number;
             msg: string;
@@ -530,6 +674,7 @@ export interface components {
         ErrorEnvelope: components["schemas"]["EnvelopeBase"] & {
             /** @enum {integer} */
             code?: 400 | 401 | 40201 | 40202 | 403 | 40301 | 40302 | 40303 | 404 | 409 | 40901 | 413 | 429 | 500 | 50301;
+            /** @description Human-readable explanation, English unless `Accept-Language` or the account's API error language selects another supported language. Never parse it; branch on `code`. */
             msg?: string;
         };
         CreateTaskRequest: {
@@ -594,6 +739,38 @@ export interface components {
             msg?: "success";
             data: components["schemas"]["RetryTaskResponse"];
         };
+        TaskPurgeResponse: {
+            taskId: string;
+            /**
+             * @description `purged` after a successful destroy, and on any idempotent repeat. Still `present` means this call removed nothing and may be retried later; the reason is deliberately not disclosed.
+             * @enum {string}
+             */
+            contentState: "present" | "expired" | "purged";
+            /**
+             * Format: date-time
+             * @description Time of the **first** destroy, not of this call.
+             */
+            purgedAt?: string;
+            /**
+             * @description Omitted while `contentState` is `present`.
+             * @enum {string}
+             */
+            contentRemovedBy?: "user" | "system";
+            /**
+             * @description Always true. Destroying content never changes the ledger, the charged amount, or any other billing fact. It is stated explicitly because it is the one thing a caller is likely to get wrong about an endpoint named "purge".
+             * @constant
+             */
+            billingRetained: true;
+            /** @description True while the background sweep has not finished removing the stored media objects. */
+            mediaDeletionPending: boolean;
+        };
+        TaskPurgeEnvelope: components["schemas"]["EnvelopeBase"] & {
+            /** @constant */
+            code?: 200;
+            /** @constant */
+            msg?: "success";
+            data: components["schemas"]["TaskPurgeResponse"];
+        };
         CreateTaskEnvelope: components["schemas"]["EnvelopeBase"] & {
             /** @constant */
             code?: 200;
@@ -646,9 +823,12 @@ export interface components {
                 [key: string]: unknown;
             };
             output?: components["schemas"]["TaskOutput"];
-            /** @description Stable SpicyAPI failure identifier; never a raw execution-channel code. */
-            errorCode?: string;
-            /** @description Safe normalized explanation without internal service names */
+            /**
+             * @description Stable SpicyAPI failure identifier from a closed set; never an internal diagnostic code. The set is closed: any other value a client sees should be handled as `upstream_failed`.
+             * @enum {string}
+             */
+            errorCode?: "invalid_request" | "unsupported_combination" | "content_rejected" | "rate_limited" | "upstream_unavailable" | "generation_failed" | "timeout" | "invalid_asset" | "upstream_failed";
+            /** @description Safe normalized explanation without internal service names, hosts, task IDs, or raw errors. Follows the same language selection as `msg`; `errorCode` never changes. */
             errorMessage?: string;
             cost: components["schemas"]["USDString"];
             /** @description When false, `cost` is the held estimate. On success the final charge is capped at that hold; unused funds are released. Failed or expired tasks release the hold in full. */
@@ -662,6 +842,40 @@ export interface components {
             deadlineAt?: string;
             /** Format: date-time */
             completedAt?: string;
+            /**
+             * @description Whether the task content is still stored, and why it is not. `expired` means the retention policy removed it; `purged` means the account owner destroyed it with `purgeTask`. The two are deliberately distinct: telling a customer their own deletion was an expiry reads as the platform losing their data.
+             * @enum {string}
+             */
+            contentState?: "present" | "expired" | "purged";
+            /**
+             * @description Present only once content has been removed. Omitted while `contentState` is `present`.
+             * @enum {string}
+             */
+            contentRemovedBy?: "user" | "system";
+            /**
+             * Format: date-time
+             * @description Present only for a task destroyed with `purgeTask`. Expiry does not set it.
+             */
+            purgedAt?: string;
+            retention?: components["schemas"]["TaskRetention"];
+        };
+        /** @description When this task's content is scheduled to be removed, and which layer decided it. Omitted for tasks created before per-task retention existed; those follow the platform maximum. */
+        TaskRetention: {
+            /**
+             * Format: date-time
+             * @description When the generated media objects and the result payload are removed. Before the task finishes this is measured from acceptance; when the task reaches a terminal state it is re-based on the completion time using the same window, so it only ever moves later, never earlier.
+             */
+            outputsExpireAt: string;
+            /**
+             * Format: date-time
+             * @description When the stored request text is erased. The task row, its state, amounts and request_id remain.
+             */
+            promptsExpireAt: string;
+            /**
+             * @description Which layer actually constrained the value: the per-request `X-Spicy-Retention` header, the account setting, or the platform maximum. A request that sends the header and still sees `account` has an account setting that is already shorter than it asked for.
+             * @enum {string}
+             */
+            source: "header" | "account" | "platform";
         };
         TaskRecordEnvelope: components["schemas"]["EnvelopeBase"] & {
             /** @constant */
@@ -756,6 +970,7 @@ export interface components {
             data: components["schemas"]["APIKeyUsageResponse"];
         };
         Balance: {
+            funding?: components["schemas"]["FundingOverview"];
             available: components["schemas"]["USDString"];
             held: components["schemas"]["USDString"];
             total: components["schemas"]["USDString"];
@@ -790,16 +1005,16 @@ export interface components {
             /** @description Stable product-family identifier; endpoint variants are listed in `tasks` and expressed by `inputSchema`. */
             family: string;
             displayName: string;
-            /** @description Model creator/author identifier. It never identifies an execution channel. */
+            /** @description Model creator/author identifier, such as the research lab that built the model. */
             provider: string;
             /** @enum {string} */
             modality: "image" | "video" | "audio" | "text";
             tasks: string[];
             async: boolean;
-            /** @description Informational model-creator capability metadata only. It does not participate in routing, authorization, or request rejection. */
+            /** @description Informational model-creator capability metadata only. It does not participate in authorization, availability decisions, or request rejection. */
             mature: boolean;
             /**
-             * @description Informational model-creator policy metadata only. It does not participate in routing, authorization, or request rejection.
+             * @description Informational model-creator policy metadata only. It does not participate in authorization, availability decisions, or request rejection.
              * @enum {string}
              */
             policyTier: "unrestricted" | "borderline" | "unspecified";
@@ -857,7 +1072,7 @@ export interface components {
         UploadURLRequest: {
             /** @enum {string} */
             contentType: "image/jpeg" | "image/png" | "image/webp" | "image/gif" | "video/mp4" | "video/webm" | "audio/mpeg" | "audio/wav";
-            /** @description Images are limited to 10 MiB; supported audio/video to 100 MiB. */
+            /** @description Images are limited to 10 MiB; supported audio/video to 90 MiB. */
             bytes: number;
         };
         UploadURLResponse: {
@@ -1080,6 +1295,53 @@ export interface components {
                 total_tokens?: number;
             };
         };
+        /** @description Google Gemini `generateContent` request. Which generation parameters a model accepts comes from that model's `inputSchema` in `/v1/models` and the catalog; unsupported parameters return 400. */
+        GeminiGenerateContentRequest: {
+            contents: {
+                /** @enum {string} */
+                role?: "user" | "model";
+                parts?: Record<string, never>[];
+            }[];
+            systemInstruction?: Record<string, never>;
+            tools?: Record<string, never>[];
+            toolConfig?: Record<string, never>;
+            generationConfig?: {
+                temperature?: number;
+                topP?: number;
+                maxOutputTokens?: number;
+                stopSequences?: string[];
+                responseMimeType?: string;
+                responseSchema?: Record<string, never>;
+                thinkingConfig?: Record<string, never>;
+            };
+        };
+        GeminiGenerateContentResponse: {
+            candidates?: {
+                index?: number;
+                content?: {
+                    role?: string;
+                    parts?: Record<string, never>[];
+                };
+                finishReason?: string;
+            }[];
+            usageMetadata?: {
+                promptTokenCount?: number;
+                candidatesTokenCount?: number;
+                totalTokenCount?: number;
+                cachedContentTokenCount?: number;
+                thoughtsTokenCount?: number;
+            };
+            /** @description The SpicyAPI model identifier. */
+            modelVersion?: string;
+            responseId?: string;
+        };
+        GeminiErrorBody: {
+            error: {
+                code: number;
+                message: string;
+                status: string;
+            };
+        };
         AnthropicMessageRequest: {
             model: string;
             system?: string | Record<string, never>[];
@@ -1263,10 +1525,25 @@ export interface components {
                 "application/json": components["schemas"]["AnthropicErrorBody"];
             };
         };
+        /** @description Error in the Google `{error:{code,message,status}}` shape. `status` is the google.rpc code name (for example `INVALID_ARGUMENT`, `UNAUTHENTICATED`, `RESOURCE_EXHAUSTED`). */
+        GeminiError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["GeminiErrorBody"];
+            };
+        };
     };
     parameters: {
         /** @description Stable key for one logical task submission; retained for 24 hours per account and bound to both the submitting API key and normalized request fingerprint. A sibling key receives 409 without the original task ID. */
         IdempotencyKey: string;
+        /**
+         * @description Retention for this one task, in whole seconds. It applies to both the generated outputs and the stored request text. The effective value is always `min(header, account setting, platform maximum)`: a request can only shorten retention, never extend it.
+         *     `0` is valid and means the outputs are removed as soon as the task reaches a terminal state. Values that cannot be applied never fail the request: a negative number is clamped to `0`, a value above the ceiling is clamped to the ceiling, and a value that is not a decimal integer is ignored so the account setting applies. The effective result is always reported back in `retention` on the task record.
+         *     Accepted by `createTask` and `stream`. `retry` inherits the source task's effective value and ignores this header, so one task family never ends up with two different expiry times. `quote` does not accept it because it does not create a task.
+         */
+        SpicyRetention: string;
     };
     requestBodies: never;
     headers: {
@@ -1319,6 +1596,12 @@ export interface operations {
             header?: {
                 /** @description Stable key for one logical task submission; retained for 24 hours per account and bound to both the submitting API key and normalized request fingerprint. A sibling key receives 409 without the original task ID. */
                 "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+                /**
+                 * @description Retention for this one task, in whole seconds. It applies to both the generated outputs and the stored request text. The effective value is always `min(header, account setting, platform maximum)`: a request can only shorten retention, never extend it.
+                 *     `0` is valid and means the outputs are removed as soon as the task reaches a terminal state. Values that cannot be applied never fail the request: a negative number is clamped to `0`, a value above the ceiling is clamped to the ceiling, and a value that is not a decimal integer is ignored so the account setting applies. The effective result is always reported back in `retention` on the task record.
+                 *     Accepted by `createTask` and `stream`. `retry` inherits the source task's effective value and ignores this header, so one task family never ends up with two different expiry times. `quote` does not accept it because it does not create a task.
+                 */
+                "X-Spicy-Retention"?: components["parameters"]["SpicyRetention"];
             };
             path?: never;
             cookie?: never;
@@ -1401,6 +1684,12 @@ export interface operations {
             header?: {
                 /** @description Stable key for one logical task submission; retained for 24 hours per account and bound to both the submitting API key and normalized request fingerprint. A sibling key receives 409 without the original task ID. */
                 "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+                /**
+                 * @description Retention for this one task, in whole seconds. It applies to both the generated outputs and the stored request text. The effective value is always `min(header, account setting, platform maximum)`: a request can only shorten retention, never extend it.
+                 *     `0` is valid and means the outputs are removed as soon as the task reaches a terminal state. Values that cannot be applied never fail the request: a negative number is clamped to `0`, a value above the ceiling is clamped to the ceiling, and a value that is not a decimal integer is ignored so the account setting applies. The effective result is always reported back in `retention` on the task record.
+                 *     Accepted by `createTask` and `stream`. `retry` inherits the source task's effective value and ignores this header, so one task family never ends up with two different expiry times. `quote` does not accept it because it does not create a task.
+                 */
+                "X-Spicy-Retention"?: components["parameters"]["SpicyRetention"];
             };
             path?: never;
             cookie?: never;
@@ -1468,11 +1757,45 @@ export interface operations {
             503: components["responses"]["Unavailable"];
         };
     };
+    purgeTask: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Stable key for one logical task submission; retained for 24 hours per account and bound to both the submitting API key and normalized request fingerprint. A sibling key receives 409 without the original task ID. */
+                "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["TaskActionRequest"];
+            };
+        };
+        responses: {
+            /** @description Content destroyed, or already destroyed by an earlier call. */
+            200: {
+                headers: {
+                    "Cache-Control"?: "no-store";
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TaskPurgeEnvelope"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            429: components["responses"]["RateLimited"];
+            500: components["responses"]["ServerError"];
+        };
+    };
     listModels: {
         parameters: {
             query?: {
                 modality?: "image" | "video" | "audio" | "text";
-                /** @description Exact model creator/author identifier. This never identifies an execution channel. */
+                /** @description Exact model creator/author identifier, such as the research lab that built the model. */
                 provider?: string;
                 /** @description Exact supported task, for example `text-to-image`. */
                 task?: string;
@@ -1615,7 +1938,7 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description Available, held, and total balance in USD decimal strings. */
+            /** @description Net available, held, and total balances plus funding sources in USD decimal strings. Unused credit is separate from wallet funds; model-scoped grants may not pay for every request. */
             200: {
                 headers: {
                     [name: string]: unknown;
@@ -1860,6 +2183,87 @@ export interface operations {
             503: components["responses"]["AnthropicError"];
         };
     };
+    geminiGenerateContent: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Stable key for one logical task submission; retained for 24 hours per account and bound to both the submitting API key and normalized request fingerprint. A sibling key receives 409 without the original task ID. */
+                "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+            };
+            path: {
+                model: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["GeminiGenerateContentRequest"];
+            };
+        };
+        responses: {
+            /** @description One `GenerateContentResponse`. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GeminiGenerateContentResponse"];
+                };
+            };
+            400: components["responses"]["GeminiError"];
+            401: components["responses"]["GeminiError"];
+            402: components["responses"]["GeminiError"];
+            403: components["responses"]["GeminiError"];
+            404: components["responses"]["GeminiError"];
+            409: components["responses"]["GeminiError"];
+            413: components["responses"]["GeminiError"];
+            429: components["responses"]["GeminiError"];
+            500: components["responses"]["GeminiError"];
+            503: components["responses"]["GeminiError"];
+        };
+    };
+    geminiStreamGenerateContent: {
+        parameters: {
+            query?: {
+                alt?: "sse";
+            };
+            header?: {
+                /** @description Stable key for one logical task submission; retained for 24 hours per account and bound to both the submitting API key and normalized request fingerprint. A sibling key receives 409 without the original task ID. */
+                "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+            };
+            path: {
+                model: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["GeminiGenerateContentRequest"];
+            };
+        };
+        responses: {
+            /** @description An SSE stream (`alt=sse`) or a JSON array of `GenerateContentResponse`. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/event-stream": string;
+                    "application/json": components["schemas"]["GeminiGenerateContentResponse"][];
+                };
+            };
+            400: components["responses"]["GeminiError"];
+            401: components["responses"]["GeminiError"];
+            402: components["responses"]["GeminiError"];
+            403: components["responses"]["GeminiError"];
+            404: components["responses"]["GeminiError"];
+            409: components["responses"]["GeminiError"];
+            413: components["responses"]["GeminiError"];
+            429: components["responses"]["GeminiError"];
+            500: components["responses"]["GeminiError"];
+            503: components["responses"]["GeminiError"];
+        };
+    };
     createVideo: {
         parameters: {
             query?: never;