@openrouter/sdk 0.0.0-beta.42 → 0.0.0-beta.43

package/src/models/openresponseseasyinputmessage.ts

@@ -8,23 +8,11 @@ import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import {
-  ResponseInputFile,
-  ResponseInputFile$inboundSchema,
-  ResponseInputFile$Outbound,
-  ResponseInputFile$outboundSchema,
-} from "./responseinputfile.js";
-import {
-  ResponseInputImage,
-  ResponseInputImage$inboundSchema,
-  ResponseInputImage$Outbound,
-  ResponseInputImage$outboundSchema,
-} from "./responseinputimage.js";
-import {
-  ResponseInputText,
-  ResponseInputText$inboundSchema,
-  ResponseInputText$Outbound,
-  ResponseInputText$outboundSchema,
-} from "./responseinputtext.js";
+  OpenResponsesInputContent,
+  OpenResponsesInputContent$inboundSchema,
+  OpenResponsesInputContent$Outbound,
+  OpenResponsesInputContent$outboundSchema,
+} from "./openresponsesinputcontent.js";
 
 export const OpenResponsesEasyInputMessageType = {
   Message: "message",
@@ -67,19 +55,13 @@ export type OpenResponsesEasyInputMessageRoleUnion =
   | OpenResponsesEasyInputMessageRoleAssistant
   | OpenResponsesEasyInputMessageRoleDeveloper;
 
-export type OpenResponsesEasyInputMessageContent1 =
-  | (ResponseInputText & { type: "input_text" })
-  | (ResponseInputImage & { type: "input_image" })
-  | (ResponseInputFile & { type: "input_file" });
-
-export type OpenResponsesEasyInputMessageContent2 =
-  | Array<
-    | (ResponseInputText & { type: "input_text" })
-    | (ResponseInputImage & { type: "input_image" })
-    | (ResponseInputFile & { type: "input_file" })
-  >
+export type OpenResponsesEasyInputMessageContent =
+  | Array<OpenResponsesInputContent>
   | string;
 
+/**
+ * Simplified input message format that accepts string or array content
+ */
 export type OpenResponsesEasyInputMessage = {
   type?: OpenResponsesEasyInputMessageType | undefined;
   role:
@@ -87,13 +69,7 @@ export type OpenResponsesEasyInputMessage = {
     | OpenResponsesEasyInputMessageRoleSystem
     | OpenResponsesEasyInputMessageRoleAssistant
     | OpenResponsesEasyInputMessageRoleDeveloper;
-  content:
-    | Array<
-      | (ResponseInputText & { type: "input_text" })
-      | (ResponseInputImage & { type: "input_image" })
-      | (ResponseInputFile & { type: "input_file" })
-    >
-    | string;
+  content: Array<OpenResponsesInputContent> | string;
 };
 
 /** @internal */
@@ -280,191 +256,57 @@ export function openResponsesEasyInputMessageRoleUnionFromJSON(
 }
 
 /** @internal */
-export const OpenResponsesEasyInputMessageContent1$inboundSchema: z.ZodType<
-  OpenResponsesEasyInputMessageContent1,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  ResponseInputText$inboundSchema.and(
-    z.object({ type: z.literal("input_text") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
-  ResponseInputImage$inboundSchema.and(
-    z.object({ type: z.literal("input_image") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
-  ResponseInputFile$inboundSchema.and(
-    z.object({ type: z.literal("input_file") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
-]);
-
-/** @internal */
-export type OpenResponsesEasyInputMessageContent1$Outbound =
-  | (ResponseInputText$Outbound & { type: "input_text" })
-  | (ResponseInputImage$Outbound & { type: "input_image" })
-  | (ResponseInputFile$Outbound & { type: "input_file" });
-
-/** @internal */
-export const OpenResponsesEasyInputMessageContent1$outboundSchema: z.ZodType<
-  OpenResponsesEasyInputMessageContent1$Outbound,
-  z.ZodTypeDef,
-  OpenResponsesEasyInputMessageContent1
-> = z.union([
-  ResponseInputText$outboundSchema.and(
-    z.object({ type: z.literal("input_text") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
-  ResponseInputImage$outboundSchema.and(
-    z.object({ type: z.literal("input_image") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
-  ResponseInputFile$outboundSchema.and(
-    z.object({ type: z.literal("input_file") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
-]);
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace OpenResponsesEasyInputMessageContent1$ {
-  /** @deprecated use `OpenResponsesEasyInputMessageContent1$inboundSchema` instead. */
-  export const inboundSchema =
-    OpenResponsesEasyInputMessageContent1$inboundSchema;
-  /** @deprecated use `OpenResponsesEasyInputMessageContent1$outboundSchema` instead. */
-  export const outboundSchema =
-    OpenResponsesEasyInputMessageContent1$outboundSchema;
-  /** @deprecated use `OpenResponsesEasyInputMessageContent1$Outbound` instead. */
-  export type Outbound = OpenResponsesEasyInputMessageContent1$Outbound;
-}
-
-export function openResponsesEasyInputMessageContent1ToJSON(
-  openResponsesEasyInputMessageContent1: OpenResponsesEasyInputMessageContent1,
-): string {
-  return JSON.stringify(
-    OpenResponsesEasyInputMessageContent1$outboundSchema.parse(
-      openResponsesEasyInputMessageContent1,
-    ),
-  );
-}
-
-export function openResponsesEasyInputMessageContent1FromJSON(
-  jsonString: string,
-): SafeParseResult<OpenResponsesEasyInputMessageContent1, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      OpenResponsesEasyInputMessageContent1$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'OpenResponsesEasyInputMessageContent1' from JSON`,
-  );
-}
-
-/** @internal */
-export const OpenResponsesEasyInputMessageContent2$inboundSchema: z.ZodType<
-  OpenResponsesEasyInputMessageContent2,
+export const OpenResponsesEasyInputMessageContent$inboundSchema: z.ZodType<
+  OpenResponsesEasyInputMessageContent,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  z.array(
-    z.union([
-      ResponseInputText$inboundSchema.and(
-        z.object({ type: z.literal("input_text") }).transform((v) => ({
-          type: v.type,
-        })),
-      ),
-      ResponseInputImage$inboundSchema.and(
-        z.object({ type: z.literal("input_image") }).transform((v) => ({
-          type: v.type,
-        })),
-      ),
-      ResponseInputFile$inboundSchema.and(
-        z.object({ type: z.literal("input_file") }).transform((v) => ({
-          type: v.type,
-        })),
-      ),
-    ]),
-  ),
-  z.string(),
-]);
+> = z.union([z.array(OpenResponsesInputContent$inboundSchema), z.string()]);
 
 /** @internal */
-export type OpenResponsesEasyInputMessageContent2$Outbound =
-  | Array<
-    | (ResponseInputText$Outbound & { type: "input_text" })
-    | (ResponseInputImage$Outbound & { type: "input_image" })
-    | (ResponseInputFile$Outbound & { type: "input_file" })
-  >
+export type OpenResponsesEasyInputMessageContent$Outbound =
+  | Array<OpenResponsesInputContent$Outbound>
   | string;
 
 /** @internal */
-export const OpenResponsesEasyInputMessageContent2$outboundSchema: z.ZodType<
-  OpenResponsesEasyInputMessageContent2$Outbound,
+export const OpenResponsesEasyInputMessageContent$outboundSchema: z.ZodType<
+  OpenResponsesEasyInputMessageContent$Outbound,
   z.ZodTypeDef,
-  OpenResponsesEasyInputMessageContent2
-> = z.union([
-  z.array(
-    z.union([
-      ResponseInputText$outboundSchema.and(
-        z.object({ type: z.literal("input_text") }).transform((v) => ({
-          type: v.type,
-        })),
-      ),
-      ResponseInputImage$outboundSchema.and(
-        z.object({ type: z.literal("input_image") }).transform((v) => ({
-          type: v.type,
-        })),
-      ),
-      ResponseInputFile$outboundSchema.and(
-        z.object({ type: z.literal("input_file") }).transform((v) => ({
-          type: v.type,
-        })),
-      ),
-    ]),
-  ),
-  z.string(),
-]);
+  OpenResponsesEasyInputMessageContent
+> = z.union([z.array(OpenResponsesInputContent$outboundSchema), z.string()]);
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace OpenResponsesEasyInputMessageContent2$ {
-  /** @deprecated use `OpenResponsesEasyInputMessageContent2$inboundSchema` instead. */
+export namespace OpenResponsesEasyInputMessageContent$ {
+  /** @deprecated use `OpenResponsesEasyInputMessageContent$inboundSchema` instead. */
   export const inboundSchema =
-    OpenResponsesEasyInputMessageContent2$inboundSchema;
-  /** @deprecated use `OpenResponsesEasyInputMessageContent2$outboundSchema` instead. */
+    OpenResponsesEasyInputMessageContent$inboundSchema;
+  /** @deprecated use `OpenResponsesEasyInputMessageContent$outboundSchema` instead. */
   export const outboundSchema =
-    OpenResponsesEasyInputMessageContent2$outboundSchema;
-  /** @deprecated use `OpenResponsesEasyInputMessageContent2$Outbound` instead. */
-  export type Outbound = OpenResponsesEasyInputMessageContent2$Outbound;
+    OpenResponsesEasyInputMessageContent$outboundSchema;
+  /** @deprecated use `OpenResponsesEasyInputMessageContent$Outbound` instead. */
+  export type Outbound = OpenResponsesEasyInputMessageContent$Outbound;
 }
 
-export function openResponsesEasyInputMessageContent2ToJSON(
-  openResponsesEasyInputMessageContent2: OpenResponsesEasyInputMessageContent2,
+export function openResponsesEasyInputMessageContentToJSON(
+  openResponsesEasyInputMessageContent: OpenResponsesEasyInputMessageContent,
 ): string {
   return JSON.stringify(
-    OpenResponsesEasyInputMessageContent2$outboundSchema.parse(
-      openResponsesEasyInputMessageContent2,
+    OpenResponsesEasyInputMessageContent$outboundSchema.parse(
+      openResponsesEasyInputMessageContent,
     ),
   );
 }
 
-export function openResponsesEasyInputMessageContent2FromJSON(
+export function openResponsesEasyInputMessageContentFromJSON(
   jsonString: string,
-): SafeParseResult<OpenResponsesEasyInputMessageContent2, SDKValidationError> {
+): SafeParseResult<OpenResponsesEasyInputMessageContent, SDKValidationError> {
   return safeParse(
     jsonString,
     (x) =>
-      OpenResponsesEasyInputMessageContent2$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'OpenResponsesEasyInputMessageContent2' from JSON`,
+      OpenResponsesEasyInputMessageContent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OpenResponsesEasyInputMessageContent' from JSON`,
   );
 }
 
@@ -482,25 +324,7 @@ export const OpenResponsesEasyInputMessage$inboundSchema: z.ZodType<
     OpenResponsesEasyInputMessageRoleDeveloper$inboundSchema,
   ]),
   content: z.union([
-    z.array(
-      z.union([
-        ResponseInputText$inboundSchema.and(
-          z.object({ type: z.literal("input_text") }).transform((v) => ({
-            type: v.type,
-          })),
-        ),
-        ResponseInputImage$inboundSchema.and(
-          z.object({ type: z.literal("input_image") }).transform((v) => ({
-            type: v.type,
-          })),
-        ),
-        ResponseInputFile$inboundSchema.and(
-          z.object({ type: z.literal("input_file") }).transform((v) => ({
-            type: v.type,
-          })),
-        ),
-      ]),
-    ),
+    z.array(OpenResponsesInputContent$inboundSchema),
     z.string(),
   ]),
 });
@@ -509,13 +333,7 @@ export const OpenResponsesEasyInputMessage$inboundSchema: z.ZodType<
 export type OpenResponsesEasyInputMessage$Outbound = {
   type?: string | undefined;
   role: string | string | string | string;
-  content:
-    | Array<
-      | (ResponseInputText$Outbound & { type: "input_text" })
-      | (ResponseInputImage$Outbound & { type: "input_image" })
-      | (ResponseInputFile$Outbound & { type: "input_file" })
-    >
-    | string;
+  content: Array<OpenResponsesInputContent$Outbound> | string;
 };
 
 /** @internal */
@@ -532,25 +350,7 @@ export const OpenResponsesEasyInputMessage$outboundSchema: z.ZodType<
     OpenResponsesEasyInputMessageRoleDeveloper$outboundSchema,
   ]),
   content: z.union([
-    z.array(
-      z.union([
-        ResponseInputText$outboundSchema.and(
-          z.object({ type: z.literal("input_text") }).transform((v) => ({
-            type: v.type,
-          })),
-        ),
-        ResponseInputImage$outboundSchema.and(
-          z.object({ type: z.literal("input_image") }).transform((v) => ({
-            type: v.type,
-          })),
-        ),
-        ResponseInputFile$outboundSchema.and(
-          z.object({ type: z.literal("input_file") }).transform((v) => ({
-            type: v.type,
-          })),
-        ),
-      ]),
-    ),
+    z.array(OpenResponsesInputContent$outboundSchema),
     z.string(),
   ]),
 });

package/src/models/openresponsesformatjsonobject.ts

@@ -0,0 +1,101 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+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";
+
+export const OpenResponsesFormatJSONObjectType = {
+  JsonObject: "json_object",
+} as const;
+export type OpenResponsesFormatJSONObjectType = ClosedEnum<
+  typeof OpenResponsesFormatJSONObjectType
+>;
+
+/**
+ * JSON object response format
+ */
+export type OpenResponsesFormatJSONObject = {
+  type: OpenResponsesFormatJSONObjectType;
+};
+
+/** @internal */
+export const OpenResponsesFormatJSONObjectType$inboundSchema: z.ZodNativeEnum<
+  typeof OpenResponsesFormatJSONObjectType
+> = z.nativeEnum(OpenResponsesFormatJSONObjectType);
+
+/** @internal */
+export const OpenResponsesFormatJSONObjectType$outboundSchema: z.ZodNativeEnum<
+  typeof OpenResponsesFormatJSONObjectType
+> = OpenResponsesFormatJSONObjectType$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesFormatJSONObjectType$ {
+  /** @deprecated use `OpenResponsesFormatJSONObjectType$inboundSchema` instead. */
+  export const inboundSchema = OpenResponsesFormatJSONObjectType$inboundSchema;
+  /** @deprecated use `OpenResponsesFormatJSONObjectType$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesFormatJSONObjectType$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesFormatJSONObject$inboundSchema: z.ZodType<
+  OpenResponsesFormatJSONObject,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: OpenResponsesFormatJSONObjectType$inboundSchema,
+});
+
+/** @internal */
+export type OpenResponsesFormatJSONObject$Outbound = {
+  type: string;
+};
+
+/** @internal */
+export const OpenResponsesFormatJSONObject$outboundSchema: z.ZodType<
+  OpenResponsesFormatJSONObject$Outbound,
+  z.ZodTypeDef,
+  OpenResponsesFormatJSONObject
+> = z.object({
+  type: OpenResponsesFormatJSONObjectType$outboundSchema,
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesFormatJSONObject$ {
+  /** @deprecated use `OpenResponsesFormatJSONObject$inboundSchema` instead. */
+  export const inboundSchema = OpenResponsesFormatJSONObject$inboundSchema;
+  /** @deprecated use `OpenResponsesFormatJSONObject$outboundSchema` instead. */
+  export const outboundSchema = OpenResponsesFormatJSONObject$outboundSchema;
+  /** @deprecated use `OpenResponsesFormatJSONObject$Outbound` instead. */
+  export type Outbound = OpenResponsesFormatJSONObject$Outbound;
+}
+
+export function openResponsesFormatJSONObjectToJSON(
+  openResponsesFormatJSONObject: OpenResponsesFormatJSONObject,
+): string {
+  return JSON.stringify(
+    OpenResponsesFormatJSONObject$outboundSchema.parse(
+      openResponsesFormatJSONObject,
+    ),
+  );
+}
+
+export function openResponsesFormatJSONObjectFromJSON(
+  jsonString: string,
+): SafeParseResult<OpenResponsesFormatJSONObject, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OpenResponsesFormatJSONObject$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OpenResponsesFormatJSONObject' from JSON`,
+  );
+}

package/src/models/openresponsesformatjsonschema.ts

@@ -0,0 +1,117 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+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";
+
+export const OpenResponsesFormatJSONSchemaType = {
+  JsonSchema: "json_schema",
+} as const;
+export type OpenResponsesFormatJSONSchemaType = ClosedEnum<
+  typeof OpenResponsesFormatJSONSchemaType
+>;
+
+/**
+ * JSON schema constrained response format
+ */
+export type OpenResponsesFormatJSONSchema = {
+  type: OpenResponsesFormatJSONSchemaType;
+  name: string;
+  description?: string | undefined;
+  strict?: boolean | null | undefined;
+  schema: { [k: string]: any | null };
+};
+
+/** @internal */
+export const OpenResponsesFormatJSONSchemaType$inboundSchema: z.ZodNativeEnum<
+  typeof OpenResponsesFormatJSONSchemaType
+> = z.nativeEnum(OpenResponsesFormatJSONSchemaType);
+
+/** @internal */
+export const OpenResponsesFormatJSONSchemaType$outboundSchema: z.ZodNativeEnum<
+  typeof OpenResponsesFormatJSONSchemaType
+> = OpenResponsesFormatJSONSchemaType$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesFormatJSONSchemaType$ {
+  /** @deprecated use `OpenResponsesFormatJSONSchemaType$inboundSchema` instead. */
+  export const inboundSchema = OpenResponsesFormatJSONSchemaType$inboundSchema;
+  /** @deprecated use `OpenResponsesFormatJSONSchemaType$outboundSchema` instead. */
+  export const outboundSchema =
+    OpenResponsesFormatJSONSchemaType$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesFormatJSONSchema$inboundSchema: z.ZodType<
+  OpenResponsesFormatJSONSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: OpenResponsesFormatJSONSchemaType$inboundSchema,
+  name: z.string(),
+  description: z.string().optional(),
+  strict: z.nullable(z.boolean()).optional(),
+  schema: z.record(z.nullable(z.any())),
+});
+
+/** @internal */
+export type OpenResponsesFormatJSONSchema$Outbound = {
+  type: string;
+  name: string;
+  description?: string | undefined;
+  strict?: boolean | null | undefined;
+  schema: { [k: string]: any | null };
+};
+
+/** @internal */
+export const OpenResponsesFormatJSONSchema$outboundSchema: z.ZodType<
+  OpenResponsesFormatJSONSchema$Outbound,
+  z.ZodTypeDef,
+  OpenResponsesFormatJSONSchema
+> = z.object({
+  type: OpenResponsesFormatJSONSchemaType$outboundSchema,
+  name: z.string(),
+  description: z.string().optional(),
+  strict: z.nullable(z.boolean()).optional(),
+  schema: z.record(z.nullable(z.any())),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesFormatJSONSchema$ {
+  /** @deprecated use `OpenResponsesFormatJSONSchema$inboundSchema` instead. */
+  export const inboundSchema = OpenResponsesFormatJSONSchema$inboundSchema;
+  /** @deprecated use `OpenResponsesFormatJSONSchema$outboundSchema` instead. */
+  export const outboundSchema = OpenResponsesFormatJSONSchema$outboundSchema;
+  /** @deprecated use `OpenResponsesFormatJSONSchema$Outbound` instead. */
+  export type Outbound = OpenResponsesFormatJSONSchema$Outbound;
+}
+
+export function openResponsesFormatJSONSchemaToJSON(
+  openResponsesFormatJSONSchema: OpenResponsesFormatJSONSchema,
+): string {
+  return JSON.stringify(
+    OpenResponsesFormatJSONSchema$outboundSchema.parse(
+      openResponsesFormatJSONSchema,
+    ),
+  );
+}
+
+export function openResponsesFormatJSONSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<OpenResponsesFormatJSONSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OpenResponsesFormatJSONSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OpenResponsesFormatJSONSchema' from JSON`,
+  );
+}

package/src/models/openresponsesformattext.ts

@@ -0,0 +1,98 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+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";
+
+export const OpenResponsesFormatTextType = {
+  Text: "text",
+} as const;
+export type OpenResponsesFormatTextType = ClosedEnum<
+  typeof OpenResponsesFormatTextType
+>;
+
+/**
+ * Plain text response format
+ */
+export type OpenResponsesFormatText = {
+  type: OpenResponsesFormatTextType;
+};
+
+/** @internal */
+export const OpenResponsesFormatTextType$inboundSchema: z.ZodNativeEnum<
+  typeof OpenResponsesFormatTextType
+> = z.nativeEnum(OpenResponsesFormatTextType);
+
+/** @internal */
+export const OpenResponsesFormatTextType$outboundSchema: z.ZodNativeEnum<
+  typeof OpenResponsesFormatTextType
+> = OpenResponsesFormatTextType$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesFormatTextType$ {
+  /** @deprecated use `OpenResponsesFormatTextType$inboundSchema` instead. */
+  export const inboundSchema = OpenResponsesFormatTextType$inboundSchema;
+  /** @deprecated use `OpenResponsesFormatTextType$outboundSchema` instead. */
+  export const outboundSchema = OpenResponsesFormatTextType$outboundSchema;
+}
+
+/** @internal */
+export const OpenResponsesFormatText$inboundSchema: z.ZodType<
+  OpenResponsesFormatText,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: OpenResponsesFormatTextType$inboundSchema,
+});
+
+/** @internal */
+export type OpenResponsesFormatText$Outbound = {
+  type: string;
+};
+
+/** @internal */
+export const OpenResponsesFormatText$outboundSchema: z.ZodType<
+  OpenResponsesFormatText$Outbound,
+  z.ZodTypeDef,
+  OpenResponsesFormatText
+> = z.object({
+  type: OpenResponsesFormatTextType$outboundSchema,
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OpenResponsesFormatText$ {
+  /** @deprecated use `OpenResponsesFormatText$inboundSchema` instead. */
+  export const inboundSchema = OpenResponsesFormatText$inboundSchema;
+  /** @deprecated use `OpenResponsesFormatText$outboundSchema` instead. */
+  export const outboundSchema = OpenResponsesFormatText$outboundSchema;
+  /** @deprecated use `OpenResponsesFormatText$Outbound` instead. */
+  export type Outbound = OpenResponsesFormatText$Outbound;
+}
+
+export function openResponsesFormatTextToJSON(
+  openResponsesFormatText: OpenResponsesFormatText,
+): string {
+  return JSON.stringify(
+    OpenResponsesFormatText$outboundSchema.parse(openResponsesFormatText),
+  );
+}
+
+export function openResponsesFormatTextFromJSON(
+  jsonString: string,
+): SafeParseResult<OpenResponsesFormatText, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OpenResponsesFormatText$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OpenResponsesFormatText' from JSON`,
+  );
+}