/*
 * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
 */

import * as z from "zod/v3";
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 { SDKValidationError } from "../errors/sdkvalidationerror.js";
import {
  OpenAIChatCompletionUsage,
  OpenAIChatCompletionUsage$inboundSchema,
  OpenAIChatCompletionUsage$Outbound,
  OpenAIChatCompletionUsage$outboundSchema,
} from "./openaichatcompletionusage.js";

export type OpenAIChatCompletionChunkFile2 = {
  /**
   * The unique identifier of a previously uploaded file
   */
  fileId: string;
  /**
   * Optional filename override
   */
  filename?: string | undefined;
};

export type OpenAIChatCompletionChunkFile1 = {
  /**
   * The name of the file
   */
  filename: string;
  /**
   * Base64-encoded file data
   */
  fileData: string;
};

/**
 * The file to include in the message, either as raw data or by reference
 */
export type OpenAIChatCompletionChunk2File =
  | OpenAIChatCompletionChunkFile1
  | OpenAIChatCompletionChunkFile2;

export type OpenAIChatCompletionChunk24 = {
  /**
   * Content type identifier for file content
   */
  type: "file";
  /**
   * The file to include in the message, either as raw data or by reference
   */
  file: OpenAIChatCompletionChunkFile1 | OpenAIChatCompletionChunkFile2;
};

/**
 * The format of the encoded audio data
 */
export const OpenAIChatCompletionChunk2Format = {
  Wav: "wav",
  Mp3: "mp3",
} as const;
/**
 * The format of the encoded audio data
 */
export type OpenAIChatCompletionChunk2Format = ClosedEnum<
  typeof OpenAIChatCompletionChunk2Format
>;

export type OpenAIChatCompletionChunk2InputAudio = {
  /**
   * Base64-encoded audio data
   */
  data: string;
  /**
   * The format of the encoded audio data
   */
  format: OpenAIChatCompletionChunk2Format;
};

export type OpenAIChatCompletionChunk23 = {
  /**
   * Content type identifier for audio input content
   */
  type: "input_audio";
  inputAudio: OpenAIChatCompletionChunk2InputAudio;
};

/**
 * The detail level of the image analysis. 'low' disables high-res mode, 'high' enables it, 'auto' lets the model decide.
 */
export const OpenAIChatCompletionChunk2Detail = {
  Auto: "auto",
  Low: "low",
  High: "high",
} as const;
/**
 * The detail level of the image analysis. 'low' disables high-res mode, 'high' enables it, 'auto' lets the model decide.
 */
export type OpenAIChatCompletionChunk2Detail = ClosedEnum<
  typeof OpenAIChatCompletionChunk2Detail
>;

export type OpenAIChatCompletionChunk2ImageUrl = {
  /**
   * The URL of the image, or a base64-encoded image data URL
   */
  url: string;
  /**
   * The detail level of the image analysis. 'low' disables high-res mode, 'high' enables it, 'auto' lets the model decide.
   */
  detail?: OpenAIChatCompletionChunk2Detail | undefined;
};

export type OpenAIChatCompletionChunk22 = {
  /**
   * Content type identifier for image URL content
   */
  type: "image_url";
  imageUrl: OpenAIChatCompletionChunk2ImageUrl;
};

export type OpenAIChatCompletionChunk21 = {
  /**
   * Content type identifier for text content
   */
  type: "text";
  /**
   * The text content to include in the message
   */
  text: string;
};

/**
 * A content part that can be included in a message. Supports text, images, audio, and files.
 */
export type OpenAIChatCompletionChunkContent2 =
  | OpenAIChatCompletionChunk21
  | OpenAIChatCompletionChunk22
  | OpenAIChatCompletionChunk23
  | OpenAIChatCompletionChunk24;

/**
 * The content of the chunk. May be a string, content parts, or null.
 */
export type OpenAIChatCompletionChunkContent =
  | string
  | Array<
    | OpenAIChatCompletionChunk21
    | OpenAIChatCompletionChunk22
    | OpenAIChatCompletionChunk23
    | OpenAIChatCompletionChunk24
  >;

/**
 * The function that the model called
 */
export type OpenAIChatCompletionChunkFunction = {
  /**
   * The name of the function called
   */
  name?: string | undefined;
  /**
   * The arguments passed to the function, as a JSON string
   */
  arguments?: string | undefined;
};

/**
 * A partial tool call delta in a streaming chunk
 */
export type OpenAIChatCompletionChunkToolCalls = {
  /**
   * The ID of the tool call
   */
  id?: string | undefined;
  /**
   * The type of the tool. Currently only 'function' is supported.
   */
  type?: "function" | undefined;
  /**
   * The function that the model called
   */
  function?: OpenAIChatCompletionChunkFunction | undefined;
  /**
   * The index of the tool call in the list of tool calls
   */
  index: number;
};

/**
 * The delta content for this chunk
 */
export type Delta = {
  /**
   * The role of the author of this message
   */
  role?: "assistant" | undefined;
  /**
   * The content of the chunk. May be a string, content parts, or null.
   */
  content?:
    | string
    | Array<
      | OpenAIChatCompletionChunk21
      | OpenAIChatCompletionChunk22
      | OpenAIChatCompletionChunk23
      | OpenAIChatCompletionChunk24
    >
    | null
    | undefined;
  /**
   * The reasoning content delta generated by the model. Present for models that support chain-of-thought reasoning.
   */
  reasoning?: string | null | undefined;
  /**
   * The tool call deltas generated by the model
   */
  toolCalls?: Array<OpenAIChatCompletionChunkToolCalls> | undefined;
};

/**
 * The reason why the model stopped generating tokens.
 */
export const FinishReason1 = {
  Stop: "stop",
  Length: "length",
  ToolCalls: "tool_calls",
  ContentFilter: "content_filter",
} as const;
/**
 * The reason why the model stopped generating tokens.
 */
export type FinishReason1 = ClosedEnum<typeof FinishReason1>;

/**
 * The reason the model stopped generating tokens. Only present in the final chunk. 'stop' means natural stop point, 'length' means max_tokens limit reached, 'tool_calls' means the model called a tool, 'content_filter' means content was filtered.
 */
export type OpenAIChatCompletionChunkFinishReason = FinishReason1 | string;

/**
 * Log probability information for the choice
 */
export type OpenAIChatCompletionChunkLogprobs = {
  /**
   * The list of tokens
   */
  tokens: Array<string>;
  /**
   * The log probability of each token
   */
  tokenLogprobs: Array<number>;
  /**
   * The top log probabilities for each token position
   */
  topLogprobs: Array<{ [k: string]: number }>;
  /**
   * The character offset from the beginning of the returned text for each token
   */
  textOffset: Array<number>;
};

/**
 * A chat completion choice in a streaming chunk
 */
export type Choices = {
  /**
   * The index of this choice in the list of choices
   */
  index: number;
  /**
   * The delta content for this chunk
   */
  delta: Delta;
  /**
   * The reason the model stopped generating tokens. Only present in the final chunk. 'stop' means natural stop point, 'length' means max_tokens limit reached, 'tool_calls' means the model called a tool, 'content_filter' means content was filtered.
   */
  finishReason: FinishReason1 | string | null;
  /**
   * Log probability information for the choice
   */
  logprobs?: OpenAIChatCompletionChunkLogprobs | null | undefined;
};

/**
 * Represents a streamed chunk of a chat completion response
 */
export type OpenAIChatCompletionChunk = {
  /**
   * A unique identifier for the chat completion
   */
  id: string;
  /**
   * The object type, always 'chat.completion.chunk'
   */
  object: "chat.completion.chunk";
  /**
   * The Unix timestamp (in seconds) of when the chat completion was created
   */
  created: number;
  /**
   * The model used for the chat completion
   */
  model: string;
  /**
   * A list of chat completion choices in this chunk
   */
  choices: Array<Choices>;
  /**
   * Usage statistics for the completion request
   */
  usage?: OpenAIChatCompletionUsage | undefined;
  /**
   * This fingerprint represents the backend configuration that the model runs with
   */
  systemFingerprint?: string | undefined;
};

/** @internal */
export const OpenAIChatCompletionChunkFile2$inboundSchema: z.ZodType<
  OpenAIChatCompletionChunkFile2,
  z.ZodTypeDef,
  unknown
> = z.object({
  file_id: z.string(),
  filename: z.string().optional(),
}).transform((v) => {
  return remap$(v, {
    "file_id": "fileId",
  });
});
/** @internal */
export type OpenAIChatCompletionChunkFile2$Outbound = {
  file_id: string;
  filename?: string | undefined;
};

/** @internal */
export const OpenAIChatCompletionChunkFile2$outboundSchema: z.ZodType<
  OpenAIChatCompletionChunkFile2$Outbound,
  z.ZodTypeDef,
  OpenAIChatCompletionChunkFile2
> = z.object({
  fileId: z.string(),
  filename: z.string().optional(),
}).transform((v) => {
  return remap$(v, {
    fileId: "file_id",
  });
});

export function openAIChatCompletionChunkFile2ToJSON(
  openAIChatCompletionChunkFile2: OpenAIChatCompletionChunkFile2,
): string {
  return JSON.stringify(
    OpenAIChatCompletionChunkFile2$outboundSchema.parse(
      openAIChatCompletionChunkFile2,
    ),
  );
}
export function openAIChatCompletionChunkFile2FromJSON(
  jsonString: string,
): SafeParseResult<OpenAIChatCompletionChunkFile2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => OpenAIChatCompletionChunkFile2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OpenAIChatCompletionChunkFile2' from JSON`,
  );
}

/** @internal */
export const OpenAIChatCompletionChunkFile1$inboundSchema: z.ZodType<
  OpenAIChatCompletionChunkFile1,
  z.ZodTypeDef,
  unknown
> = z.object({
  filename: z.string(),
  file_data: z.string(),
}).transform((v) => {
  return remap$(v, {
    "file_data": "fileData",
  });
});
/** @internal */
export type OpenAIChatCompletionChunkFile1$Outbound = {
  filename: string;
  file_data: string;
};

/** @internal */
export const OpenAIChatCompletionChunkFile1$outboundSchema: z.ZodType<
  OpenAIChatCompletionChunkFile1$Outbound,
  z.ZodTypeDef,
  OpenAIChatCompletionChunkFile1
> = z.object({
  filename: z.string(),
  fileData: z.string(),
}).transform((v) => {
  return remap$(v, {
    fileData: "file_data",
  });
});

export function openAIChatCompletionChunkFile1ToJSON(
  openAIChatCompletionChunkFile1: OpenAIChatCompletionChunkFile1,
): string {
  return JSON.stringify(
    OpenAIChatCompletionChunkFile1$outboundSchema.parse(
      openAIChatCompletionChunkFile1,
    ),
  );
}
export function openAIChatCompletionChunkFile1FromJSON(
  jsonString: string,
): SafeParseResult<OpenAIChatCompletionChunkFile1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => OpenAIChatCompletionChunkFile1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OpenAIChatCompletionChunkFile1' from JSON`,
  );
}

/** @internal */
export const OpenAIChatCompletionChunk2File$inboundSchema: z.ZodType<
  OpenAIChatCompletionChunk2File,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => OpenAIChatCompletionChunkFile1$inboundSchema),
  z.lazy(() => OpenAIChatCompletionChunkFile2$inboundSchema),
]);
/** @internal */
export type OpenAIChatCompletionChunk2File$Outbound =
  | OpenAIChatCompletionChunkFile1$Outbound
  | OpenAIChatCompletionChunkFile2$Outbound;

/** @internal */
export const OpenAIChatCompletionChunk2File$outboundSchema: z.ZodType<
  OpenAIChatCompletionChunk2File$Outbound,
  z.ZodTypeDef,
  OpenAIChatCompletionChunk2File
> = z.union([
  z.lazy(() => OpenAIChatCompletionChunkFile1$outboundSchema),
  z.lazy(() => OpenAIChatCompletionChunkFile2$outboundSchema),
]);

export function openAIChatCompletionChunk2FileToJSON(
  openAIChatCompletionChunk2File: OpenAIChatCompletionChunk2File,
): string {
  return JSON.stringify(
    OpenAIChatCompletionChunk2File$outboundSchema.parse(
      openAIChatCompletionChunk2File,
    ),
  );
}
export function openAIChatCompletionChunk2FileFromJSON(
  jsonString: string,
): SafeParseResult<OpenAIChatCompletionChunk2File, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => OpenAIChatCompletionChunk2File$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OpenAIChatCompletionChunk2File' from JSON`,
  );
}

/** @internal */
export const OpenAIChatCompletionChunk24$inboundSchema: z.ZodType<
  OpenAIChatCompletionChunk24,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("file"),
  file: z.union([
    z.lazy(() => OpenAIChatCompletionChunkFile1$inboundSchema),
    z.lazy(() => OpenAIChatCompletionChunkFile2$inboundSchema),
  ]),
});
/** @internal */
export type OpenAIChatCompletionChunk24$Outbound = {
  type: "file";
  file:
    | OpenAIChatCompletionChunkFile1$Outbound
    | OpenAIChatCompletionChunkFile2$Outbound;
};

/** @internal */
export const OpenAIChatCompletionChunk24$outboundSchema: z.ZodType<
  OpenAIChatCompletionChunk24$Outbound,
  z.ZodTypeDef,
  OpenAIChatCompletionChunk24
> = z.object({
  type: z.literal("file"),
  file: z.union([
    z.lazy(() => OpenAIChatCompletionChunkFile1$outboundSchema),
    z.lazy(() => OpenAIChatCompletionChunkFile2$outboundSchema),
  ]),
});

export function openAIChatCompletionChunk24ToJSON(
  openAIChatCompletionChunk24: OpenAIChatCompletionChunk24,
): string {
  return JSON.stringify(
    OpenAIChatCompletionChunk24$outboundSchema.parse(
      openAIChatCompletionChunk24,
    ),
  );
}
export function openAIChatCompletionChunk24FromJSON(
  jsonString: string,
): SafeParseResult<OpenAIChatCompletionChunk24, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => OpenAIChatCompletionChunk24$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OpenAIChatCompletionChunk24' from JSON`,
  );
}

/** @internal */
export const OpenAIChatCompletionChunk2Format$inboundSchema: z.ZodNativeEnum<
  typeof OpenAIChatCompletionChunk2Format
> = z.nativeEnum(OpenAIChatCompletionChunk2Format);
/** @internal */
export const OpenAIChatCompletionChunk2Format$outboundSchema: z.ZodNativeEnum<
  typeof OpenAIChatCompletionChunk2Format
> = OpenAIChatCompletionChunk2Format$inboundSchema;

/** @internal */
export const OpenAIChatCompletionChunk2InputAudio$inboundSchema: z.ZodType<
  OpenAIChatCompletionChunk2InputAudio,
  z.ZodTypeDef,
  unknown
> = z.object({
  data: z.string(),
  format: OpenAIChatCompletionChunk2Format$inboundSchema,
});
/** @internal */
export type OpenAIChatCompletionChunk2InputAudio$Outbound = {
  data: string;
  format: string;
};

/** @internal */
export const OpenAIChatCompletionChunk2InputAudio$outboundSchema: z.ZodType<
  OpenAIChatCompletionChunk2InputAudio$Outbound,
  z.ZodTypeDef,
  OpenAIChatCompletionChunk2InputAudio
> = z.object({
  data: z.string(),
  format: OpenAIChatCompletionChunk2Format$outboundSchema,
});

export function openAIChatCompletionChunk2InputAudioToJSON(
  openAIChatCompletionChunk2InputAudio: OpenAIChatCompletionChunk2InputAudio,
): string {
  return JSON.stringify(
    OpenAIChatCompletionChunk2InputAudio$outboundSchema.parse(
      openAIChatCompletionChunk2InputAudio,
    ),
  );
}
export function openAIChatCompletionChunk2InputAudioFromJSON(
  jsonString: string,
): SafeParseResult<OpenAIChatCompletionChunk2InputAudio, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      OpenAIChatCompletionChunk2InputAudio$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OpenAIChatCompletionChunk2InputAudio' from JSON`,
  );
}

/** @internal */
export const OpenAIChatCompletionChunk23$inboundSchema: z.ZodType<
  OpenAIChatCompletionChunk23,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("input_audio"),
  input_audio: z.lazy(() => OpenAIChatCompletionChunk2InputAudio$inboundSchema),
}).transform((v) => {
  return remap$(v, {
    "input_audio": "inputAudio",
  });
});
/** @internal */
export type OpenAIChatCompletionChunk23$Outbound = {
  type: "input_audio";
  input_audio: OpenAIChatCompletionChunk2InputAudio$Outbound;
};

/** @internal */
export const OpenAIChatCompletionChunk23$outboundSchema: z.ZodType<
  OpenAIChatCompletionChunk23$Outbound,
  z.ZodTypeDef,
  OpenAIChatCompletionChunk23
> = z.object({
  type: z.literal("input_audio"),
  inputAudio: z.lazy(() => OpenAIChatCompletionChunk2InputAudio$outboundSchema),
}).transform((v) => {
  return remap$(v, {
    inputAudio: "input_audio",
  });
});

export function openAIChatCompletionChunk23ToJSON(
  openAIChatCompletionChunk23: OpenAIChatCompletionChunk23,
): string {
  return JSON.stringify(
    OpenAIChatCompletionChunk23$outboundSchema.parse(
      openAIChatCompletionChunk23,
    ),
  );
}
export function openAIChatCompletionChunk23FromJSON(
  jsonString: string,
): SafeParseResult<OpenAIChatCompletionChunk23, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => OpenAIChatCompletionChunk23$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OpenAIChatCompletionChunk23' from JSON`,
  );
}

/** @internal */
export const OpenAIChatCompletionChunk2Detail$inboundSchema: z.ZodNativeEnum<
  typeof OpenAIChatCompletionChunk2Detail
> = z.nativeEnum(OpenAIChatCompletionChunk2Detail);
/** @internal */
export const OpenAIChatCompletionChunk2Detail$outboundSchema: z.ZodNativeEnum<
  typeof OpenAIChatCompletionChunk2Detail
> = OpenAIChatCompletionChunk2Detail$inboundSchema;

/** @internal */
export const OpenAIChatCompletionChunk2ImageUrl$inboundSchema: z.ZodType<
  OpenAIChatCompletionChunk2ImageUrl,
  z.ZodTypeDef,
  unknown
> = z.object({
  url: z.string(),
  detail: OpenAIChatCompletionChunk2Detail$inboundSchema.optional(),
});
/** @internal */
export type OpenAIChatCompletionChunk2ImageUrl$Outbound = {
  url: string;
  detail?: string | undefined;
};

/** @internal */
export const OpenAIChatCompletionChunk2ImageUrl$outboundSchema: z.ZodType<
  OpenAIChatCompletionChunk2ImageUrl$Outbound,
  z.ZodTypeDef,
  OpenAIChatCompletionChunk2ImageUrl
> = z.object({
  url: z.string(),
  detail: OpenAIChatCompletionChunk2Detail$outboundSchema.optional(),
});

export function openAIChatCompletionChunk2ImageUrlToJSON(
  openAIChatCompletionChunk2ImageUrl: OpenAIChatCompletionChunk2ImageUrl,
): string {
  return JSON.stringify(
    OpenAIChatCompletionChunk2ImageUrl$outboundSchema.parse(
      openAIChatCompletionChunk2ImageUrl,
    ),
  );
}
export function openAIChatCompletionChunk2ImageUrlFromJSON(
  jsonString: string,
): SafeParseResult<OpenAIChatCompletionChunk2ImageUrl, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      OpenAIChatCompletionChunk2ImageUrl$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OpenAIChatCompletionChunk2ImageUrl' from JSON`,
  );
}

/** @internal */
export const OpenAIChatCompletionChunk22$inboundSchema: z.ZodType<
  OpenAIChatCompletionChunk22,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("image_url"),
  image_url: z.lazy(() => OpenAIChatCompletionChunk2ImageUrl$inboundSchema),
}).transform((v) => {
  return remap$(v, {
    "image_url": "imageUrl",
  });
});
/** @internal */
export type OpenAIChatCompletionChunk22$Outbound = {
  type: "image_url";
  image_url: OpenAIChatCompletionChunk2ImageUrl$Outbound;
};

/** @internal */
export const OpenAIChatCompletionChunk22$outboundSchema: z.ZodType<
  OpenAIChatCompletionChunk22$Outbound,
  z.ZodTypeDef,
  OpenAIChatCompletionChunk22
> = z.object({
  type: z.literal("image_url"),
  imageUrl: z.lazy(() => OpenAIChatCompletionChunk2ImageUrl$outboundSchema),
}).transform((v) => {
  return remap$(v, {
    imageUrl: "image_url",
  });
});

export function openAIChatCompletionChunk22ToJSON(
  openAIChatCompletionChunk22: OpenAIChatCompletionChunk22,
): string {
  return JSON.stringify(
    OpenAIChatCompletionChunk22$outboundSchema.parse(
      openAIChatCompletionChunk22,
    ),
  );
}
export function openAIChatCompletionChunk22FromJSON(
  jsonString: string,
): SafeParseResult<OpenAIChatCompletionChunk22, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => OpenAIChatCompletionChunk22$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OpenAIChatCompletionChunk22' from JSON`,
  );
}

/** @internal */
export const OpenAIChatCompletionChunk21$inboundSchema: z.ZodType<
  OpenAIChatCompletionChunk21,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("text"),
  text: z.string(),
});
/** @internal */
export type OpenAIChatCompletionChunk21$Outbound = {
  type: "text";
  text: string;
};

/** @internal */
export const OpenAIChatCompletionChunk21$outboundSchema: z.ZodType<
  OpenAIChatCompletionChunk21$Outbound,
  z.ZodTypeDef,
  OpenAIChatCompletionChunk21
> = z.object({
  type: z.literal("text"),
  text: z.string(),
});

export function openAIChatCompletionChunk21ToJSON(
  openAIChatCompletionChunk21: OpenAIChatCompletionChunk21,
): string {
  return JSON.stringify(
    OpenAIChatCompletionChunk21$outboundSchema.parse(
      openAIChatCompletionChunk21,
    ),
  );
}
export function openAIChatCompletionChunk21FromJSON(
  jsonString: string,
): SafeParseResult<OpenAIChatCompletionChunk21, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => OpenAIChatCompletionChunk21$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OpenAIChatCompletionChunk21' from JSON`,
  );
}

/** @internal */
export const OpenAIChatCompletionChunkContent2$inboundSchema: z.ZodType<
  OpenAIChatCompletionChunkContent2,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => OpenAIChatCompletionChunk21$inboundSchema),
  z.lazy(() => OpenAIChatCompletionChunk22$inboundSchema),
  z.lazy(() => OpenAIChatCompletionChunk23$inboundSchema),
  z.lazy(() => OpenAIChatCompletionChunk24$inboundSchema),
]);
/** @internal */
export type OpenAIChatCompletionChunkContent2$Outbound =
  | OpenAIChatCompletionChunk21$Outbound
  | OpenAIChatCompletionChunk22$Outbound
  | OpenAIChatCompletionChunk23$Outbound
  | OpenAIChatCompletionChunk24$Outbound;

/** @internal */
export const OpenAIChatCompletionChunkContent2$outboundSchema: z.ZodType<
  OpenAIChatCompletionChunkContent2$Outbound,
  z.ZodTypeDef,
  OpenAIChatCompletionChunkContent2
> = z.union([
  z.lazy(() => OpenAIChatCompletionChunk21$outboundSchema),
  z.lazy(() => OpenAIChatCompletionChunk22$outboundSchema),
  z.lazy(() => OpenAIChatCompletionChunk23$outboundSchema),
  z.lazy(() => OpenAIChatCompletionChunk24$outboundSchema),
]);

export function openAIChatCompletionChunkContent2ToJSON(
  openAIChatCompletionChunkContent2: OpenAIChatCompletionChunkContent2,
): string {
  return JSON.stringify(
    OpenAIChatCompletionChunkContent2$outboundSchema.parse(
      openAIChatCompletionChunkContent2,
    ),
  );
}
export function openAIChatCompletionChunkContent2FromJSON(
  jsonString: string,
): SafeParseResult<OpenAIChatCompletionChunkContent2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => OpenAIChatCompletionChunkContent2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OpenAIChatCompletionChunkContent2' from JSON`,
  );
}

/** @internal */
export const OpenAIChatCompletionChunkContent$inboundSchema: z.ZodType<
  OpenAIChatCompletionChunkContent,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.string(),
  z.array(z.union([
    z.lazy(() => OpenAIChatCompletionChunk21$inboundSchema),
    z.lazy(() => OpenAIChatCompletionChunk22$inboundSchema),
    z.lazy(() => OpenAIChatCompletionChunk23$inboundSchema),
    z.lazy(() => OpenAIChatCompletionChunk24$inboundSchema),
  ])),
]);
/** @internal */
export type OpenAIChatCompletionChunkContent$Outbound =
  | string
  | Array<
    | OpenAIChatCompletionChunk21$Outbound
    | OpenAIChatCompletionChunk22$Outbound
    | OpenAIChatCompletionChunk23$Outbound
    | OpenAIChatCompletionChunk24$Outbound
  >;

/** @internal */
export const OpenAIChatCompletionChunkContent$outboundSchema: z.ZodType<
  OpenAIChatCompletionChunkContent$Outbound,
  z.ZodTypeDef,
  OpenAIChatCompletionChunkContent
> = z.union([
  z.string(),
  z.array(z.union([
    z.lazy(() => OpenAIChatCompletionChunk21$outboundSchema),
    z.lazy(() => OpenAIChatCompletionChunk22$outboundSchema),
    z.lazy(() => OpenAIChatCompletionChunk23$outboundSchema),
    z.lazy(() => OpenAIChatCompletionChunk24$outboundSchema),
  ])),
]);

export function openAIChatCompletionChunkContentToJSON(
  openAIChatCompletionChunkContent: OpenAIChatCompletionChunkContent,
): string {
  return JSON.stringify(
    OpenAIChatCompletionChunkContent$outboundSchema.parse(
      openAIChatCompletionChunkContent,
    ),
  );
}
export function openAIChatCompletionChunkContentFromJSON(
  jsonString: string,
): SafeParseResult<OpenAIChatCompletionChunkContent, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => OpenAIChatCompletionChunkContent$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OpenAIChatCompletionChunkContent' from JSON`,
  );
}

/** @internal */
export const OpenAIChatCompletionChunkFunction$inboundSchema: z.ZodType<
  OpenAIChatCompletionChunkFunction,
  z.ZodTypeDef,
  unknown
> = z.object({
  name: z.string().optional(),
  arguments: z.string().optional(),
});
/** @internal */
export type OpenAIChatCompletionChunkFunction$Outbound = {
  name?: string | undefined;
  arguments?: string | undefined;
};

/** @internal */
export const OpenAIChatCompletionChunkFunction$outboundSchema: z.ZodType<
  OpenAIChatCompletionChunkFunction$Outbound,
  z.ZodTypeDef,
  OpenAIChatCompletionChunkFunction
> = z.object({
  name: z.string().optional(),
  arguments: z.string().optional(),
});

export function openAIChatCompletionChunkFunctionToJSON(
  openAIChatCompletionChunkFunction: OpenAIChatCompletionChunkFunction,
): string {
  return JSON.stringify(
    OpenAIChatCompletionChunkFunction$outboundSchema.parse(
      openAIChatCompletionChunkFunction,
    ),
  );
}
export function openAIChatCompletionChunkFunctionFromJSON(
  jsonString: string,
): SafeParseResult<OpenAIChatCompletionChunkFunction, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => OpenAIChatCompletionChunkFunction$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OpenAIChatCompletionChunkFunction' from JSON`,
  );
}

/** @internal */
export const OpenAIChatCompletionChunkToolCalls$inboundSchema: z.ZodType<
  OpenAIChatCompletionChunkToolCalls,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: z.string().optional(),
  type: z.literal("function").optional(),
  function: z.lazy(() => OpenAIChatCompletionChunkFunction$inboundSchema)
    .optional(),
  index: z.number().int(),
});
/** @internal */
export type OpenAIChatCompletionChunkToolCalls$Outbound = {
  id?: string | undefined;
  type?: "function" | undefined;
  function?: OpenAIChatCompletionChunkFunction$Outbound | undefined;
  index: number;
};

/** @internal */
export const OpenAIChatCompletionChunkToolCalls$outboundSchema: z.ZodType<
  OpenAIChatCompletionChunkToolCalls$Outbound,
  z.ZodTypeDef,
  OpenAIChatCompletionChunkToolCalls
> = z.object({
  id: z.string().optional(),
  type: z.literal("function").optional(),
  function: z.lazy(() => OpenAIChatCompletionChunkFunction$outboundSchema)
    .optional(),
  index: z.number().int(),
});

export function openAIChatCompletionChunkToolCallsToJSON(
  openAIChatCompletionChunkToolCalls: OpenAIChatCompletionChunkToolCalls,
): string {
  return JSON.stringify(
    OpenAIChatCompletionChunkToolCalls$outboundSchema.parse(
      openAIChatCompletionChunkToolCalls,
    ),
  );
}
export function openAIChatCompletionChunkToolCallsFromJSON(
  jsonString: string,
): SafeParseResult<OpenAIChatCompletionChunkToolCalls, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      OpenAIChatCompletionChunkToolCalls$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OpenAIChatCompletionChunkToolCalls' from JSON`,
  );
}

/** @internal */
export const Delta$inboundSchema: z.ZodType<Delta, z.ZodTypeDef, unknown> = z
  .object({
    role: z.literal("assistant").optional(),
    content: z.nullable(
      z.union([
        z.string(),
        z.array(
          z.union([
            z.lazy(() => OpenAIChatCompletionChunk21$inboundSchema),
            z.lazy(() => OpenAIChatCompletionChunk22$inboundSchema),
            z.lazy(() => OpenAIChatCompletionChunk23$inboundSchema),
            z.lazy(() => OpenAIChatCompletionChunk24$inboundSchema),
          ]),
        ),
      ]),
    ).optional(),
    reasoning: z.nullable(z.string()).optional(),
    tool_calls: z.array(
      z.lazy(() => OpenAIChatCompletionChunkToolCalls$inboundSchema),
    ).optional(),
  }).transform((v) => {
    return remap$(v, {
      "tool_calls": "toolCalls",
    });
  });
/** @internal */
export type Delta$Outbound = {
  role?: "assistant" | undefined;
  content?:
    | string
    | Array<
      | OpenAIChatCompletionChunk21$Outbound
      | OpenAIChatCompletionChunk22$Outbound
      | OpenAIChatCompletionChunk23$Outbound
      | OpenAIChatCompletionChunk24$Outbound
    >
    | null
    | undefined;
  reasoning?: string | null | undefined;
  tool_calls?: Array<OpenAIChatCompletionChunkToolCalls$Outbound> | undefined;
};

/** @internal */
export const Delta$outboundSchema: z.ZodType<
  Delta$Outbound,
  z.ZodTypeDef,
  Delta
> = z.object({
  role: z.literal("assistant").optional(),
  content: z.nullable(
    z.union([
      z.string(),
      z.array(
        z.union([
          z.lazy(() => OpenAIChatCompletionChunk21$outboundSchema),
          z.lazy(() => OpenAIChatCompletionChunk22$outboundSchema),
          z.lazy(() => OpenAIChatCompletionChunk23$outboundSchema),
          z.lazy(() => OpenAIChatCompletionChunk24$outboundSchema),
        ]),
      ),
    ]),
  ).optional(),
  reasoning: z.nullable(z.string()).optional(),
  toolCalls: z.array(
    z.lazy(() => OpenAIChatCompletionChunkToolCalls$outboundSchema),
  ).optional(),
}).transform((v) => {
  return remap$(v, {
    toolCalls: "tool_calls",
  });
});

export function deltaToJSON(delta: Delta): string {
  return JSON.stringify(Delta$outboundSchema.parse(delta));
}
export function deltaFromJSON(
  jsonString: string,
): SafeParseResult<Delta, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Delta$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Delta' from JSON`,
  );
}

/** @internal */
export const FinishReason1$inboundSchema: z.ZodNativeEnum<
  typeof FinishReason1
> = z.nativeEnum(FinishReason1);
/** @internal */
export const FinishReason1$outboundSchema: z.ZodNativeEnum<
  typeof FinishReason1
> = FinishReason1$inboundSchema;

/** @internal */
export const OpenAIChatCompletionChunkFinishReason$inboundSchema: z.ZodType<
  OpenAIChatCompletionChunkFinishReason,
  z.ZodTypeDef,
  unknown
> = z.union([FinishReason1$inboundSchema, z.string()]);
/** @internal */
export type OpenAIChatCompletionChunkFinishReason$Outbound = string | string;

/** @internal */
export const OpenAIChatCompletionChunkFinishReason$outboundSchema: z.ZodType<
  OpenAIChatCompletionChunkFinishReason$Outbound,
  z.ZodTypeDef,
  OpenAIChatCompletionChunkFinishReason
> = z.union([FinishReason1$outboundSchema, z.string()]);

export function openAIChatCompletionChunkFinishReasonToJSON(
  openAIChatCompletionChunkFinishReason: OpenAIChatCompletionChunkFinishReason,
): string {
  return JSON.stringify(
    OpenAIChatCompletionChunkFinishReason$outboundSchema.parse(
      openAIChatCompletionChunkFinishReason,
    ),
  );
}
export function openAIChatCompletionChunkFinishReasonFromJSON(
  jsonString: string,
): SafeParseResult<OpenAIChatCompletionChunkFinishReason, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      OpenAIChatCompletionChunkFinishReason$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OpenAIChatCompletionChunkFinishReason' from JSON`,
  );
}

/** @internal */
export const OpenAIChatCompletionChunkLogprobs$inboundSchema: z.ZodType<
  OpenAIChatCompletionChunkLogprobs,
  z.ZodTypeDef,
  unknown
> = z.object({
  tokens: z.array(z.string()),
  token_logprobs: z.array(z.number()),
  top_logprobs: z.array(z.record(z.number())),
  text_offset: z.array(z.number().int()),
}).transform((v) => {
  return remap$(v, {
    "token_logprobs": "tokenLogprobs",
    "top_logprobs": "topLogprobs",
    "text_offset": "textOffset",
  });
});
/** @internal */
export type OpenAIChatCompletionChunkLogprobs$Outbound = {
  tokens: Array<string>;
  token_logprobs: Array<number>;
  top_logprobs: Array<{ [k: string]: number }>;
  text_offset: Array<number>;
};

/** @internal */
export const OpenAIChatCompletionChunkLogprobs$outboundSchema: z.ZodType<
  OpenAIChatCompletionChunkLogprobs$Outbound,
  z.ZodTypeDef,
  OpenAIChatCompletionChunkLogprobs
> = z.object({
  tokens: z.array(z.string()),
  tokenLogprobs: z.array(z.number()),
  topLogprobs: z.array(z.record(z.number())),
  textOffset: z.array(z.number().int()),
}).transform((v) => {
  return remap$(v, {
    tokenLogprobs: "token_logprobs",
    topLogprobs: "top_logprobs",
    textOffset: "text_offset",
  });
});

export function openAIChatCompletionChunkLogprobsToJSON(
  openAIChatCompletionChunkLogprobs: OpenAIChatCompletionChunkLogprobs,
): string {
  return JSON.stringify(
    OpenAIChatCompletionChunkLogprobs$outboundSchema.parse(
      openAIChatCompletionChunkLogprobs,
    ),
  );
}
export function openAIChatCompletionChunkLogprobsFromJSON(
  jsonString: string,
): SafeParseResult<OpenAIChatCompletionChunkLogprobs, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => OpenAIChatCompletionChunkLogprobs$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OpenAIChatCompletionChunkLogprobs' from JSON`,
  );
}

/** @internal */
export const Choices$inboundSchema: z.ZodType<Choices, z.ZodTypeDef, unknown> =
  z.object({
    index: z.number().int(),
    delta: z.lazy(() => Delta$inboundSchema),
    finish_reason: z.nullable(
      z.union([FinishReason1$inboundSchema, z.string()]),
    ),
    logprobs: z.nullable(
      z.lazy(() => OpenAIChatCompletionChunkLogprobs$inboundSchema),
    ).optional(),
  }).transform((v) => {
    return remap$(v, {
      "finish_reason": "finishReason",
    });
  });
/** @internal */
export type Choices$Outbound = {
  index: number;
  delta: Delta$Outbound;
  finish_reason: string | string | null;
  logprobs?: OpenAIChatCompletionChunkLogprobs$Outbound | null | undefined;
};

/** @internal */
export const Choices$outboundSchema: z.ZodType<
  Choices$Outbound,
  z.ZodTypeDef,
  Choices
> = z.object({
  index: z.number().int(),
  delta: z.lazy(() => Delta$outboundSchema),
  finishReason: z.nullable(z.union([FinishReason1$outboundSchema, z.string()])),
  logprobs: z.nullable(
    z.lazy(() => OpenAIChatCompletionChunkLogprobs$outboundSchema),
  ).optional(),
}).transform((v) => {
  return remap$(v, {
    finishReason: "finish_reason",
  });
});

export function choicesToJSON(choices: Choices): string {
  return JSON.stringify(Choices$outboundSchema.parse(choices));
}
export function choicesFromJSON(
  jsonString: string,
): SafeParseResult<Choices, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Choices$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Choices' from JSON`,
  );
}

/** @internal */
export const OpenAIChatCompletionChunk$inboundSchema: z.ZodType<
  OpenAIChatCompletionChunk,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: z.string(),
  object: z.literal("chat.completion.chunk"),
  created: z.number().int(),
  model: z.string(),
  choices: z.array(z.lazy(() => Choices$inboundSchema)),
  usage: OpenAIChatCompletionUsage$inboundSchema.optional(),
  system_fingerprint: z.string().optional(),
}).transform((v) => {
  return remap$(v, {
    "system_fingerprint": "systemFingerprint",
  });
});
/** @internal */
export type OpenAIChatCompletionChunk$Outbound = {
  id: string;
  object: "chat.completion.chunk";
  created: number;
  model: string;
  choices: Array<Choices$Outbound>;
  usage?: OpenAIChatCompletionUsage$Outbound | undefined;
  system_fingerprint?: string | undefined;
};

/** @internal */
export const OpenAIChatCompletionChunk$outboundSchema: z.ZodType<
  OpenAIChatCompletionChunk$Outbound,
  z.ZodTypeDef,
  OpenAIChatCompletionChunk
> = z.object({
  id: z.string(),
  object: z.literal("chat.completion.chunk"),
  created: z.number().int(),
  model: z.string(),
  choices: z.array(z.lazy(() => Choices$outboundSchema)),
  usage: OpenAIChatCompletionUsage$outboundSchema.optional(),
  systemFingerprint: z.string().optional(),
}).transform((v) => {
  return remap$(v, {
    systemFingerprint: "system_fingerprint",
  });
});

export function openAIChatCompletionChunkToJSON(
  openAIChatCompletionChunk: OpenAIChatCompletionChunk,
): string {
  return JSON.stringify(
    OpenAIChatCompletionChunk$outboundSchema.parse(openAIChatCompletionChunk),
  );
}
export function openAIChatCompletionChunkFromJSON(
  jsonString: string,
): SafeParseResult<OpenAIChatCompletionChunk, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => OpenAIChatCompletionChunk$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OpenAIChatCompletionChunk' from JSON`,
  );
}