@openrouter/sdk 0.0.0-beta.4 → 0.0.0-beta.41

package/src/models/chatmessagecontentitemaudio.ts

@@ -5,11 +5,15 @@
 import * as z from "zod";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { ClosedEnum } from "../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-export const Format = {
+export const ChatMessageContentItemAudioFormat = {
   Wav: "wav",
   Mp3: "mp3",
   Flac: "flac",
@@ -18,11 +22,13 @@ export const Format = {
   Pcm16: "pcm16",
   Pcm24: "pcm24",
 } as const;
-export type Format = ClosedEnum<typeof Format>;
+export type ChatMessageContentItemAudioFormat = OpenEnum<
+  typeof ChatMessageContentItemAudioFormat
+>;
 
 export type InputAudio = {
   data: string;
-  format: Format;
+  format: ChatMessageContentItemAudioFormat;
 };
 
 export type ChatMessageContentItemAudio = {
@@ -31,22 +37,36 @@ export type ChatMessageContentItemAudio = {
 };
 
 /** @internal */
-export const Format$inboundSchema: z.ZodNativeEnum<typeof Format> = z
-  .nativeEnum(Format);
+export const ChatMessageContentItemAudioFormat$inboundSchema: z.ZodType<
+  ChatMessageContentItemAudioFormat,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ChatMessageContentItemAudioFormat),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const Format$outboundSchema: z.ZodNativeEnum<typeof Format> =
-  Format$inboundSchema;
+export const ChatMessageContentItemAudioFormat$outboundSchema: z.ZodType<
+  ChatMessageContentItemAudioFormat,
+  z.ZodTypeDef,
+  ChatMessageContentItemAudioFormat
+> = z.union([
+  z.nativeEnum(ChatMessageContentItemAudioFormat),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace Format$ {
-  /** @deprecated use `Format$inboundSchema` instead. */
-  export const inboundSchema = Format$inboundSchema;
-  /** @deprecated use `Format$outboundSchema` instead. */
-  export const outboundSchema = Format$outboundSchema;
+export namespace ChatMessageContentItemAudioFormat$ {
+  /** @deprecated use `ChatMessageContentItemAudioFormat$inboundSchema` instead. */
+  export const inboundSchema = ChatMessageContentItemAudioFormat$inboundSchema;
+  /** @deprecated use `ChatMessageContentItemAudioFormat$outboundSchema` instead. */
+  export const outboundSchema =
+    ChatMessageContentItemAudioFormat$outboundSchema;
 }
 
 /** @internal */
@@ -56,7 +76,7 @@ export const InputAudio$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   data: z.string(),
-  format: Format$inboundSchema,
+  format: ChatMessageContentItemAudioFormat$inboundSchema,
 });
 
 /** @internal */
@@ -72,7 +92,7 @@ export const InputAudio$outboundSchema: z.ZodType<
   InputAudio
 > = z.object({
   data: z.string(),
-  format: Format$outboundSchema,
+  format: ChatMessageContentItemAudioFormat$outboundSchema,
 });
 
 /**

package/src/models/chatmessagecontentitemimage.ts

@@ -5,20 +5,26 @@
 import * as z from "zod";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { ClosedEnum } from "../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-export const Detail = {
+export const ChatMessageContentItemImageDetail = {
   Auto: "auto",
   Low: "low",
   High: "high",
 } as const;
-export type Detail = ClosedEnum<typeof Detail>;
+export type ChatMessageContentItemImageDetail = OpenEnum<
+  typeof ChatMessageContentItemImageDetail
+>;
 
 export type ImageUrl = {
   url: string;
-  detail?: Detail | undefined;
+  detail?: ChatMessageContentItemImageDetail | undefined;
 };
 
 export type ChatMessageContentItemImage = {
@@ -27,22 +33,36 @@ export type ChatMessageContentItemImage = {
 };
 
 /** @internal */
-export const Detail$inboundSchema: z.ZodNativeEnum<typeof Detail> = z
-  .nativeEnum(Detail);
+export const ChatMessageContentItemImageDetail$inboundSchema: z.ZodType<
+  ChatMessageContentItemImageDetail,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ChatMessageContentItemImageDetail),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const Detail$outboundSchema: z.ZodNativeEnum<typeof Detail> =
-  Detail$inboundSchema;
+export const ChatMessageContentItemImageDetail$outboundSchema: z.ZodType<
+  ChatMessageContentItemImageDetail,
+  z.ZodTypeDef,
+  ChatMessageContentItemImageDetail
+> = z.union([
+  z.nativeEnum(ChatMessageContentItemImageDetail),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace Detail$ {
-  /** @deprecated use `Detail$inboundSchema` instead. */
-  export const inboundSchema = Detail$inboundSchema;
-  /** @deprecated use `Detail$outboundSchema` instead. */
-  export const outboundSchema = Detail$outboundSchema;
+export namespace ChatMessageContentItemImageDetail$ {
+  /** @deprecated use `ChatMessageContentItemImageDetail$inboundSchema` instead. */
+  export const inboundSchema = ChatMessageContentItemImageDetail$inboundSchema;
+  /** @deprecated use `ChatMessageContentItemImageDetail$outboundSchema` instead. */
+  export const outboundSchema =
+    ChatMessageContentItemImageDetail$outboundSchema;
 }
 
 /** @internal */
@@ -52,7 +72,7 @@ export const ImageUrl$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   url: z.string(),
-  detail: Detail$inboundSchema.optional(),
+  detail: ChatMessageContentItemImageDetail$inboundSchema.optional(),
 });
 
 /** @internal */
@@ -68,7 +88,7 @@ export const ImageUrl$outboundSchema: z.ZodType<
   ImageUrl
 > = z.object({
   url: z.string(),
-  detail: Detail$outboundSchema.optional(),
+  detail: ChatMessageContentItemImageDetail$outboundSchema.optional(),
 });
 
 /**

package/src/models/chatmessagetokenlogprob.ts

@@ -8,7 +8,7 @@ import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-export type TopLogprob = {
+export type ChatMessageTokenLogprobTopLogprob = {
   token: string;
   logprob: number;
   bytes: Array<number> | null;
@@ -18,12 +18,12 @@ export type ChatMessageTokenLogprob = {
   token: string;
   logprob: number;
   bytes: Array<number> | null;
-  topLogprobs: Array<TopLogprob>;
+  topLogprobs: Array<ChatMessageTokenLogprobTopLogprob>;
 };
 
 /** @internal */
-export const TopLogprob$inboundSchema: z.ZodType<
-  TopLogprob,
+export const ChatMessageTokenLogprobTopLogprob$inboundSchema: z.ZodType<
+  ChatMessageTokenLogprobTopLogprob,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -33,17 +33,17 @@ export const TopLogprob$inboundSchema: z.ZodType<
 });
 
 /** @internal */
-export type TopLogprob$Outbound = {
+export type ChatMessageTokenLogprobTopLogprob$Outbound = {
   token: string;
   logprob: number;
   bytes: Array<number> | null;
 };
 
 /** @internal */
-export const TopLogprob$outboundSchema: z.ZodType<
-  TopLogprob$Outbound,
+export const ChatMessageTokenLogprobTopLogprob$outboundSchema: z.ZodType<
+  ChatMessageTokenLogprobTopLogprob$Outbound,
   z.ZodTypeDef,
-  TopLogprob
+  ChatMessageTokenLogprobTopLogprob
 > = z.object({
   token: z.string(),
   logprob: z.number(),
@@ -54,26 +54,33 @@ export const TopLogprob$outboundSchema: z.ZodType<
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace TopLogprob$ {
-  /** @deprecated use `TopLogprob$inboundSchema` instead. */
-  export const inboundSchema = TopLogprob$inboundSchema;
-  /** @deprecated use `TopLogprob$outboundSchema` instead. */
-  export const outboundSchema = TopLogprob$outboundSchema;
-  /** @deprecated use `TopLogprob$Outbound` instead. */
-  export type Outbound = TopLogprob$Outbound;
+export namespace ChatMessageTokenLogprobTopLogprob$ {
+  /** @deprecated use `ChatMessageTokenLogprobTopLogprob$inboundSchema` instead. */
+  export const inboundSchema = ChatMessageTokenLogprobTopLogprob$inboundSchema;
+  /** @deprecated use `ChatMessageTokenLogprobTopLogprob$outboundSchema` instead. */
+  export const outboundSchema =
+    ChatMessageTokenLogprobTopLogprob$outboundSchema;
+  /** @deprecated use `ChatMessageTokenLogprobTopLogprob$Outbound` instead. */
+  export type Outbound = ChatMessageTokenLogprobTopLogprob$Outbound;
 }
 
-export function topLogprobToJSON(topLogprob: TopLogprob): string {
-  return JSON.stringify(TopLogprob$outboundSchema.parse(topLogprob));
+export function chatMessageTokenLogprobTopLogprobToJSON(
+  chatMessageTokenLogprobTopLogprob: ChatMessageTokenLogprobTopLogprob,
+): string {
+  return JSON.stringify(
+    ChatMessageTokenLogprobTopLogprob$outboundSchema.parse(
+      chatMessageTokenLogprobTopLogprob,
+    ),
+  );
 }
 
-export function topLogprobFromJSON(
+export function chatMessageTokenLogprobTopLogprobFromJSON(
   jsonString: string,
-): SafeParseResult<TopLogprob, SDKValidationError> {
+): SafeParseResult<ChatMessageTokenLogprobTopLogprob, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => TopLogprob$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'TopLogprob' from JSON`,
+    (x) => ChatMessageTokenLogprobTopLogprob$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChatMessageTokenLogprobTopLogprob' from JSON`,
   );
 }
 
@@ -86,7 +93,9 @@ export const ChatMessageTokenLogprob$inboundSchema: z.ZodType<
   token: z.string(),
   logprob: z.number(),
   bytes: z.nullable(z.array(z.number())),
-  top_logprobs: z.array(z.lazy(() => TopLogprob$inboundSchema)),
+  top_logprobs: z.array(
+    z.lazy(() => ChatMessageTokenLogprobTopLogprob$inboundSchema),
+  ),
 }).transform((v) => {
   return remap$(v, {
     "top_logprobs": "topLogprobs",
@@ -98,7 +107,7 @@ export type ChatMessageTokenLogprob$Outbound = {
   token: string;
   logprob: number;
   bytes: Array<number> | null;
-  top_logprobs: Array<TopLogprob$Outbound>;
+  top_logprobs: Array<ChatMessageTokenLogprobTopLogprob$Outbound>;
 };
 
 /** @internal */
@@ -110,7 +119,9 @@ export const ChatMessageTokenLogprob$outboundSchema: z.ZodType<
   token: z.string(),
   logprob: z.number(),
   bytes: z.nullable(z.array(z.number())),
-  topLogprobs: z.array(z.lazy(() => TopLogprob$outboundSchema)),
+  topLogprobs: z.array(
+    z.lazy(() => ChatMessageTokenLogprobTopLogprob$outboundSchema),
+  ),
 }).transform((v) => {
   return remap$(v, {
     topLogprobs: "top_logprobs",

package/src/models/chatresponsechoice.ts

@@ -5,7 +5,6 @@
 import * as z from "zod";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import {
   AssistantMessage,
@@ -13,6 +12,11 @@ import {
   AssistantMessage$Outbound,
   AssistantMessage$outboundSchema,
 } from "./assistantmessage.js";
+import {
+  ChatCompletionFinishReason,
+  ChatCompletionFinishReason$inboundSchema,
+  ChatCompletionFinishReason$outboundSchema,
+} from "./chatcompletionfinishreason.js";
 import {
   ChatMessageTokenLogprobs,
   ChatMessageTokenLogprobs$inboundSchema,
@@ -21,52 +25,20 @@ import {
 } from "./chatmessagetokenlogprobs.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-export const ChatResponseChoiceFinishReason = {
-  ToolCalls: "tool_calls",
-  Stop: "stop",
-  Length: "length",
-  ContentFilter: "content_filter",
-  Error: "error",
-} as const;
-export type ChatResponseChoiceFinishReason = ClosedEnum<
-  typeof ChatResponseChoiceFinishReason
->;
-
 export type ChatResponseChoice = {
-  finishReason: ChatResponseChoiceFinishReason | null;
+  finishReason: ChatCompletionFinishReason | null;
   index: number;
   message: AssistantMessage;
   logprobs?: ChatMessageTokenLogprobs | null | undefined;
 };
 
-/** @internal */
-export const ChatResponseChoiceFinishReason$inboundSchema: z.ZodNativeEnum<
-  typeof ChatResponseChoiceFinishReason
-> = z.nativeEnum(ChatResponseChoiceFinishReason);
-
-/** @internal */
-export const ChatResponseChoiceFinishReason$outboundSchema: z.ZodNativeEnum<
-  typeof ChatResponseChoiceFinishReason
-> = ChatResponseChoiceFinishReason$inboundSchema;
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace ChatResponseChoiceFinishReason$ {
-  /** @deprecated use `ChatResponseChoiceFinishReason$inboundSchema` instead. */
-  export const inboundSchema = ChatResponseChoiceFinishReason$inboundSchema;
-  /** @deprecated use `ChatResponseChoiceFinishReason$outboundSchema` instead. */
-  export const outboundSchema = ChatResponseChoiceFinishReason$outboundSchema;
-}
-
 /** @internal */
 export const ChatResponseChoice$inboundSchema: z.ZodType<
   ChatResponseChoice,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  finish_reason: z.nullable(ChatResponseChoiceFinishReason$inboundSchema),
+  finish_reason: z.nullable(ChatCompletionFinishReason$inboundSchema),
   index: z.number(),
   message: AssistantMessage$inboundSchema,
   logprobs: z.nullable(ChatMessageTokenLogprobs$inboundSchema).optional(),
@@ -90,7 +62,7 @@ export const ChatResponseChoice$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ChatResponseChoice
 > = z.object({
-  finishReason: z.nullable(ChatResponseChoiceFinishReason$outboundSchema),
+  finishReason: z.nullable(ChatCompletionFinishReason$outboundSchema),
   index: z.number(),
   message: AssistantMessage$outboundSchema,
   logprobs: z.nullable(ChatMessageTokenLogprobs$outboundSchema).optional(),

package/src/models/chatstreamingchoice.ts

@@ -5,8 +5,12 @@
 import * as z from "zod";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
+import {
+  ChatCompletionFinishReason,
+  ChatCompletionFinishReason$inboundSchema,
+  ChatCompletionFinishReason$outboundSchema,
+} from "./chatcompletionfinishreason.js";
 import {
   ChatMessageTokenLogprobs,
   ChatMessageTokenLogprobs$inboundSchema,
@@ -21,45 +25,13 @@ import {
 } from "./chatstreamingmessagechunk.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-export const ChatStreamingChoiceFinishReason = {
-  ToolCalls: "tool_calls",
-  Stop: "stop",
-  Length: "length",
-  ContentFilter: "content_filter",
-  Error: "error",
-} as const;
-export type ChatStreamingChoiceFinishReason = ClosedEnum<
-  typeof ChatStreamingChoiceFinishReason
->;
-
 export type ChatStreamingChoice = {
   delta: ChatStreamingMessageChunk;
-  finishReason: ChatStreamingChoiceFinishReason | null;
+  finishReason: ChatCompletionFinishReason | null;
   index: number;
   logprobs?: ChatMessageTokenLogprobs | null | undefined;
 };
 
-/** @internal */
-export const ChatStreamingChoiceFinishReason$inboundSchema: z.ZodNativeEnum<
-  typeof ChatStreamingChoiceFinishReason
-> = z.nativeEnum(ChatStreamingChoiceFinishReason);
-
-/** @internal */
-export const ChatStreamingChoiceFinishReason$outboundSchema: z.ZodNativeEnum<
-  typeof ChatStreamingChoiceFinishReason
-> = ChatStreamingChoiceFinishReason$inboundSchema;
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace ChatStreamingChoiceFinishReason$ {
-  /** @deprecated use `ChatStreamingChoiceFinishReason$inboundSchema` instead. */
-  export const inboundSchema = ChatStreamingChoiceFinishReason$inboundSchema;
-  /** @deprecated use `ChatStreamingChoiceFinishReason$outboundSchema` instead. */
-  export const outboundSchema = ChatStreamingChoiceFinishReason$outboundSchema;
-}
-
 /** @internal */
 export const ChatStreamingChoice$inboundSchema: z.ZodType<
   ChatStreamingChoice,
@@ -67,7 +39,7 @@ export const ChatStreamingChoice$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   delta: ChatStreamingMessageChunk$inboundSchema,
-  finish_reason: z.nullable(ChatStreamingChoiceFinishReason$inboundSchema),
+  finish_reason: z.nullable(ChatCompletionFinishReason$inboundSchema),
   index: z.number(),
   logprobs: z.nullable(ChatMessageTokenLogprobs$inboundSchema).optional(),
 }).transform((v) => {
@@ -91,7 +63,7 @@ export const ChatStreamingChoice$outboundSchema: z.ZodType<
   ChatStreamingChoice
 > = z.object({
   delta: ChatStreamingMessageChunk$outboundSchema,
-  finishReason: z.nullable(ChatStreamingChoiceFinishReason$outboundSchema),
+  finishReason: z.nullable(ChatCompletionFinishReason$outboundSchema),
   index: z.number(),
   logprobs: z.nullable(ChatMessageTokenLogprobs$outboundSchema).optional(),
 }).transform((v) => {

package/src/models/chatstreamingmessagechunk.ts

@@ -15,13 +15,15 @@ import {
 } from "./chatstreamingmessagetoolcall.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-export const Role = {
+export const ChatStreamingMessageChunkRole = {
   Assistant: "assistant",
 } as const;
-export type Role = ClosedEnum<typeof Role>;
+export type ChatStreamingMessageChunkRole = ClosedEnum<
+  typeof ChatStreamingMessageChunkRole
+>;
 
 export type ChatStreamingMessageChunk = {
-  role?: Role | undefined;
+  role?: ChatStreamingMessageChunkRole | undefined;
   content?: string | null | undefined;
   reasoning?: string | null | undefined;
   refusal?: string | null | undefined;
@@ -29,23 +31,24 @@ export type ChatStreamingMessageChunk = {
 };
 
 /** @internal */
-export const Role$inboundSchema: z.ZodNativeEnum<typeof Role> = z.nativeEnum(
-  Role,
-);
+export const ChatStreamingMessageChunkRole$inboundSchema: z.ZodNativeEnum<
+  typeof ChatStreamingMessageChunkRole
+> = z.nativeEnum(ChatStreamingMessageChunkRole);
 
 /** @internal */
-export const Role$outboundSchema: z.ZodNativeEnum<typeof Role> =
-  Role$inboundSchema;
+export const ChatStreamingMessageChunkRole$outboundSchema: z.ZodNativeEnum<
+  typeof ChatStreamingMessageChunkRole
+> = ChatStreamingMessageChunkRole$inboundSchema;
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace Role$ {
-  /** @deprecated use `Role$inboundSchema` instead. */
-  export const inboundSchema = Role$inboundSchema;
-  /** @deprecated use `Role$outboundSchema` instead. */
-  export const outboundSchema = Role$outboundSchema;
+export namespace ChatStreamingMessageChunkRole$ {
+  /** @deprecated use `ChatStreamingMessageChunkRole$inboundSchema` instead. */
+  export const inboundSchema = ChatStreamingMessageChunkRole$inboundSchema;
+  /** @deprecated use `ChatStreamingMessageChunkRole$outboundSchema` instead. */
+  export const outboundSchema = ChatStreamingMessageChunkRole$outboundSchema;
 }
 
 /** @internal */
@@ -54,7 +57,7 @@ export const ChatStreamingMessageChunk$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  role: Role$inboundSchema.optional(),
+  role: ChatStreamingMessageChunkRole$inboundSchema.optional(),
   content: z.nullable(z.string()).optional(),
   reasoning: z.nullable(z.string()).optional(),
   refusal: z.nullable(z.string()).optional(),
@@ -80,7 +83,7 @@ export const ChatStreamingMessageChunk$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ChatStreamingMessageChunk
 > = z.object({
-  role: Role$outboundSchema.optional(),
+  role: ChatStreamingMessageChunkRole$outboundSchema.optional(),
   content: z.nullable(z.string()).optional(),
   reasoning: z.nullable(z.string()).optional(),
   refusal: z.nullable(z.string()).optional(),

package/src/models/completionchoice.ts

@@ -0,0 +1,98 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import {
+  CompletionFinishReason,
+  CompletionFinishReason$inboundSchema,
+  CompletionFinishReason$outboundSchema,
+} from "./completionfinishreason.js";
+import {
+  CompletionLogprobs,
+  CompletionLogprobs$inboundSchema,
+  CompletionLogprobs$Outbound,
+  CompletionLogprobs$outboundSchema,
+} from "./completionlogprobs.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type CompletionChoice = {
+  text: string;
+  index: number;
+  logprobs: CompletionLogprobs | null;
+  finishReason: CompletionFinishReason | null;
+};
+
+/** @internal */
+export const CompletionChoice$inboundSchema: z.ZodType<
+  CompletionChoice,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  text: z.string(),
+  index: z.number(),
+  logprobs: z.nullable(CompletionLogprobs$inboundSchema),
+  finish_reason: z.nullable(CompletionFinishReason$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "finish_reason": "finishReason",
+  });
+});
+
+/** @internal */
+export type CompletionChoice$Outbound = {
+  text: string;
+  index: number;
+  logprobs: CompletionLogprobs$Outbound | null;
+  finish_reason: string | null;
+};
+
+/** @internal */
+export const CompletionChoice$outboundSchema: z.ZodType<
+  CompletionChoice$Outbound,
+  z.ZodTypeDef,
+  CompletionChoice
+> = z.object({
+  text: z.string(),
+  index: z.number(),
+  logprobs: z.nullable(CompletionLogprobs$outboundSchema),
+  finishReason: z.nullable(CompletionFinishReason$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    finishReason: "finish_reason",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace CompletionChoice$ {
+  /** @deprecated use `CompletionChoice$inboundSchema` instead. */
+  export const inboundSchema = CompletionChoice$inboundSchema;
+  /** @deprecated use `CompletionChoice$outboundSchema` instead. */
+  export const outboundSchema = CompletionChoice$outboundSchema;
+  /** @deprecated use `CompletionChoice$Outbound` instead. */
+  export type Outbound = CompletionChoice$Outbound;
+}
+
+export function completionChoiceToJSON(
+  completionChoice: CompletionChoice,
+): string {
+  return JSON.stringify(
+    CompletionChoice$outboundSchema.parse(completionChoice),
+  );
+}
+
+export function completionChoiceFromJSON(
+  jsonString: string,
+): SafeParseResult<CompletionChoice, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CompletionChoice$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CompletionChoice' from JSON`,
+  );
+}