@openrouter/sdk 0.11.2 → 0.12.0

package/esm/models/reasoningitem.d.ts

@@ -1,11 +1,8 @@
 import * as z from "zod/v4";
-import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { ClosedEnum } from "../types/enums.js";
+import { ReasoningFormat } from "./reasoningformat.js";
 import { ReasoningSummaryText, ReasoningSummaryText$Outbound } from "./reasoningsummarytext.js";
 import { ReasoningTextContent, ReasoningTextContent$Outbound } from "./reasoningtextcontent.js";
-export declare const ReasoningItemType: {
-    readonly Reasoning: "reasoning";
-};
-export type ReasoningItemType = ClosedEnum<typeof ReasoningItemType>;
 export declare const ReasoningItemStatusInProgress: {
     readonly InProgress: "in_progress";
 };
@@ -19,31 +16,24 @@ export declare const ReasoningItemStatusCompleted: {
 };
 export type ReasoningItemStatusCompleted = ClosedEnum<typeof ReasoningItemStatusCompleted>;
 export type ReasoningItemStatusUnion = ReasoningItemStatusCompleted | ReasoningItemStatusIncomplete | ReasoningItemStatusInProgress;
-export declare const ReasoningItemFormat: {
-    readonly Unknown: "unknown";
-    readonly OpenaiResponsesV1: "openai-responses-v1";
-    readonly AzureOpenaiResponsesV1: "azure-openai-responses-v1";
-    readonly XaiResponsesV1: "xai-responses-v1";
-    readonly AnthropicClaudeV1: "anthropic-claude-v1";
-    readonly GoogleGeminiV1: "google-gemini-v1";
+export declare const ReasoningItemType: {
+    readonly Reasoning: "reasoning";
 };
-export type ReasoningItemFormat = OpenEnum<typeof ReasoningItemFormat>;
+export type ReasoningItemType = ClosedEnum<typeof ReasoningItemType>;
 /**
  * Reasoning output item with signature and format extensions
  */
 export type ReasoningItem = {
-    type: ReasoningItemType;
-    id: string;
     content?: Array<ReasoningTextContent> | null | undefined;
-    summary: Array<ReasoningSummaryText>;
     encryptedContent?: string | null | undefined;
+    id: string;
     status?: ReasoningItemStatusCompleted | ReasoningItemStatusIncomplete | ReasoningItemStatusInProgress | undefined;
+    summary: Array<ReasoningSummaryText>;
+    type: ReasoningItemType;
+    format?: ReasoningFormat | null | undefined;
     signature?: string | null | undefined;
-    format?: ReasoningItemFormat | null | undefined;
 };
 /** @internal */
-export declare const ReasoningItemType$outboundSchema: z.ZodEnum<typeof ReasoningItemType>;
-/** @internal */
 export declare const ReasoningItemStatusInProgress$outboundSchema: z.ZodEnum<typeof ReasoningItemStatusInProgress>;
 /** @internal */
 export declare const ReasoningItemStatusIncomplete$outboundSchema: z.ZodEnum<typeof ReasoningItemStatusIncomplete>;
@@ -55,17 +45,17 @@ export type ReasoningItemStatusUnion$Outbound = string | string | string;
 export declare const ReasoningItemStatusUnion$outboundSchema: z.ZodType<ReasoningItemStatusUnion$Outbound, ReasoningItemStatusUnion>;
 export declare function reasoningItemStatusUnionToJSON(reasoningItemStatusUnion: ReasoningItemStatusUnion): string;
 /** @internal */
-export declare const ReasoningItemFormat$outboundSchema: z.ZodType<string, ReasoningItemFormat>;
+export declare const ReasoningItemType$outboundSchema: z.ZodEnum<typeof ReasoningItemType>;
 /** @internal */
 export type ReasoningItem$Outbound = {
-    type: string;
-    id: string;
     content?: Array<ReasoningTextContent$Outbound> | null | undefined;
-    summary: Array<ReasoningSummaryText$Outbound>;
     encrypted_content?: string | null | undefined;
+    id: string;
     status?: string | string | string | undefined;
-    signature?: string | null | undefined;
+    summary: Array<ReasoningSummaryText$Outbound>;
+    type: string;
     format?: string | null | undefined;
+    signature?: string | null | undefined;
 };
 /** @internal */
 export declare const ReasoningItem$outboundSchema: z.ZodType<ReasoningItem$Outbound, ReasoningItem>;

package/esm/models/reasoningitem.js

@@ -4,12 +4,9 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
-import * as openEnums from "../types/enums.js";
+import { ReasoningFormat$outboundSchema, } from "./reasoningformat.js";
 import { ReasoningSummaryText$outboundSchema, } from "./reasoningsummarytext.js";
 import { ReasoningTextContent$outboundSchema, } from "./reasoningtextcontent.js";
-export const ReasoningItemType = {
-    Reasoning: "reasoning",
-};
 export const ReasoningItemStatusInProgress = {
     InProgress: "in_progress",
 };
@@ -19,17 +16,10 @@ export const ReasoningItemStatusIncomplete = {
 export const ReasoningItemStatusCompleted = {
     Completed: "completed",
 };
-export const ReasoningItemFormat = {
-    Unknown: "unknown",
-    OpenaiResponsesV1: "openai-responses-v1",
-    AzureOpenaiResponsesV1: "azure-openai-responses-v1",
-    XaiResponsesV1: "xai-responses-v1",
-    AnthropicClaudeV1: "anthropic-claude-v1",
-    GoogleGeminiV1: "google-gemini-v1",
+export const ReasoningItemType = {
+    Reasoning: "reasoning",
 };
 /** @internal */
-export const ReasoningItemType$outboundSchema = z.enum(ReasoningItemType);
-/** @internal */
 export const ReasoningItemStatusInProgress$outboundSchema = z.enum(ReasoningItemStatusInProgress);
 /** @internal */
 export const ReasoningItemStatusIncomplete$outboundSchema = z.enum(ReasoningItemStatusIncomplete);
@@ -45,21 +35,21 @@ export function reasoningItemStatusUnionToJSON(reasoningItemStatusUnion) {
     return JSON.stringify(ReasoningItemStatusUnion$outboundSchema.parse(reasoningItemStatusUnion));
 }
 /** @internal */
-export const ReasoningItemFormat$outboundSchema = openEnums.outboundSchema(ReasoningItemFormat);
+export const ReasoningItemType$outboundSchema = z.enum(ReasoningItemType);
 /** @internal */
 export const ReasoningItem$outboundSchema = z.object({
-    type: ReasoningItemType$outboundSchema,
-    id: z.string(),
     content: z.nullable(z.array(ReasoningTextContent$outboundSchema)).optional(),
-    summary: z.array(ReasoningSummaryText$outboundSchema),
     encryptedContent: z.nullable(z.string()).optional(),
+    id: z.string(),
     status: z.union([
         ReasoningItemStatusCompleted$outboundSchema,
         ReasoningItemStatusIncomplete$outboundSchema,
         ReasoningItemStatusInProgress$outboundSchema,
     ]).optional(),
+    summary: z.array(ReasoningSummaryText$outboundSchema),
+    type: ReasoningItemType$outboundSchema,
+    format: z.nullable(ReasoningFormat$outboundSchema).optional(),
     signature: z.nullable(z.string()).optional(),
-    format: z.nullable(ReasoningItemFormat$outboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         encryptedContent: "encrypted_content",

package/esm/models/reasoningsummarypartaddedevent.d.ts

@@ -6,12 +6,12 @@ import { ReasoningSummaryText } from "./reasoningsummarytext.js";
  * Event emitted when a reasoning summary part is added
  */
 export type ReasoningSummaryPartAddedEvent = {
-    type: "response.reasoning_summary_part.added";
-    outputIndex: number;
     itemId: string;
-    summaryIndex: number;
+    outputIndex: number;
     part: ReasoningSummaryText;
     sequenceNumber: number;
+    summaryIndex: number;
+    type: "response.reasoning_summary_part.added";
 };
 /** @internal */
 export declare const ReasoningSummaryPartAddedEvent$inboundSchema: z.ZodType<ReasoningSummaryPartAddedEvent, unknown>;

package/esm/models/reasoningsummarypartaddedevent.js

@@ -8,18 +8,18 @@ import { safeParse } from "../lib/schemas.js";
 import { ReasoningSummaryText$inboundSchema, } from "./reasoningsummarytext.js";
 /** @internal */
 export const ReasoningSummaryPartAddedEvent$inboundSchema = z.object({
-    type: z.literal("response.reasoning_summary_part.added"),
-    output_index: z.number(),
     item_id: z.string(),
-    summary_index: z.number(),
+    output_index: z.int(),
     part: ReasoningSummaryText$inboundSchema,
-    sequence_number: z.number(),
+    sequence_number: z.int(),
+    summary_index: z.int(),
+    type: z.literal("response.reasoning_summary_part.added"),
 }).transform((v) => {
     return remap$(v, {
-        "output_index": "outputIndex",
         "item_id": "itemId",
-        "summary_index": "summaryIndex",
+        "output_index": "outputIndex",
         "sequence_number": "sequenceNumber",
+        "summary_index": "summaryIndex",
     });
 });
 export function reasoningSummaryPartAddedEventFromJSON(jsonString) {

package/esm/models/reasoningsummarypartdoneevent.d.ts

@@ -6,12 +6,12 @@ import { ReasoningSummaryText } from "./reasoningsummarytext.js";
  * Event emitted when a reasoning summary part is complete
  */
 export type ReasoningSummaryPartDoneEvent = {
-    type: "response.reasoning_summary_part.done";
-    outputIndex: number;
     itemId: string;
-    summaryIndex: number;
+    outputIndex: number;
     part: ReasoningSummaryText;
     sequenceNumber: number;
+    summaryIndex: number;
+    type: "response.reasoning_summary_part.done";
 };
 /** @internal */
 export declare const ReasoningSummaryPartDoneEvent$inboundSchema: z.ZodType<ReasoningSummaryPartDoneEvent, unknown>;

package/esm/models/reasoningsummarypartdoneevent.js

@@ -8,18 +8,18 @@ import { safeParse } from "../lib/schemas.js";
 import { ReasoningSummaryText$inboundSchema, } from "./reasoningsummarytext.js";
 /** @internal */
 export const ReasoningSummaryPartDoneEvent$inboundSchema = z.object({
-    type: z.literal("response.reasoning_summary_part.done"),
-    output_index: z.number(),
     item_id: z.string(),
-    summary_index: z.number(),
+    output_index: z.int(),
     part: ReasoningSummaryText$inboundSchema,
-    sequence_number: z.number(),
+    sequence_number: z.int(),
+    summary_index: z.int(),
+    type: z.literal("response.reasoning_summary_part.done"),
 }).transform((v) => {
     return remap$(v, {
-        "output_index": "outputIndex",
         "item_id": "itemId",
-        "summary_index": "summaryIndex",
+        "output_index": "outputIndex",
         "sequence_number": "sequenceNumber",
+        "summary_index": "summaryIndex",
     });
 });
 export function reasoningSummaryPartDoneEventFromJSON(jsonString) {

package/esm/models/reasoningsummarytext.d.ts

@@ -7,8 +7,8 @@ export declare const ReasoningSummaryTextType: {
 };
 export type ReasoningSummaryTextType = ClosedEnum<typeof ReasoningSummaryTextType>;
 export type ReasoningSummaryText = {
-    type: ReasoningSummaryTextType;
     text: string;
+    type: ReasoningSummaryTextType;
 };
 /** @internal */
 export declare const ReasoningSummaryTextType$inboundSchema: z.ZodEnum<typeof ReasoningSummaryTextType>;
@@ -18,8 +18,8 @@ export declare const ReasoningSummaryTextType$outboundSchema: z.ZodEnum<typeof R
 export declare const ReasoningSummaryText$inboundSchema: z.ZodType<ReasoningSummaryText, unknown>;
 /** @internal */
 export type ReasoningSummaryText$Outbound = {
-    type: string;
     text: string;
+    type: string;
 };
 /** @internal */
 export declare const ReasoningSummaryText$outboundSchema: z.ZodType<ReasoningSummaryText$Outbound, ReasoningSummaryText>;

package/esm/models/reasoningsummarytext.js

@@ -13,13 +13,13 @@ export const ReasoningSummaryTextType$inboundSchema = z.enum(ReasoningSummaryTex
 export const ReasoningSummaryTextType$outboundSchema = ReasoningSummaryTextType$inboundSchema;
 /** @internal */
 export const ReasoningSummaryText$inboundSchema = z.object({
-    type: ReasoningSummaryTextType$inboundSchema,
     text: z.string(),
+    type: ReasoningSummaryTextType$inboundSchema,
 });
 /** @internal */
 export const ReasoningSummaryText$outboundSchema = z.object({
-    type: ReasoningSummaryTextType$outboundSchema,
     text: z.string(),
+    type: ReasoningSummaryTextType$outboundSchema,
 });
 export function reasoningSummaryTextToJSON(reasoningSummaryText) {
     return JSON.stringify(ReasoningSummaryText$outboundSchema.parse(reasoningSummaryText));

package/esm/models/reasoningsummarytextdeltaevent.d.ts

@@ -5,12 +5,12 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  * Event emitted when reasoning summary text delta is streamed
  */
 export type ReasoningSummaryTextDeltaEvent = {
-    type: "response.reasoning_summary_text.delta";
+    delta: string;
     itemId: string;
     outputIndex: number;
-    summaryIndex: number;
-    delta: string;
     sequenceNumber: number;
+    summaryIndex: number;
+    type: "response.reasoning_summary_text.delta";
 };
 /** @internal */
 export declare const ReasoningSummaryTextDeltaEvent$inboundSchema: z.ZodType<ReasoningSummaryTextDeltaEvent, unknown>;

package/esm/models/reasoningsummarytextdeltaevent.js

@@ -7,18 +7,18 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const ReasoningSummaryTextDeltaEvent$inboundSchema = z.object({
-    type: z.literal("response.reasoning_summary_text.delta"),
-    item_id: z.string(),
-    output_index: z.number(),
-    summary_index: z.number(),
     delta: z.string(),
-    sequence_number: z.number(),
+    item_id: z.string(),
+    output_index: z.int(),
+    sequence_number: z.int(),
+    summary_index: z.int(),
+    type: z.literal("response.reasoning_summary_text.delta"),
 }).transform((v) => {
     return remap$(v, {
         "item_id": "itemId",
         "output_index": "outputIndex",
-        "summary_index": "summaryIndex",
         "sequence_number": "sequenceNumber",
+        "summary_index": "summaryIndex",
     });
 });
 export function reasoningSummaryTextDeltaEventFromJSON(jsonString) {

package/esm/models/reasoningsummarytextdoneevent.d.ts

@@ -5,12 +5,12 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  * Event emitted when reasoning summary text streaming is complete
  */
 export type ReasoningSummaryTextDoneEvent = {
-    type: "response.reasoning_summary_text.done";
     itemId: string;
     outputIndex: number;
+    sequenceNumber: number;
     summaryIndex: number;
     text: string;
-    sequenceNumber: number;
+    type: "response.reasoning_summary_text.done";
 };
 /** @internal */
 export declare const ReasoningSummaryTextDoneEvent$inboundSchema: z.ZodType<ReasoningSummaryTextDoneEvent, unknown>;

package/esm/models/reasoningsummarytextdoneevent.js

@@ -7,18 +7,18 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const ReasoningSummaryTextDoneEvent$inboundSchema = z.object({
-    type: z.literal("response.reasoning_summary_text.done"),
     item_id: z.string(),
-    output_index: z.number(),
-    summary_index: z.number(),
+    output_index: z.int(),
+    sequence_number: z.int(),
+    summary_index: z.int(),
     text: z.string(),
-    sequence_number: z.number(),
+    type: z.literal("response.reasoning_summary_text.done"),
 }).transform((v) => {
     return remap$(v, {
         "item_id": "itemId",
         "output_index": "outputIndex",
-        "summary_index": "summaryIndex",
         "sequence_number": "sequenceNumber",
+        "summary_index": "summaryIndex",
     });
 });
 export function reasoningSummaryTextDoneEventFromJSON(jsonString) {

package/esm/models/reasoningsummaryverbosity.d.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+export declare const ReasoningSummaryVerbosity: {
+    readonly Auto: "auto";
+    readonly Concise: "concise";
+    readonly Detailed: "detailed";
+};
+export type ReasoningSummaryVerbosity = OpenEnum<typeof ReasoningSummaryVerbosity>;
+/** @internal */
+export declare const ReasoningSummaryVerbosity$inboundSchema: z.ZodType<ReasoningSummaryVerbosity, unknown>;
+/** @internal */
+export declare const ReasoningSummaryVerbosity$outboundSchema: z.ZodType<string, ReasoningSummaryVerbosity>;
+//# sourceMappingURL=reasoningsummaryverbosity.d.ts.map

package/esm/models/reasoningsummaryverbosity.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: a51c85f04729
+ */
+import * as openEnums from "../types/enums.js";
+export const ReasoningSummaryVerbosity = {
+    Auto: "auto",
+    Concise: "concise",
+    Detailed: "detailed",
+};
+/** @internal */
+export const ReasoningSummaryVerbosity$inboundSchema = openEnums.inboundSchema(ReasoningSummaryVerbosity);
+/** @internal */
+export const ReasoningSummaryVerbosity$outboundSchema = openEnums.outboundSchema(ReasoningSummaryVerbosity);
+//# sourceMappingURL=reasoningsummaryverbosity.js.map

package/esm/models/reasoningtextcontent.d.ts

@@ -7,8 +7,8 @@ export declare const ReasoningTextContentType: {
 };
 export type ReasoningTextContentType = ClosedEnum<typeof ReasoningTextContentType>;
 export type ReasoningTextContent = {
-    type: ReasoningTextContentType;
     text: string;
+    type: ReasoningTextContentType;
 };
 /** @internal */
 export declare const ReasoningTextContentType$inboundSchema: z.ZodEnum<typeof ReasoningTextContentType>;
@@ -18,8 +18,8 @@ export declare const ReasoningTextContentType$outboundSchema: z.ZodEnum<typeof R
 export declare const ReasoningTextContent$inboundSchema: z.ZodType<ReasoningTextContent, unknown>;
 /** @internal */
 export type ReasoningTextContent$Outbound = {
-    type: string;
     text: string;
+    type: string;
 };
 /** @internal */
 export declare const ReasoningTextContent$outboundSchema: z.ZodType<ReasoningTextContent$Outbound, ReasoningTextContent>;

package/esm/models/reasoningtextcontent.js

@@ -13,13 +13,13 @@ export const ReasoningTextContentType$inboundSchema = z.enum(ReasoningTextConten
 export const ReasoningTextContentType$outboundSchema = ReasoningTextContentType$inboundSchema;
 /** @internal */
 export const ReasoningTextContent$inboundSchema = z.object({
-    type: ReasoningTextContentType$inboundSchema,
     text: z.string(),
+    type: ReasoningTextContentType$inboundSchema,
 });
 /** @internal */
 export const ReasoningTextContent$outboundSchema = z.object({
-    type: ReasoningTextContentType$outboundSchema,
     text: z.string(),
+    type: ReasoningTextContentType$outboundSchema,
 });
 export function reasoningTextContentToJSON(reasoningTextContent) {
     return JSON.stringify(ReasoningTextContent$outboundSchema.parse(reasoningTextContent));

package/esm/models/refusaldeltaevent.d.ts

@@ -5,12 +5,12 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  * Event emitted when a refusal delta is streamed
  */
 export type RefusalDeltaEvent = {
-    type: "response.refusal.delta";
-    outputIndex: number;
-    itemId: string;
     contentIndex: number;
     delta: string;
+    itemId: string;
+    outputIndex: number;
     sequenceNumber: number;
+    type: "response.refusal.delta";
 };
 /** @internal */
 export declare const RefusalDeltaEvent$inboundSchema: z.ZodType<RefusalDeltaEvent, unknown>;

package/esm/models/refusaldeltaevent.js

@@ -7,17 +7,17 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const RefusalDeltaEvent$inboundSchema = z.object({
-    type: z.literal("response.refusal.delta"),
-    output_index: z.number(),
-    item_id: z.string(),
-    content_index: z.number(),
+    content_index: z.int(),
     delta: z.string(),
-    sequence_number: z.number(),
+    item_id: z.string(),
+    output_index: z.int(),
+    sequence_number: z.int(),
+    type: z.literal("response.refusal.delta"),
 }).transform((v) => {
     return remap$(v, {
-        "output_index": "outputIndex",
-        "item_id": "itemId",
         "content_index": "contentIndex",
+        "item_id": "itemId",
+        "output_index": "outputIndex",
         "sequence_number": "sequenceNumber",
     });
 });

package/esm/models/refusaldoneevent.d.ts

@@ -5,12 +5,12 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  * Event emitted when refusal streaming is complete
  */
 export type RefusalDoneEvent = {
-    type: "response.refusal.done";
-    outputIndex: number;
-    itemId: string;
     contentIndex: number;
+    itemId: string;
+    outputIndex: number;
     refusal: string;
     sequenceNumber: number;
+    type: "response.refusal.done";
 };
 /** @internal */
 export declare const RefusalDoneEvent$inboundSchema: z.ZodType<RefusalDoneEvent, unknown>;

package/esm/models/refusaldoneevent.js

@@ -7,17 +7,17 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const RefusalDoneEvent$inboundSchema = z.object({
-    type: z.literal("response.refusal.done"),
-    output_index: z.number(),
+    content_index: z.int(),
     item_id: z.string(),
-    content_index: z.number(),
+    output_index: z.int(),
     refusal: z.string(),
-    sequence_number: z.number(),
+    sequence_number: z.int(),
+    type: z.literal("response.refusal.done"),
 }).transform((v) => {
     return remap$(v, {
-        "output_index": "outputIndex",
-        "item_id": "itemId",
         "content_index": "contentIndex",
+        "item_id": "itemId",
+        "output_index": "outputIndex",
         "sequence_number": "sequenceNumber",
     });
 });

package/esm/models/responsehealingplugin.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod/v4";
+export type ResponseHealingPlugin = {
+    /**
+     * Set to false to disable the response-healing plugin for this request. Defaults to true.
+     */
+    enabled?: boolean | undefined;
+    id: "response-healing";
+};
+/** @internal */
+export type ResponseHealingPlugin$Outbound = {
+    enabled?: boolean | undefined;
+    id: "response-healing";
+};
+/** @internal */
+export declare const ResponseHealingPlugin$outboundSchema: z.ZodType<ResponseHealingPlugin$Outbound, ResponseHealingPlugin>;
+export declare function responseHealingPluginToJSON(responseHealingPlugin: ResponseHealingPlugin): string;
+//# sourceMappingURL=responsehealingplugin.d.ts.map

package/esm/models/responsehealingplugin.js

@@ -0,0 +1,14 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 622c12ba88e2
+ */
+import * as z from "zod/v4";
+/** @internal */
+export const ResponseHealingPlugin$outboundSchema = z.object({
+    enabled: z.boolean().optional(),
+    id: z.literal("response-healing"),
+});
+export function responseHealingPluginToJSON(responseHealingPlugin) {
+    return JSON.stringify(ResponseHealingPlugin$outboundSchema.parse(responseHealingPlugin));
+}
+//# sourceMappingURL=responsehealingplugin.js.map

package/esm/models/responseoutputtext.d.ts

@@ -3,55 +3,55 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { OpenAIResponsesAnnotation, OpenAIResponsesAnnotation$Outbound } from "./openairesponsesannotation.js";
 export type ResponseOutputTextTopLogprob = {
-    token: string;
     bytes: Array<number>;
     logprob: number;
-};
-export type ResponseOutputTextLogprob = {
     token: string;
+};
+export type Logprob = {
     bytes: Array<number>;
     logprob: number;
+    token: string;
     topLogprobs: Array<ResponseOutputTextTopLogprob>;
 };
 export type ResponseOutputText = {
-    type: "output_text";
-    text: string;
     annotations?: Array<OpenAIResponsesAnnotation> | undefined;
-    logprobs?: Array<ResponseOutputTextLogprob> | undefined;
+    logprobs?: Array<Logprob> | undefined;
+    text: string;
+    type: "output_text";
 };
 /** @internal */
 export declare const ResponseOutputTextTopLogprob$inboundSchema: z.ZodType<ResponseOutputTextTopLogprob, unknown>;
 /** @internal */
 export type ResponseOutputTextTopLogprob$Outbound = {
-    token: string;
     bytes: Array<number>;
     logprob: number;
+    token: string;
 };
 /** @internal */
 export declare const ResponseOutputTextTopLogprob$outboundSchema: z.ZodType<ResponseOutputTextTopLogprob$Outbound, ResponseOutputTextTopLogprob>;
 export declare function responseOutputTextTopLogprobToJSON(responseOutputTextTopLogprob: ResponseOutputTextTopLogprob): string;
 export declare function responseOutputTextTopLogprobFromJSON(jsonString: string): SafeParseResult<ResponseOutputTextTopLogprob, SDKValidationError>;
 /** @internal */
-export declare const ResponseOutputTextLogprob$inboundSchema: z.ZodType<ResponseOutputTextLogprob, unknown>;
+export declare const Logprob$inboundSchema: z.ZodType<Logprob, unknown>;
 /** @internal */
-export type ResponseOutputTextLogprob$Outbound = {
-    token: string;
+export type Logprob$Outbound = {
     bytes: Array<number>;
     logprob: number;
+    token: string;
     top_logprobs: Array<ResponseOutputTextTopLogprob$Outbound>;
 };
 /** @internal */
-export declare const ResponseOutputTextLogprob$outboundSchema: z.ZodType<ResponseOutputTextLogprob$Outbound, ResponseOutputTextLogprob>;
-export declare function responseOutputTextLogprobToJSON(responseOutputTextLogprob: ResponseOutputTextLogprob): string;
-export declare function responseOutputTextLogprobFromJSON(jsonString: string): SafeParseResult<ResponseOutputTextLogprob, SDKValidationError>;
+export declare const Logprob$outboundSchema: z.ZodType<Logprob$Outbound, Logprob>;
+export declare function logprobToJSON(logprob: Logprob): string;
+export declare function logprobFromJSON(jsonString: string): SafeParseResult<Logprob, SDKValidationError>;
 /** @internal */
 export declare const ResponseOutputText$inboundSchema: z.ZodType<ResponseOutputText, unknown>;
 /** @internal */
 export type ResponseOutputText$Outbound = {
-    type: "output_text";
-    text: string;
     annotations?: Array<OpenAIResponsesAnnotation$Outbound> | undefined;
-    logprobs?: Array<ResponseOutputTextLogprob$Outbound> | undefined;
+    logprobs?: Array<Logprob$Outbound> | undefined;
+    text: string;
+    type: "output_text";
 };
 /** @internal */
 export declare const ResponseOutputText$outboundSchema: z.ZodType<ResponseOutputText$Outbound, ResponseOutputText>;