@openrouter/sdk 0.1.27 → 0.2.6

package/esm/models/openresponsesimagegencallgenerating.d.ts

@@ -1,23 +1,16 @@
 import * as z from "zod/v4";
-import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const OpenResponsesImageGenCallGeneratingType: {
-    readonly ResponseImageGenerationCallGenerating: "response.image_generation_call.generating";
-};
-export type OpenResponsesImageGenCallGeneratingType = ClosedEnum<typeof OpenResponsesImageGenCallGeneratingType>;
 /**
  * Image generation call is generating
  */
 export type OpenResponsesImageGenCallGenerating = {
-    type: OpenResponsesImageGenCallGeneratingType;
+    type: "response.image_generation_call.generating";
     itemId: string;
     outputIndex: number;
     sequenceNumber: number;
 };
 /** @internal */
-export declare const OpenResponsesImageGenCallGeneratingType$inboundSchema: z.ZodEnum<typeof OpenResponsesImageGenCallGeneratingType>;
-/** @internal */
 export declare const OpenResponsesImageGenCallGenerating$inboundSchema: z.ZodType<OpenResponsesImageGenCallGenerating, unknown>;
 export declare function openResponsesImageGenCallGeneratingFromJSON(jsonString: string): SafeParseResult<OpenResponsesImageGenCallGenerating, SDKValidationError>;
 //# sourceMappingURL=openresponsesimagegencallgenerating.d.ts.map

package/esm/models/openresponsesimagegencallgenerating.js

@@ -4,14 +4,9 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-export const OpenResponsesImageGenCallGeneratingType = {
-    ResponseImageGenerationCallGenerating: "response.image_generation_call.generating",
-};
-/** @internal */
-export const OpenResponsesImageGenCallGeneratingType$inboundSchema = z.enum(OpenResponsesImageGenCallGeneratingType);
 /** @internal */
 export const OpenResponsesImageGenCallGenerating$inboundSchema = z.object({
-    type: OpenResponsesImageGenCallGeneratingType$inboundSchema,
+    type: z.literal("response.image_generation_call.generating"),
     item_id: z.string(),
     output_index: z.number(),
     sequence_number: z.number(),

package/esm/models/openresponsesimagegencallinprogress.d.ts

@@ -1,23 +1,16 @@
 import * as z from "zod/v4";
-import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const OpenResponsesImageGenCallInProgressType: {
-    readonly ResponseImageGenerationCallInProgress: "response.image_generation_call.in_progress";
-};
-export type OpenResponsesImageGenCallInProgressType = ClosedEnum<typeof OpenResponsesImageGenCallInProgressType>;
 /**
  * Image generation call in progress
  */
 export type OpenResponsesImageGenCallInProgress = {
-    type: OpenResponsesImageGenCallInProgressType;
+    type: "response.image_generation_call.in_progress";
     itemId: string;
     outputIndex: number;
     sequenceNumber: number;
 };
 /** @internal */
-export declare const OpenResponsesImageGenCallInProgressType$inboundSchema: z.ZodEnum<typeof OpenResponsesImageGenCallInProgressType>;
-/** @internal */
 export declare const OpenResponsesImageGenCallInProgress$inboundSchema: z.ZodType<OpenResponsesImageGenCallInProgress, unknown>;
 export declare function openResponsesImageGenCallInProgressFromJSON(jsonString: string): SafeParseResult<OpenResponsesImageGenCallInProgress, SDKValidationError>;
 //# sourceMappingURL=openresponsesimagegencallinprogress.d.ts.map

package/esm/models/openresponsesimagegencallinprogress.js

@@ -4,14 +4,9 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-export const OpenResponsesImageGenCallInProgressType = {
-    ResponseImageGenerationCallInProgress: "response.image_generation_call.in_progress",
-};
-/** @internal */
-export const OpenResponsesImageGenCallInProgressType$inboundSchema = z.enum(OpenResponsesImageGenCallInProgressType);
 /** @internal */
 export const OpenResponsesImageGenCallInProgress$inboundSchema = z.object({
-    type: OpenResponsesImageGenCallInProgressType$inboundSchema,
+    type: z.literal("response.image_generation_call.in_progress"),
     item_id: z.string(),
     output_index: z.number(),
     sequence_number: z.number(),

package/esm/models/openresponsesimagegencallpartialimage.d.ts

@@ -1,16 +1,11 @@
 import * as z from "zod/v4";
-import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const OpenResponsesImageGenCallPartialImageType: {
-    readonly ResponseImageGenerationCallPartialImage: "response.image_generation_call.partial_image";
-};
-export type OpenResponsesImageGenCallPartialImageType = ClosedEnum<typeof OpenResponsesImageGenCallPartialImageType>;
 /**
  * Image generation call with partial image
  */
 export type OpenResponsesImageGenCallPartialImage = {
-    type: OpenResponsesImageGenCallPartialImageType;
+    type: "response.image_generation_call.partial_image";
     itemId: string;
     outputIndex: number;
     sequenceNumber: number;
@@ -18,8 +13,6 @@ export type OpenResponsesImageGenCallPartialImage = {
     partialImageIndex: number;
 };
 /** @internal */
-export declare const OpenResponsesImageGenCallPartialImageType$inboundSchema: z.ZodEnum<typeof OpenResponsesImageGenCallPartialImageType>;
-/** @internal */
 export declare const OpenResponsesImageGenCallPartialImage$inboundSchema: z.ZodType<OpenResponsesImageGenCallPartialImage, unknown>;
 export declare function openResponsesImageGenCallPartialImageFromJSON(jsonString: string): SafeParseResult<OpenResponsesImageGenCallPartialImage, SDKValidationError>;
 //# sourceMappingURL=openresponsesimagegencallpartialimage.d.ts.map

package/esm/models/openresponsesimagegencallpartialimage.js

@@ -4,14 +4,9 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-export const OpenResponsesImageGenCallPartialImageType = {
-    ResponseImageGenerationCallPartialImage: "response.image_generation_call.partial_image",
-};
-/** @internal */
-export const OpenResponsesImageGenCallPartialImageType$inboundSchema = z.enum(OpenResponsesImageGenCallPartialImageType);
 /** @internal */
 export const OpenResponsesImageGenCallPartialImage$inboundSchema = z.object({
-    type: OpenResponsesImageGenCallPartialImageType$inboundSchema,
+    type: z.literal("response.image_generation_call.partial_image"),
     item_id: z.string(),
     output_index: z.number(),
     sequence_number: z.number(),

package/esm/models/openresponsesinputmessageitem.d.ts

@@ -21,28 +21,12 @@ export declare const OpenResponsesInputMessageItemRoleUser: {
 };
 export type OpenResponsesInputMessageItemRoleUser = ClosedEnum<typeof OpenResponsesInputMessageItemRoleUser>;
 export type OpenResponsesInputMessageItemRoleUnion = OpenResponsesInputMessageItemRoleUser | OpenResponsesInputMessageItemRoleSystem | OpenResponsesInputMessageItemRoleDeveloper;
-export type OpenResponsesInputMessageItemContent = (ResponseInputText & {
-    type: "input_text";
-}) | (ResponseInputImage & {
-    type: "input_image";
-}) | (ResponseInputAudio & {
-    type: "input_audio";
-}) | (ResponseInputFile & {
-    type: "input_file";
-});
+export type OpenResponsesInputMessageItemContent = ResponseInputText | ResponseInputImage | ResponseInputFile | ResponseInputAudio;
 export type OpenResponsesInputMessageItem = {
     id?: string | undefined;
     type?: OpenResponsesInputMessageItemType | undefined;
     role: OpenResponsesInputMessageItemRoleUser | OpenResponsesInputMessageItemRoleSystem | OpenResponsesInputMessageItemRoleDeveloper;
-    content: Array<(ResponseInputText & {
-        type: "input_text";
-    }) | (ResponseInputImage & {
-        type: "input_image";
-    }) | (ResponseInputAudio & {
-        type: "input_audio";
-    }) | (ResponseInputFile & {
-        type: "input_file";
-    })>;
+    content: Array<ResponseInputText | ResponseInputImage | ResponseInputFile | ResponseInputAudio>;
 };
 /** @internal */
 export declare const OpenResponsesInputMessageItemType$outboundSchema: z.ZodEnum<typeof OpenResponsesInputMessageItemType>;
@@ -58,15 +42,7 @@ export type OpenResponsesInputMessageItemRoleUnion$Outbound = string | string |
 export declare const OpenResponsesInputMessageItemRoleUnion$outboundSchema: z.ZodType<OpenResponsesInputMessageItemRoleUnion$Outbound, OpenResponsesInputMessageItemRoleUnion>;
 export declare function openResponsesInputMessageItemRoleUnionToJSON(openResponsesInputMessageItemRoleUnion: OpenResponsesInputMessageItemRoleUnion): string;
 /** @internal */
-export type OpenResponsesInputMessageItemContent$Outbound = (ResponseInputText$Outbound & {
-    type: "input_text";
-}) | (ResponseInputImage$Outbound & {
-    type: "input_image";
-}) | (ResponseInputAudio$Outbound & {
-    type: "input_audio";
-}) | (ResponseInputFile$Outbound & {
-    type: "input_file";
-});
+export type OpenResponsesInputMessageItemContent$Outbound = ResponseInputText$Outbound | ResponseInputImage$Outbound | ResponseInputFile$Outbound | ResponseInputAudio$Outbound;
 /** @internal */
 export declare const OpenResponsesInputMessageItemContent$outboundSchema: z.ZodType<OpenResponsesInputMessageItemContent$Outbound, OpenResponsesInputMessageItemContent>;
 export declare function openResponsesInputMessageItemContentToJSON(openResponsesInputMessageItemContent: OpenResponsesInputMessageItemContent): string;
@@ -75,15 +51,7 @@ export type OpenResponsesInputMessageItem$Outbound = {
     id?: string | undefined;
     type?: string | undefined;
     role: string | string | string;
-    content: Array<(ResponseInputText$Outbound & {
-        type: "input_text";
-    }) | (ResponseInputImage$Outbound & {
-        type: "input_image";
-    }) | (ResponseInputAudio$Outbound & {
-        type: "input_audio";
-    }) | (ResponseInputFile$Outbound & {
-        type: "input_file";
-    })>;
+    content: Array<ResponseInputText$Outbound | ResponseInputImage$Outbound | ResponseInputFile$Outbound | ResponseInputAudio$Outbound>;
 };
 /** @internal */
 export declare const OpenResponsesInputMessageItem$outboundSchema: z.ZodType<OpenResponsesInputMessageItem$Outbound, OpenResponsesInputMessageItem>;

package/esm/models/openresponsesinputmessageitem.js

@@ -37,10 +37,10 @@ export function openResponsesInputMessageItemRoleUnionToJSON(openResponsesInputM
 }
 /** @internal */
 export const OpenResponsesInputMessageItemContent$outboundSchema = z.union([
-    ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") })),
-    ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") })),
-    ResponseInputAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") })),
-    ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") })),
+    ResponseInputText$outboundSchema,
+    ResponseInputImage$outboundSchema,
+    ResponseInputFile$outboundSchema,
+    ResponseInputAudio$outboundSchema,
 ]);
 export function openResponsesInputMessageItemContentToJSON(openResponsesInputMessageItemContent) {
     return JSON.stringify(OpenResponsesInputMessageItemContent$outboundSchema.parse(openResponsesInputMessageItemContent));
@@ -55,10 +55,10 @@ export const OpenResponsesInputMessageItem$outboundSchema = z.object({
         OpenResponsesInputMessageItemRoleDeveloper$outboundSchema,
     ]),
     content: z.array(z.union([
-        ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") })),
-        ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") })),
-        ResponseInputAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") })),
-        ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") })),
+        ResponseInputText$outboundSchema,
+        ResponseInputImage$outboundSchema,
+        ResponseInputFile$outboundSchema,
+        ResponseInputAudio$outboundSchema,
     ])),
 });
 export function openResponsesInputMessageItemToJSON(openResponsesInputMessageItem) {

package/esm/models/openresponsesnonstreamingresponse.d.ts

@@ -22,15 +22,11 @@ export declare const ObjectT: {
     readonly Response: "response";
 };
 export type ObjectT = ClosedEnum<typeof ObjectT>;
-export declare const OpenResponsesNonStreamingResponseType: {
-    readonly Function: "function";
-};
-export type OpenResponsesNonStreamingResponseType = ClosedEnum<typeof OpenResponsesNonStreamingResponseType>;
 /**
  * Function tool definition
  */
 export type OpenResponsesNonStreamingResponseToolFunction = {
-    type: OpenResponsesNonStreamingResponseType;
+    type: "function";
     name: string;
     description?: string | null | undefined;
     strict?: boolean | null | undefined;
@@ -92,8 +88,6 @@ export type OpenResponsesNonStreamingResponse = {
 /** @internal */
 export declare const ObjectT$inboundSchema: z.ZodEnum<typeof ObjectT>;
 /** @internal */
-export declare const OpenResponsesNonStreamingResponseType$inboundSchema: z.ZodEnum<typeof OpenResponsesNonStreamingResponseType>;
-/** @internal */
 export declare const OpenResponsesNonStreamingResponseToolFunction$inboundSchema: z.ZodType<OpenResponsesNonStreamingResponseToolFunction, unknown>;
 export declare function openResponsesNonStreamingResponseToolFunctionFromJSON(jsonString: string): SafeParseResult<OpenResponsesNonStreamingResponseToolFunction, SDKValidationError>;
 /** @internal */

package/esm/models/openresponsesnonstreamingresponse.js

@@ -23,16 +23,11 @@ import { ResponseTextConfig$inboundSchema, } from "./responsetextconfig.js";
 export const ObjectT = {
     Response: "response",
 };
-export const OpenResponsesNonStreamingResponseType = {
-    Function: "function",
-};
 /** @internal */
 export const ObjectT$inboundSchema = z.enum(ObjectT);
 /** @internal */
-export const OpenResponsesNonStreamingResponseType$inboundSchema = z.enum(OpenResponsesNonStreamingResponseType);
-/** @internal */
 export const OpenResponsesNonStreamingResponseToolFunction$inboundSchema = z.object({
-    type: OpenResponsesNonStreamingResponseType$inboundSchema,
+    type: z.literal("function"),
     name: z.string(),
     description: z.nullable(z.string()).optional(),
     strict: z.nullable(z.boolean()).optional(),

package/esm/models/openresponsesreasoningdeltaevent.d.ts

@@ -1,16 +1,11 @@
 import * as z from "zod/v4";
-import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const OpenResponsesReasoningDeltaEventType: {
-    readonly ResponseReasoningTextDelta: "response.reasoning_text.delta";
-};
-export type OpenResponsesReasoningDeltaEventType = ClosedEnum<typeof OpenResponsesReasoningDeltaEventType>;
 /**
  * Event emitted when reasoning text delta is streamed
  */
 export type OpenResponsesReasoningDeltaEvent = {
-    type: OpenResponsesReasoningDeltaEventType;
+    type: "response.reasoning_text.delta";
     outputIndex: number;
     itemId: string;
     contentIndex: number;
@@ -18,8 +13,6 @@ export type OpenResponsesReasoningDeltaEvent = {
     sequenceNumber: number;
 };
 /** @internal */
-export declare const OpenResponsesReasoningDeltaEventType$inboundSchema: z.ZodEnum<typeof OpenResponsesReasoningDeltaEventType>;
-/** @internal */
 export declare const OpenResponsesReasoningDeltaEvent$inboundSchema: z.ZodType<OpenResponsesReasoningDeltaEvent, unknown>;
 export declare function openResponsesReasoningDeltaEventFromJSON(jsonString: string): SafeParseResult<OpenResponsesReasoningDeltaEvent, SDKValidationError>;
 //# sourceMappingURL=openresponsesreasoningdeltaevent.d.ts.map

package/esm/models/openresponsesreasoningdeltaevent.js

@@ -4,14 +4,9 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-export const OpenResponsesReasoningDeltaEventType = {
-    ResponseReasoningTextDelta: "response.reasoning_text.delta",
-};
-/** @internal */
-export const OpenResponsesReasoningDeltaEventType$inboundSchema = z.enum(OpenResponsesReasoningDeltaEventType);
 /** @internal */
 export const OpenResponsesReasoningDeltaEvent$inboundSchema = z.object({
-    type: OpenResponsesReasoningDeltaEventType$inboundSchema,
+    type: z.literal("response.reasoning_text.delta"),
     output_index: z.number(),
     item_id: z.string(),
     content_index: z.number(),

package/esm/models/openresponsesreasoningdoneevent.d.ts

@@ -1,16 +1,11 @@
 import * as z from "zod/v4";
-import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const OpenResponsesReasoningDoneEventType: {
-    readonly ResponseReasoningTextDone: "response.reasoning_text.done";
-};
-export type OpenResponsesReasoningDoneEventType = ClosedEnum<typeof OpenResponsesReasoningDoneEventType>;
 /**
  * Event emitted when reasoning text streaming is complete
  */
 export type OpenResponsesReasoningDoneEvent = {
-    type: OpenResponsesReasoningDoneEventType;
+    type: "response.reasoning_text.done";
     outputIndex: number;
     itemId: string;
     contentIndex: number;
@@ -18,8 +13,6 @@ export type OpenResponsesReasoningDoneEvent = {
     sequenceNumber: number;
 };
 /** @internal */
-export declare const OpenResponsesReasoningDoneEventType$inboundSchema: z.ZodEnum<typeof OpenResponsesReasoningDoneEventType>;
-/** @internal */
 export declare const OpenResponsesReasoningDoneEvent$inboundSchema: z.ZodType<OpenResponsesReasoningDoneEvent, unknown>;
 export declare function openResponsesReasoningDoneEventFromJSON(jsonString: string): SafeParseResult<OpenResponsesReasoningDoneEvent, SDKValidationError>;
 //# sourceMappingURL=openresponsesreasoningdoneevent.d.ts.map

package/esm/models/openresponsesreasoningdoneevent.js

@@ -4,14 +4,9 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-export const OpenResponsesReasoningDoneEventType = {
-    ResponseReasoningTextDone: "response.reasoning_text.done",
-};
-/** @internal */
-export const OpenResponsesReasoningDoneEventType$inboundSchema = z.enum(OpenResponsesReasoningDoneEventType);
 /** @internal */
 export const OpenResponsesReasoningDoneEvent$inboundSchema = z.object({
-    type: OpenResponsesReasoningDoneEventType$inboundSchema,
+    type: z.literal("response.reasoning_text.done"),
     output_index: z.number(),
     item_id: z.string(),
     content_index: z.number(),

package/esm/models/openresponsesreasoningsummarypartaddedevent.d.ts

@@ -1,17 +1,12 @@
 import * as z from "zod/v4";
-import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { ReasoningSummaryText } from "./reasoningsummarytext.js";
-export declare const OpenResponsesReasoningSummaryPartAddedEventType: {
-    readonly ResponseReasoningSummaryPartAdded: "response.reasoning_summary_part.added";
-};
-export type OpenResponsesReasoningSummaryPartAddedEventType = ClosedEnum<typeof OpenResponsesReasoningSummaryPartAddedEventType>;
 /**
  * Event emitted when a reasoning summary part is added
  */
 export type OpenResponsesReasoningSummaryPartAddedEvent = {
-    type: OpenResponsesReasoningSummaryPartAddedEventType;
+    type: "response.reasoning_summary_part.added";
     outputIndex: number;
     itemId: string;
     summaryIndex: number;
@@ -19,8 +14,6 @@ export type OpenResponsesReasoningSummaryPartAddedEvent = {
     sequenceNumber: number;
 };
 /** @internal */
-export declare const OpenResponsesReasoningSummaryPartAddedEventType$inboundSchema: z.ZodEnum<typeof OpenResponsesReasoningSummaryPartAddedEventType>;
-/** @internal */
 export declare const OpenResponsesReasoningSummaryPartAddedEvent$inboundSchema: z.ZodType<OpenResponsesReasoningSummaryPartAddedEvent, unknown>;
 export declare function openResponsesReasoningSummaryPartAddedEventFromJSON(jsonString: string): SafeParseResult<OpenResponsesReasoningSummaryPartAddedEvent, SDKValidationError>;
 //# sourceMappingURL=openresponsesreasoningsummarypartaddedevent.d.ts.map

package/esm/models/openresponsesreasoningsummarypartaddedevent.js

@@ -5,14 +5,9 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ReasoningSummaryText$inboundSchema, } from "./reasoningsummarytext.js";
-export const OpenResponsesReasoningSummaryPartAddedEventType = {
-    ResponseReasoningSummaryPartAdded: "response.reasoning_summary_part.added",
-};
-/** @internal */
-export const OpenResponsesReasoningSummaryPartAddedEventType$inboundSchema = z.enum(OpenResponsesReasoningSummaryPartAddedEventType);
 /** @internal */
 export const OpenResponsesReasoningSummaryPartAddedEvent$inboundSchema = z.object({
-    type: OpenResponsesReasoningSummaryPartAddedEventType$inboundSchema,
+    type: z.literal("response.reasoning_summary_part.added"),
     output_index: z.number(),
     item_id: z.string(),
     summary_index: z.number(),

package/esm/models/openresponsesreasoningsummarytextdeltaevent.d.ts

@@ -1,16 +1,11 @@
 import * as z from "zod/v4";
-import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const OpenResponsesReasoningSummaryTextDeltaEventType: {
-    readonly ResponseReasoningSummaryTextDelta: "response.reasoning_summary_text.delta";
-};
-export type OpenResponsesReasoningSummaryTextDeltaEventType = ClosedEnum<typeof OpenResponsesReasoningSummaryTextDeltaEventType>;
 /**
  * Event emitted when reasoning summary text delta is streamed
  */
 export type OpenResponsesReasoningSummaryTextDeltaEvent = {
-    type: OpenResponsesReasoningSummaryTextDeltaEventType;
+    type: "response.reasoning_summary_text.delta";
     itemId: string;
     outputIndex: number;
     summaryIndex: number;
@@ -18,8 +13,6 @@ export type OpenResponsesReasoningSummaryTextDeltaEvent = {
     sequenceNumber: number;
 };
 /** @internal */
-export declare const OpenResponsesReasoningSummaryTextDeltaEventType$inboundSchema: z.ZodEnum<typeof OpenResponsesReasoningSummaryTextDeltaEventType>;
-/** @internal */
 export declare const OpenResponsesReasoningSummaryTextDeltaEvent$inboundSchema: z.ZodType<OpenResponsesReasoningSummaryTextDeltaEvent, unknown>;
 export declare function openResponsesReasoningSummaryTextDeltaEventFromJSON(jsonString: string): SafeParseResult<OpenResponsesReasoningSummaryTextDeltaEvent, SDKValidationError>;
 //# sourceMappingURL=openresponsesreasoningsummarytextdeltaevent.d.ts.map

package/esm/models/openresponsesreasoningsummarytextdeltaevent.js

@@ -4,14 +4,9 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-export const OpenResponsesReasoningSummaryTextDeltaEventType = {
-    ResponseReasoningSummaryTextDelta: "response.reasoning_summary_text.delta",
-};
-/** @internal */
-export const OpenResponsesReasoningSummaryTextDeltaEventType$inboundSchema = z.enum(OpenResponsesReasoningSummaryTextDeltaEventType);
 /** @internal */
 export const OpenResponsesReasoningSummaryTextDeltaEvent$inboundSchema = z.object({
-    type: OpenResponsesReasoningSummaryTextDeltaEventType$inboundSchema,
+    type: z.literal("response.reasoning_summary_text.delta"),
     item_id: z.string(),
     output_index: z.number(),
     summary_index: z.number(),

package/esm/models/openresponsesreasoningsummarytextdoneevent.d.ts

@@ -1,16 +1,11 @@
 import * as z from "zod/v4";
-import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const OpenResponsesReasoningSummaryTextDoneEventType: {
-    readonly ResponseReasoningSummaryTextDone: "response.reasoning_summary_text.done";
-};
-export type OpenResponsesReasoningSummaryTextDoneEventType = ClosedEnum<typeof OpenResponsesReasoningSummaryTextDoneEventType>;
 /**
  * Event emitted when reasoning summary text streaming is complete
  */
 export type OpenResponsesReasoningSummaryTextDoneEvent = {
-    type: OpenResponsesReasoningSummaryTextDoneEventType;
+    type: "response.reasoning_summary_text.done";
     itemId: string;
     outputIndex: number;
     summaryIndex: number;
@@ -18,8 +13,6 @@ export type OpenResponsesReasoningSummaryTextDoneEvent = {
     sequenceNumber: number;
 };
 /** @internal */
-export declare const OpenResponsesReasoningSummaryTextDoneEventType$inboundSchema: z.ZodEnum<typeof OpenResponsesReasoningSummaryTextDoneEventType>;
-/** @internal */
 export declare const OpenResponsesReasoningSummaryTextDoneEvent$inboundSchema: z.ZodType<OpenResponsesReasoningSummaryTextDoneEvent, unknown>;
 export declare function openResponsesReasoningSummaryTextDoneEventFromJSON(jsonString: string): SafeParseResult<OpenResponsesReasoningSummaryTextDoneEvent, SDKValidationError>;
 //# sourceMappingURL=openresponsesreasoningsummarytextdoneevent.d.ts.map

package/esm/models/openresponsesreasoningsummarytextdoneevent.js

@@ -4,14 +4,9 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-export const OpenResponsesReasoningSummaryTextDoneEventType = {
-    ResponseReasoningSummaryTextDone: "response.reasoning_summary_text.done",
-};
-/** @internal */
-export const OpenResponsesReasoningSummaryTextDoneEventType$inboundSchema = z.enum(OpenResponsesReasoningSummaryTextDoneEventType);
 /** @internal */
 export const OpenResponsesReasoningSummaryTextDoneEvent$inboundSchema = z.object({
-    type: OpenResponsesReasoningSummaryTextDoneEventType$inboundSchema,
+    type: z.literal("response.reasoning_summary_text.done"),
     item_id: z.string(),
     output_index: z.number(),
     summary_index: z.number(),