@openrouter/sdk 0.3.12 → 0.3.15

package/esm/models/operations/updateguardrail.js

@@ -0,0 +1,97 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d4106fbc6dca
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import * as openEnums from "../../types/enums.js";
+/**
+ * Interval at which the limit resets (daily, weekly, monthly)
+ */
+export const UpdateGuardrailResetIntervalRequest = {
+    Daily: "daily",
+    Weekly: "weekly",
+    Monthly: "monthly",
+};
+/**
+ * Interval at which the limit resets (daily, weekly, monthly)
+ */
+export const UpdateGuardrailResetIntervalResponse = {
+    Daily: "daily",
+    Weekly: "weekly",
+    Monthly: "monthly",
+};
+/** @internal */
+export const UpdateGuardrailResetIntervalRequest$outboundSchema = openEnums.outboundSchema(UpdateGuardrailResetIntervalRequest);
+/** @internal */
+export const UpdateGuardrailRequestBody$outboundSchema = z.object({
+    name: z.string().optional(),
+    description: z.nullable(z.string()).optional(),
+    limitUsd: z.nullable(z.number()).optional(),
+    resetInterval: z.nullable(UpdateGuardrailResetIntervalRequest$outboundSchema)
+        .optional(),
+    allowedProviders: z.nullable(z.array(z.string())).optional(),
+    allowedModels: z.nullable(z.array(z.string())).optional(),
+    enforceZdr: z.nullable(z.boolean()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        limitUsd: "limit_usd",
+        resetInterval: "reset_interval",
+        allowedProviders: "allowed_providers",
+        allowedModels: "allowed_models",
+        enforceZdr: "enforce_zdr",
+    });
+});
+export function updateGuardrailRequestBodyToJSON(updateGuardrailRequestBody) {
+    return JSON.stringify(UpdateGuardrailRequestBody$outboundSchema.parse(updateGuardrailRequestBody));
+}
+/** @internal */
+export const UpdateGuardrailRequest$outboundSchema = z.object({
+    id: z.string(),
+    requestBody: z.lazy(() => UpdateGuardrailRequestBody$outboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        requestBody: "RequestBody",
+    });
+});
+export function updateGuardrailRequestToJSON(updateGuardrailRequest) {
+    return JSON.stringify(UpdateGuardrailRequest$outboundSchema.parse(updateGuardrailRequest));
+}
+/** @internal */
+export const UpdateGuardrailResetIntervalResponse$inboundSchema = openEnums.inboundSchema(UpdateGuardrailResetIntervalResponse);
+/** @internal */
+export const UpdateGuardrailData$inboundSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.nullable(z.string()).optional(),
+    limit_usd: z.nullable(z.number()).optional(),
+    reset_interval: z.nullable(UpdateGuardrailResetIntervalResponse$inboundSchema)
+        .optional(),
+    allowed_providers: z.nullable(z.array(z.string())).optional(),
+    allowed_models: z.nullable(z.array(z.string())).optional(),
+    enforce_zdr: z.nullable(z.boolean()).optional(),
+    created_at: z.string(),
+    updated_at: z.nullable(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "limit_usd": "limitUsd",
+        "reset_interval": "resetInterval",
+        "allowed_providers": "allowedProviders",
+        "allowed_models": "allowedModels",
+        "enforce_zdr": "enforceZdr",
+        "created_at": "createdAt",
+        "updated_at": "updatedAt",
+    });
+});
+export function updateGuardrailDataFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateGuardrailData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateGuardrailData' from JSON`);
+}
+/** @internal */
+export const UpdateGuardrailResponse$inboundSchema = z.object({
+    data: z.lazy(() => UpdateGuardrailData$inboundSchema),
+});
+export function updateGuardrailResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateGuardrailResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateGuardrailResponse' from JSON`);
+}
+//# sourceMappingURL=updateguardrail.js.map

package/esm/models/percentilelatencycutoffs.d.ts

@@ -0,0 +1,33 @@
+import * as z from "zod/v4";
+/**
+ * Percentile-based latency cutoffs. All specified cutoffs must be met for an endpoint to be preferred.
+ */
+export type PercentileLatencyCutoffs = {
+    /**
+     * Maximum p50 latency (seconds)
+     */
+    p50?: number | null | undefined;
+    /**
+     * Maximum p75 latency (seconds)
+     */
+    p75?: number | null | undefined;
+    /**
+     * Maximum p90 latency (seconds)
+     */
+    p90?: number | null | undefined;
+    /**
+     * Maximum p99 latency (seconds)
+     */
+    p99?: number | null | undefined;
+};
+/** @internal */
+export type PercentileLatencyCutoffs$Outbound = {
+    p50?: number | null | undefined;
+    p75?: number | null | undefined;
+    p90?: number | null | undefined;
+    p99?: number | null | undefined;
+};
+/** @internal */
+export declare const PercentileLatencyCutoffs$outboundSchema: z.ZodType<PercentileLatencyCutoffs$Outbound, PercentileLatencyCutoffs>;
+export declare function percentileLatencyCutoffsToJSON(percentileLatencyCutoffs: PercentileLatencyCutoffs): string;
+//# sourceMappingURL=percentilelatencycutoffs.d.ts.map

package/esm/models/percentilelatencycutoffs.js

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: ab5ef16080c7
+ */
+import * as z from "zod/v4";
+/** @internal */
+export const PercentileLatencyCutoffs$outboundSchema = z.object({
+    p50: z.nullable(z.number()).optional(),
+    p75: z.nullable(z.number()).optional(),
+    p90: z.nullable(z.number()).optional(),
+    p99: z.nullable(z.number()).optional(),
+});
+export function percentileLatencyCutoffsToJSON(percentileLatencyCutoffs) {
+    return JSON.stringify(PercentileLatencyCutoffs$outboundSchema.parse(percentileLatencyCutoffs));
+}
+//# sourceMappingURL=percentilelatencycutoffs.js.map

package/esm/models/percentilestats.d.ts

@@ -0,0 +1,28 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Latency percentiles in milliseconds over the last 30 minutes. Latency measures time to first token. Only visible when authenticated with an API key or cookie; returns null for unauthenticated requests.
+ */
+export type PercentileStats = {
+    /**
+     * Median (50th percentile)
+     */
+    p50: number;
+    /**
+     * 75th percentile
+     */
+    p75: number;
+    /**
+     * 90th percentile
+     */
+    p90: number;
+    /**
+     * 99th percentile
+     */
+    p99: number;
+};
+/** @internal */
+export declare const PercentileStats$inboundSchema: z.ZodType<PercentileStats, unknown>;
+export declare function percentileStatsFromJSON(jsonString: string): SafeParseResult<PercentileStats, SDKValidationError>;
+//# sourceMappingURL=percentilestats.d.ts.map

package/esm/models/percentilestats.js

@@ -0,0 +1,17 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f8001516363f
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const PercentileStats$inboundSchema = z.object({
+    p50: z.number(),
+    p75: z.number(),
+    p90: z.number(),
+    p99: z.number(),
+});
+export function percentileStatsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => PercentileStats$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'PercentileStats' from JSON`);
+}
+//# sourceMappingURL=percentilestats.js.map

package/esm/models/percentilethroughputcutoffs.d.ts

@@ -0,0 +1,33 @@
+import * as z from "zod/v4";
+/**
+ * Percentile-based throughput cutoffs. All specified cutoffs must be met for an endpoint to be preferred.
+ */
+export type PercentileThroughputCutoffs = {
+    /**
+     * Minimum p50 throughput (tokens/sec)
+     */
+    p50?: number | null | undefined;
+    /**
+     * Minimum p75 throughput (tokens/sec)
+     */
+    p75?: number | null | undefined;
+    /**
+     * Minimum p90 throughput (tokens/sec)
+     */
+    p90?: number | null | undefined;
+    /**
+     * Minimum p99 throughput (tokens/sec)
+     */
+    p99?: number | null | undefined;
+};
+/** @internal */
+export type PercentileThroughputCutoffs$Outbound = {
+    p50?: number | null | undefined;
+    p75?: number | null | undefined;
+    p90?: number | null | undefined;
+    p99?: number | null | undefined;
+};
+/** @internal */
+export declare const PercentileThroughputCutoffs$outboundSchema: z.ZodType<PercentileThroughputCutoffs$Outbound, PercentileThroughputCutoffs>;
+export declare function percentileThroughputCutoffsToJSON(percentileThroughputCutoffs: PercentileThroughputCutoffs): string;
+//# sourceMappingURL=percentilethroughputcutoffs.d.ts.map

package/esm/models/percentilethroughputcutoffs.js

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 366b617b09b4
+ */
+import * as z from "zod/v4";
+/** @internal */
+export const PercentileThroughputCutoffs$outboundSchema = z.object({
+    p50: z.nullable(z.number()).optional(),
+    p75: z.nullable(z.number()).optional(),
+    p90: z.nullable(z.number()).optional(),
+    p99: z.nullable(z.number()).optional(),
+});
+export function percentileThroughputCutoffsToJSON(percentileThroughputCutoffs) {
+    return JSON.stringify(PercentileThroughputCutoffs$outboundSchema.parse(percentileThroughputCutoffs));
+}
+//# sourceMappingURL=percentilethroughputcutoffs.js.map

package/esm/models/preferredmaxlatency.d.ts

@@ -0,0 +1,12 @@
+import * as z from "zod/v4";
+import { PercentileLatencyCutoffs, PercentileLatencyCutoffs$Outbound } from "./percentilelatencycutoffs.js";
+/**
+ * Preferred maximum latency (in seconds). Can be a number (applies to p50) or an object with percentile-specific cutoffs. Endpoints above the threshold(s) may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
+ */
+export type PreferredMaxLatency = number | PercentileLatencyCutoffs | any;
+/** @internal */
+export type PreferredMaxLatency$Outbound = number | PercentileLatencyCutoffs$Outbound | any;
+/** @internal */
+export declare const PreferredMaxLatency$outboundSchema: z.ZodType<PreferredMaxLatency$Outbound, PreferredMaxLatency>;
+export declare function preferredMaxLatencyToJSON(preferredMaxLatency: PreferredMaxLatency): string;
+//# sourceMappingURL=preferredmaxlatency.d.ts.map

package/esm/models/preferredmaxlatency.js

@@ -0,0 +1,12 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 17fc19055e19
+ */
+import * as z from "zod/v4";
+import { PercentileLatencyCutoffs$outboundSchema, } from "./percentilelatencycutoffs.js";
+/** @internal */
+export const PreferredMaxLatency$outboundSchema = z.union([z.number(), PercentileLatencyCutoffs$outboundSchema, z.any()]);
+export function preferredMaxLatencyToJSON(preferredMaxLatency) {
+    return JSON.stringify(PreferredMaxLatency$outboundSchema.parse(preferredMaxLatency));
+}
+//# sourceMappingURL=preferredmaxlatency.js.map

package/esm/models/preferredminthroughput.d.ts

@@ -0,0 +1,12 @@
+import * as z from "zod/v4";
+import { PercentileThroughputCutoffs, PercentileThroughputCutoffs$Outbound } from "./percentilethroughputcutoffs.js";
+/**
+ * Preferred minimum throughput (in tokens per second). Can be a number (applies to p50) or an object with percentile-specific cutoffs. Endpoints below the threshold(s) may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
+ */
+export type PreferredMinThroughput = number | PercentileThroughputCutoffs | any;
+/** @internal */
+export type PreferredMinThroughput$Outbound = number | PercentileThroughputCutoffs$Outbound | any;
+/** @internal */
+export declare const PreferredMinThroughput$outboundSchema: z.ZodType<PreferredMinThroughput$Outbound, PreferredMinThroughput>;
+export declare function preferredMinThroughputToJSON(preferredMinThroughput: PreferredMinThroughput): string;
+//# sourceMappingURL=preferredminthroughput.d.ts.map

package/esm/models/preferredminthroughput.js

@@ -0,0 +1,12 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 04b7597c84f9
+ */
+import * as z from "zod/v4";
+import { PercentileThroughputCutoffs$outboundSchema, } from "./percentilethroughputcutoffs.js";
+/** @internal */
+export const PreferredMinThroughput$outboundSchema = z.union([z.number(), PercentileThroughputCutoffs$outboundSchema, z.any()]);
+export function preferredMinThroughputToJSON(preferredMinThroughput) {
+    return JSON.stringify(PreferredMinThroughput$outboundSchema.parse(preferredMinThroughput));
+}
+//# sourceMappingURL=preferredminthroughput.js.map

package/esm/models/providername.d.ts

@@ -27,12 +27,12 @@ export declare const ProviderName: {
     readonly Fireworks: "Fireworks";
     readonly Friendli: "Friendli";
     readonly GMICloud: "GMICloud";
-    readonly GoPomelo: "GoPomelo";
     readonly Google: "Google";
     readonly GoogleAIStudio: "Google AI Studio";
     readonly Groq: "Groq";
     readonly Hyperbolic: "Hyperbolic";
     readonly Inception: "Inception";
+    readonly Inceptron: "Inceptron";
     readonly InferenceNet: "InferenceNet";
     readonly Infermatic: "Infermatic";
     readonly Inflection: "Inflection";
@@ -57,13 +57,14 @@ export declare const ProviderName: {
     readonly Phala: "Phala";
     readonly Relace: "Relace";
     readonly SambaNova: "SambaNova";
+    readonly Seed: "Seed";
     readonly SiliconFlow: "SiliconFlow";
     readonly Sourceful: "Sourceful";
     readonly Stealth: "Stealth";
     readonly StreamLake: "StreamLake";
     readonly Switchpoint: "Switchpoint";
-    readonly Targon: "Targon";
     readonly Together: "Together";
+    readonly Upstage: "Upstage";
     readonly Venice: "Venice";
     readonly WandB: "WandB";
     readonly Xiaomi: "Xiaomi";

package/esm/models/providername.js

@@ -30,12 +30,12 @@ export const ProviderName = {
     Fireworks: "Fireworks",
     Friendli: "Friendli",
     GMICloud: "GMICloud",
-    GoPomelo: "GoPomelo",
     Google: "Google",
     GoogleAIStudio: "Google AI Studio",
     Groq: "Groq",
     Hyperbolic: "Hyperbolic",
     Inception: "Inception",
+    Inceptron: "Inceptron",
     InferenceNet: "InferenceNet",
     Infermatic: "Infermatic",
     Inflection: "Inflection",
@@ -60,13 +60,14 @@ export const ProviderName = {
     Phala: "Phala",
     Relace: "Relace",
     SambaNova: "SambaNova",
+    Seed: "Seed",
     SiliconFlow: "SiliconFlow",
     Sourceful: "Sourceful",
     Stealth: "Stealth",
     StreamLake: "StreamLake",
     Switchpoint: "Switchpoint",
-    Targon: "Targon",
     Together: "Together",
+    Upstage: "Upstage",
     Venice: "Venice",
     WandB: "WandB",
     Xiaomi: "Xiaomi",

package/esm/models/providerpreferences.d.ts

@@ -1,6 +1,8 @@
 import * as z from "zod/v4";
 import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { DataCollection } from "./datacollection.js";
+import { PreferredMaxLatency, PreferredMaxLatency$Outbound } from "./preferredmaxlatency.js";
+import { PreferredMinThroughput, PreferredMinThroughput$Outbound } from "./preferredminthroughput.js";
 import { ProviderName } from "./providername.js";
 import { ProviderSort } from "./providersort.js";
 import { Quantization } from "./quantization.js";
@@ -119,25 +121,13 @@ export type ProviderPreferences = {
      */
     maxPrice?: ProviderPreferencesMaxPrice | undefined;
     /**
-     * Preferred minimum throughput (in tokens per second). Endpoints below this threshold may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
+     * Preferred minimum throughput (in tokens per second). Can be a number (applies to p50) or an object with percentile-specific cutoffs. Endpoints below the threshold(s) may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
      */
-    preferredMinThroughput?: number | null | undefined;
+    preferredMinThroughput?: PreferredMinThroughput | null | undefined;
     /**
-     * Preferred maximum latency (in seconds). Endpoints above this threshold may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
+     * Preferred maximum latency (in seconds). Can be a number (applies to p50) or an object with percentile-specific cutoffs. Endpoints above the threshold(s) may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
      */
-    preferredMaxLatency?: number | null | undefined;
-    /**
-     * **DEPRECATED** Use preferred_min_throughput instead. Backwards-compatible alias for preferred_min_throughput.
-     *
-     * @deprecated field: Use preferred_min_throughput instead..
-     */
-    minThroughput?: number | null | undefined;
-    /**
-     * **DEPRECATED** Use preferred_max_latency instead. Backwards-compatible alias for preferred_max_latency.
-     *
-     * @deprecated field: Use preferred_max_latency instead..
-     */
-    maxLatency?: number | null | undefined;
+    preferredMaxLatency?: PreferredMaxLatency | null | undefined;
 };
 /** @internal */
 export type ProviderPreferencesOrder$Outbound = string | string;
@@ -204,10 +194,8 @@ export type ProviderPreferences$Outbound = {
     quantizations?: Array<string> | null | undefined;
     sort?: string | ProviderPreferencesProviderSortConfig$Outbound | string | string | null | undefined;
     max_price?: ProviderPreferencesMaxPrice$Outbound | undefined;
-    preferred_min_throughput?: number | null | undefined;
-    preferred_max_latency?: number | null | undefined;
-    min_throughput?: number | null | undefined;
-    max_latency?: number | null | undefined;
+    preferred_min_throughput?: PreferredMinThroughput$Outbound | null | undefined;
+    preferred_max_latency?: PreferredMaxLatency$Outbound | null | undefined;
 };
 /** @internal */
 export declare const ProviderPreferences$outboundSchema: z.ZodType<ProviderPreferences$Outbound, ProviderPreferences>;

package/esm/models/providerpreferences.js

@@ -6,6 +6,8 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import * as openEnums from "../types/enums.js";
 import { DataCollection$outboundSchema, } from "./datacollection.js";
+import { PreferredMaxLatency$outboundSchema, } from "./preferredmaxlatency.js";
+import { PreferredMinThroughput$outboundSchema, } from "./preferredminthroughput.js";
 import { ProviderName$outboundSchema } from "./providername.js";
 import { ProviderSort$outboundSchema } from "./providersort.js";
 import { Quantization$outboundSchema } from "./quantization.js";
@@ -113,10 +115,10 @@ export const ProviderPreferences$outboundSchema = z.object({
         SortEnum$outboundSchema,
     ])).optional(),
     maxPrice: z.lazy(() => ProviderPreferencesMaxPrice$outboundSchema).optional(),
-    preferredMinThroughput: z.nullable(z.number()).optional(),
-    preferredMaxLatency: z.nullable(z.number()).optional(),
-    minThroughput: z.nullable(z.number()).optional(),
-    maxLatency: z.nullable(z.number()).optional(),
+    preferredMinThroughput: z.nullable(PreferredMinThroughput$outboundSchema)
+        .optional(),
+    preferredMaxLatency: z.nullable(PreferredMaxLatency$outboundSchema)
+        .optional(),
 }).transform((v) => {
     return remap$(v, {
         allowFallbacks: "allow_fallbacks",
@@ -126,8 +128,6 @@ export const ProviderPreferences$outboundSchema = z.object({
         maxPrice: "max_price",
         preferredMinThroughput: "preferred_min_throughput",
         preferredMaxLatency: "preferred_max_latency",
-        minThroughput: "min_throughput",
-        maxLatency: "max_latency",
     });
 });
 export function providerPreferencesToJSON(providerPreferences) {

package/esm/models/publicendpoint.d.ts

@@ -4,6 +4,7 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import { EndpointStatus } from "./endpointstatus.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { Parameter } from "./parameter.js";
+import { PercentileStats } from "./percentilestats.js";
 import { ProviderName } from "./providername.js";
 export type Pricing = {
     /**
@@ -85,6 +86,11 @@ export type PublicEndpoint = {
     status?: EndpointStatus | undefined;
     uptimeLast30m: number | null;
     supportsImplicitCaching: boolean;
+    /**
+     * Latency percentiles in milliseconds over the last 30 minutes. Latency measures time to first token. Only visible when authenticated with an API key or cookie; returns null for unauthenticated requests.
+     */
+    latencyLast30m: PercentileStats | null;
+    throughputLast30m: PercentileStats | null;
 };
 /** @internal */
 export declare const Pricing$inboundSchema: z.ZodType<Pricing, unknown>;

package/esm/models/publicendpoint.js

@@ -8,6 +8,7 @@ import { safeParse } from "../lib/schemas.js";
 import * as openEnums from "../types/enums.js";
 import { EndpointStatus$inboundSchema, } from "./endpointstatus.js";
 import { Parameter$inboundSchema } from "./parameter.js";
+import { PercentileStats$inboundSchema, } from "./percentilestats.js";
 import { ProviderName$inboundSchema } from "./providername.js";
 export const PublicEndpointQuantization = {
     Int4: "int4",
@@ -66,6 +67,8 @@ export const PublicEndpoint$inboundSchema = z.object({
     status: EndpointStatus$inboundSchema.optional(),
     uptime_last_30m: z.nullable(z.number()),
     supports_implicit_caching: z.boolean(),
+    latency_last_30m: z.nullable(PercentileStats$inboundSchema),
+    throughput_last_30m: z.nullable(PercentileStats$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
         "model_name": "modelName",
@@ -76,6 +79,8 @@ export const PublicEndpoint$inboundSchema = z.object({
         "supported_parameters": "supportedParameters",
         "uptime_last_30m": "uptimeLast30m",
         "supports_implicit_caching": "supportsImplicitCaching",
+        "latency_last_30m": "latencyLast30m",
+        "throughput_last_30m": "throughputLast30m",
     });
 });
 export function publicEndpointFromJSON(jsonString) {

package/esm/models/responseinputimage.d.ts

@@ -1,7 +1,11 @@
 import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ResponseInputImageType: {
+    readonly InputImage: "input_image";
+};
+export type ResponseInputImageType = ClosedEnum<typeof ResponseInputImageType>;
 export declare const ResponseInputImageDetail: {
     readonly Auto: "auto";
     readonly High: "high";
@@ -12,11 +16,15 @@ export type ResponseInputImageDetail = OpenEnum<typeof ResponseInputImageDetail>
  * Image input content item
  */
 export type ResponseInputImage = {
-    type: "input_image";
+    type: ResponseInputImageType;
     detail: ResponseInputImageDetail;
     imageUrl?: string | null | undefined;
 };
 /** @internal */
+export declare const ResponseInputImageType$inboundSchema: z.ZodEnum<typeof ResponseInputImageType>;
+/** @internal */
+export declare const ResponseInputImageType$outboundSchema: z.ZodEnum<typeof ResponseInputImageType>;
+/** @internal */
 export declare const ResponseInputImageDetail$inboundSchema: z.ZodType<ResponseInputImageDetail, unknown>;
 /** @internal */
 export declare const ResponseInputImageDetail$outboundSchema: z.ZodType<string, ResponseInputImageDetail>;
@@ -24,7 +32,7 @@ export declare const ResponseInputImageDetail$outboundSchema: z.ZodType<string,
 export declare const ResponseInputImage$inboundSchema: z.ZodType<ResponseInputImage, unknown>;
 /** @internal */
 export type ResponseInputImage$Outbound = {
-    type: "input_image";
+    type: string;
     detail: string;
     image_url?: string | null | undefined;
 };

package/esm/models/responseinputimage.js

@@ -6,18 +6,25 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import * as openEnums from "../types/enums.js";
+export const ResponseInputImageType = {
+    InputImage: "input_image",
+};
 export const ResponseInputImageDetail = {
     Auto: "auto",
     High: "high",
     Low: "low",
 };
 /** @internal */
+export const ResponseInputImageType$inboundSchema = z.enum(ResponseInputImageType);
+/** @internal */
+export const ResponseInputImageType$outboundSchema = ResponseInputImageType$inboundSchema;
+/** @internal */
 export const ResponseInputImageDetail$inboundSchema = openEnums.inboundSchema(ResponseInputImageDetail);
 /** @internal */
 export const ResponseInputImageDetail$outboundSchema = openEnums.outboundSchema(ResponseInputImageDetail);
 /** @internal */
 export const ResponseInputImage$inboundSchema = z.object({
-    type: z.literal("input_image"),
+    type: ResponseInputImageType$inboundSchema,
     detail: ResponseInputImageDetail$inboundSchema,
     image_url: z.nullable(z.string()).optional(),
 }).transform((v) => {
@@ -27,7 +34,7 @@ export const ResponseInputImage$inboundSchema = z.object({
 });
 /** @internal */
 export const ResponseInputImage$outboundSchema = z.object({
-    type: z.literal("input_image"),
+    type: ResponseInputImageType$outboundSchema,
     detail: ResponseInputImageDetail$outboundSchema,
     imageUrl: z.nullable(z.string()).optional(),
 }).transform((v) => {

package/esm/models/responseinputvideo.d.ts

@@ -0,0 +1,20 @@
+import * as z from "zod/v4";
+/**
+ * Video input content item
+ */
+export type ResponseInputVideo = {
+    type: "input_video";
+    /**
+     * A base64 data URL or remote URL that resolves to a video file
+     */
+    videoUrl: string;
+};
+/** @internal */
+export type ResponseInputVideo$Outbound = {
+    type: "input_video";
+    video_url: string;
+};
+/** @internal */
+export declare const ResponseInputVideo$outboundSchema: z.ZodType<ResponseInputVideo$Outbound, ResponseInputVideo>;
+export declare function responseInputVideoToJSON(responseInputVideo: ResponseInputVideo): string;
+//# sourceMappingURL=responseinputvideo.d.ts.map

package/esm/models/responseinputvideo.js

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: be5ad9346721
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+/** @internal */
+export const ResponseInputVideo$outboundSchema = z.object({
+    type: z.literal("input_video"),
+    videoUrl: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        videoUrl: "video_url",
+    });
+});
+export function responseInputVideoToJSON(responseInputVideo) {
+    return JSON.stringify(ResponseInputVideo$outboundSchema.parse(responseInputVideo));
+}
+//# sourceMappingURL=responseinputvideo.js.map