@orq-ai/node 4.1.0-rc.45 → 4.1.0-rc.50

package/src/models/operations/createimage.ts

@@ -0,0 +1,966 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Allows to set transparency for the background of the generated image(s). This parameter is only supported for `openai/gpt-image-1`.
+ */
+export const Background = {
+  Transparent: "transparent",
+  Opaque: "opaque",
+  Auto: "auto",
+} as const;
+/**
+ * Allows to set transparency for the background of the generated image(s). This parameter is only supported for `openai/gpt-image-1`.
+ */
+export type Background = ClosedEnum<typeof Background>;
+
+/**
+ * Control the content-moderation level for images generated by `gpt-image-1`. Must be either `low` or `auto`.
+ */
+export const Moderation = {
+  Low: "low",
+  Auto: "auto",
+} as const;
+/**
+ * Control the content-moderation level for images generated by `gpt-image-1`. Must be either `low` or `auto`.
+ */
+export type Moderation = ClosedEnum<typeof Moderation>;
+
+/**
+ * The format in which the generated images are returned. This parameter is only supported for `openai/gpt-image-1`.
+ */
+export const OutputFormat = {
+  Png: "png",
+  Jpeg: "jpeg",
+  Webp: "webp",
+} as const;
+/**
+ * The format in which the generated images are returned. This parameter is only supported for `openai/gpt-image-1`.
+ */
+export type OutputFormat = ClosedEnum<typeof OutputFormat>;
+
+/**
+ * The quality of the image that will be generated. `auto` will automatically select the best quality for the given model.
+ */
+export const Quality = {
+  Auto: "auto",
+  High: "high",
+  Medium: "medium",
+  Low: "low",
+  Hd: "hd",
+  Standard: "standard",
+} as const;
+/**
+ * The quality of the image that will be generated. `auto` will automatically select the best quality for the given model.
+ */
+export type Quality = ClosedEnum<typeof Quality>;
+
+/**
+ * The format in which generated images are returned. Must be one of `url` or `b64_json`. This parameter isn't supported for `gpt-image-1` which will always return base64-encoded images.
+ */
+export const CreateImageResponseFormat = {
+  Url: "url",
+  B64Json: "b64_json",
+} as const;
+/**
+ * The format in which generated images are returned. Must be one of `url` or `b64_json`. This parameter isn't supported for `gpt-image-1` which will always return base64-encoded images.
+ */
+export type CreateImageResponseFormat = ClosedEnum<
+  typeof CreateImageResponseFormat
+>;
+
+/**
+ * The style of the generated images. This parameter is only supported for `openai/dall-e-3`. Must be one of `vivid` or `natural`.
+ */
+export const Style = {
+  Vivid: "vivid",
+  Natural: "natural",
+} as const;
+/**
+ * The style of the generated images. This parameter is only supported for `openai/dall-e-3`. Must be one of `vivid` or `natural`.
+ */
+export type Style = ClosedEnum<typeof Style>;
+
+/**
+ * Retry configuration for the request
+ */
+export type CreateImageRetry = {
+  /**
+   * Number of retry attempts (1-5)
+   */
+  count?: number | undefined;
+  /**
+   * HTTP status codes that trigger retry logic
+   */
+  onCodes?: Array<number> | undefined;
+};
+
+export type CreateImageFallbacks = {
+  /**
+   * Fallback model identifier
+   */
+  model: string;
+};
+
+export const CreateImageType = {
+  ExactMatch: "exact_match",
+} as const;
+export type CreateImageType = ClosedEnum<typeof CreateImageType>;
+
+/**
+ * Cache configuration for the request.
+ */
+export type CreateImageCache = {
+  /**
+   * Time to live for cached responses in seconds. Maximum 259200 seconds (3 days).
+   */
+  ttl?: number | undefined;
+  type: CreateImageType;
+};
+
+export const CreateImageLoadBalancerType = {
+  WeightBased: "weight_based",
+} as const;
+export type CreateImageLoadBalancerType = ClosedEnum<
+  typeof CreateImageLoadBalancerType
+>;
+
+export type CreateImageLoadBalancer1 = {
+  type: CreateImageLoadBalancerType;
+  /**
+   * Model identifier for load balancing
+   */
+  model: string;
+  /**
+   * Weight assigned to this model for load balancing
+   */
+  weight?: number | undefined;
+};
+
+export type CreateImageLoadBalancer = CreateImageLoadBalancer1;
+
+/**
+ * Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured.
+ */
+export type CreateImageTimeout = {
+  /**
+   * Timeout value in milliseconds
+   */
+  callTimeout: number;
+};
+
+export type CreateImageOrq = {
+  /**
+   * The name to display on the trace. If not specified, the default system name will be used.
+   */
+  name?: string | undefined;
+  /**
+   * Retry configuration for the request
+   */
+  retry?: CreateImageRetry | undefined;
+  /**
+   * Array of fallback models to use if primary model fails
+   */
+  fallbacks?: Array<CreateImageFallbacks> | undefined;
+  /**
+   * Information about the contact making the request. If the contact does not exist, it will be created automatically.
+   */
+  contact?: components.PublicContact | undefined;
+  /**
+   * Cache configuration for the request.
+   */
+  cache?: CreateImageCache | undefined;
+  /**
+   * Array of models with weights for load balancing requests
+   */
+  loadBalancer?: Array<CreateImageLoadBalancer1> | undefined;
+  /**
+   * Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured.
+   */
+  timeout?: CreateImageTimeout | undefined;
+};
+
+/**
+ * input
+ */
+export type CreateImageRequestBody = {
+  /**
+   * A text description of the desired image(s).
+   */
+  prompt: string;
+  /**
+   * Allows to set transparency for the background of the generated image(s). This parameter is only supported for `openai/gpt-image-1`.
+   */
+  background?: Background | null | undefined;
+  /**
+   * The model to use for image generation. One of `openai/dall-e-2`, `openai/dall-e-3`, or `openai/gpt-image-1`.
+   */
+  model: string;
+  /**
+   * Control the content-moderation level for images generated by `gpt-image-1`. Must be either `low` or `auto`.
+   */
+  moderation?: Moderation | null | undefined;
+  /**
+   * The number of images to generate. Must be between 1 and 10. For `dall-e-3`, only `n=1` is supported.
+   */
+  n?: number | null | undefined;
+  /**
+   * The compression level (0-100%) for the generated images. This parameter is only supported for `gpt-image-1` with the `webp` or `jpeg` output formats.
+   */
+  outputCompression?: number | null | undefined;
+  /**
+   * The format in which the generated images are returned. This parameter is only supported for `openai/gpt-image-1`.
+   */
+  outputFormat?: OutputFormat | null | undefined;
+  /**
+   * The quality of the image that will be generated. `auto` will automatically select the best quality for the given model.
+   */
+  quality?: Quality | null | undefined;
+  /**
+   * The format in which generated images are returned. Must be one of `url` or `b64_json`. This parameter isn't supported for `gpt-image-1` which will always return base64-encoded images.
+   */
+  responseFormat?: CreateImageResponseFormat | null | undefined;
+  /**
+   * The size of the generated images. Must be one of the specified sizes for each model.
+   */
+  size?: string | null | undefined;
+  /**
+   * The style of the generated images. This parameter is only supported for `openai/dall-e-3`. Must be one of `vivid` or `natural`.
+   */
+  style?: Style | null | undefined;
+  orq?: CreateImageOrq | undefined;
+};
+
+export type CreateImageData = {
+  /**
+   * The prompt that was used to generate the image, if there was any revision to the prompt.
+   */
+  revisedPrompt?: string | null | undefined;
+  /**
+   * The base64-encoded JSON of the generated image, if `response_format` is `b64_json`
+   */
+  b64Json?: string | undefined;
+  /**
+   * The url of the generated image, if `response_format` is `url` (default)
+   */
+  url?: string | undefined;
+};
+
+export type InputTokensDetails = {
+  imageTokens?: number | undefined;
+  textTokens?: number | undefined;
+};
+
+export type CreateImageUsage = {
+  inputTokens?: number | undefined;
+  inputTokensDetails: InputTokensDetails;
+  outputTokens?: number | undefined;
+  totalTokens?: number | undefined;
+};
+
+/**
+ * Represents an image generation response from the API.
+ */
+export type CreateImageResponseBody = {
+  /**
+   * The Unix timestamp (in seconds) of when the image was created.
+   */
+  created: number;
+  /**
+   * Represents the url or the content of an image generated.
+   */
+  data: Array<CreateImageData>;
+  usage?: CreateImageUsage | undefined;
+};
+
+/** @internal */
+export const Background$inboundSchema: z.ZodNativeEnum<typeof Background> = z
+  .nativeEnum(Background);
+/** @internal */
+export const Background$outboundSchema: z.ZodNativeEnum<typeof Background> =
+  Background$inboundSchema;
+
+/** @internal */
+export const Moderation$inboundSchema: z.ZodNativeEnum<typeof Moderation> = z
+  .nativeEnum(Moderation);
+/** @internal */
+export const Moderation$outboundSchema: z.ZodNativeEnum<typeof Moderation> =
+  Moderation$inboundSchema;
+
+/** @internal */
+export const OutputFormat$inboundSchema: z.ZodNativeEnum<typeof OutputFormat> =
+  z.nativeEnum(OutputFormat);
+/** @internal */
+export const OutputFormat$outboundSchema: z.ZodNativeEnum<typeof OutputFormat> =
+  OutputFormat$inboundSchema;
+
+/** @internal */
+export const Quality$inboundSchema: z.ZodNativeEnum<typeof Quality> = z
+  .nativeEnum(Quality);
+/** @internal */
+export const Quality$outboundSchema: z.ZodNativeEnum<typeof Quality> =
+  Quality$inboundSchema;
+
+/** @internal */
+export const CreateImageResponseFormat$inboundSchema: z.ZodNativeEnum<
+  typeof CreateImageResponseFormat
+> = z.nativeEnum(CreateImageResponseFormat);
+/** @internal */
+export const CreateImageResponseFormat$outboundSchema: z.ZodNativeEnum<
+  typeof CreateImageResponseFormat
+> = CreateImageResponseFormat$inboundSchema;
+
+/** @internal */
+export const Style$inboundSchema: z.ZodNativeEnum<typeof Style> = z.nativeEnum(
+  Style,
+);
+/** @internal */
+export const Style$outboundSchema: z.ZodNativeEnum<typeof Style> =
+  Style$inboundSchema;
+
+/** @internal */
+export const CreateImageRetry$inboundSchema: z.ZodType<
+  CreateImageRetry,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  count: z.number().default(3),
+  on_codes: z.array(z.number()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "on_codes": "onCodes",
+  });
+});
+/** @internal */
+export type CreateImageRetry$Outbound = {
+  count: number;
+  on_codes?: Array<number> | undefined;
+};
+
+/** @internal */
+export const CreateImageRetry$outboundSchema: z.ZodType<
+  CreateImageRetry$Outbound,
+  z.ZodTypeDef,
+  CreateImageRetry
+> = z.object({
+  count: z.number().default(3),
+  onCodes: z.array(z.number()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    onCodes: "on_codes",
+  });
+});
+
+export function createImageRetryToJSON(
+  createImageRetry: CreateImageRetry,
+): string {
+  return JSON.stringify(
+    CreateImageRetry$outboundSchema.parse(createImageRetry),
+  );
+}
+export function createImageRetryFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateImageRetry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateImageRetry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateImageRetry' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateImageFallbacks$inboundSchema: z.ZodType<
+  CreateImageFallbacks,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  model: z.string(),
+});
+/** @internal */
+export type CreateImageFallbacks$Outbound = {
+  model: string;
+};
+
+/** @internal */
+export const CreateImageFallbacks$outboundSchema: z.ZodType<
+  CreateImageFallbacks$Outbound,
+  z.ZodTypeDef,
+  CreateImageFallbacks
+> = z.object({
+  model: z.string(),
+});
+
+export function createImageFallbacksToJSON(
+  createImageFallbacks: CreateImageFallbacks,
+): string {
+  return JSON.stringify(
+    CreateImageFallbacks$outboundSchema.parse(createImageFallbacks),
+  );
+}
+export function createImageFallbacksFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateImageFallbacks, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateImageFallbacks$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateImageFallbacks' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateImageType$inboundSchema: z.ZodNativeEnum<
+  typeof CreateImageType
+> = z.nativeEnum(CreateImageType);
+/** @internal */
+export const CreateImageType$outboundSchema: z.ZodNativeEnum<
+  typeof CreateImageType
+> = CreateImageType$inboundSchema;
+
+/** @internal */
+export const CreateImageCache$inboundSchema: z.ZodType<
+  CreateImageCache,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  ttl: z.number().default(1800),
+  type: CreateImageType$inboundSchema,
+});
+/** @internal */
+export type CreateImageCache$Outbound = {
+  ttl: number;
+  type: string;
+};
+
+/** @internal */
+export const CreateImageCache$outboundSchema: z.ZodType<
+  CreateImageCache$Outbound,
+  z.ZodTypeDef,
+  CreateImageCache
+> = z.object({
+  ttl: z.number().default(1800),
+  type: CreateImageType$outboundSchema,
+});
+
+export function createImageCacheToJSON(
+  createImageCache: CreateImageCache,
+): string {
+  return JSON.stringify(
+    CreateImageCache$outboundSchema.parse(createImageCache),
+  );
+}
+export function createImageCacheFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateImageCache, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateImageCache$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateImageCache' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateImageLoadBalancerType$inboundSchema: z.ZodNativeEnum<
+  typeof CreateImageLoadBalancerType
+> = z.nativeEnum(CreateImageLoadBalancerType);
+/** @internal */
+export const CreateImageLoadBalancerType$outboundSchema: z.ZodNativeEnum<
+  typeof CreateImageLoadBalancerType
+> = CreateImageLoadBalancerType$inboundSchema;
+
+/** @internal */
+export const CreateImageLoadBalancer1$inboundSchema: z.ZodType<
+  CreateImageLoadBalancer1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: CreateImageLoadBalancerType$inboundSchema,
+  model: z.string(),
+  weight: z.number().default(0.5),
+});
+/** @internal */
+export type CreateImageLoadBalancer1$Outbound = {
+  type: string;
+  model: string;
+  weight: number;
+};
+
+/** @internal */
+export const CreateImageLoadBalancer1$outboundSchema: z.ZodType<
+  CreateImageLoadBalancer1$Outbound,
+  z.ZodTypeDef,
+  CreateImageLoadBalancer1
+> = z.object({
+  type: CreateImageLoadBalancerType$outboundSchema,
+  model: z.string(),
+  weight: z.number().default(0.5),
+});
+
+export function createImageLoadBalancer1ToJSON(
+  createImageLoadBalancer1: CreateImageLoadBalancer1,
+): string {
+  return JSON.stringify(
+    CreateImageLoadBalancer1$outboundSchema.parse(createImageLoadBalancer1),
+  );
+}
+export function createImageLoadBalancer1FromJSON(
+  jsonString: string,
+): SafeParseResult<CreateImageLoadBalancer1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateImageLoadBalancer1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateImageLoadBalancer1' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateImageLoadBalancer$inboundSchema: z.ZodType<
+  CreateImageLoadBalancer,
+  z.ZodTypeDef,
+  unknown
+> = z.lazy(() => CreateImageLoadBalancer1$inboundSchema);
+/** @internal */
+export type CreateImageLoadBalancer$Outbound =
+  CreateImageLoadBalancer1$Outbound;
+
+/** @internal */
+export const CreateImageLoadBalancer$outboundSchema: z.ZodType<
+  CreateImageLoadBalancer$Outbound,
+  z.ZodTypeDef,
+  CreateImageLoadBalancer
+> = z.lazy(() => CreateImageLoadBalancer1$outboundSchema);
+
+export function createImageLoadBalancerToJSON(
+  createImageLoadBalancer: CreateImageLoadBalancer,
+): string {
+  return JSON.stringify(
+    CreateImageLoadBalancer$outboundSchema.parse(createImageLoadBalancer),
+  );
+}
+export function createImageLoadBalancerFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateImageLoadBalancer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateImageLoadBalancer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateImageLoadBalancer' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateImageTimeout$inboundSchema: z.ZodType<
+  CreateImageTimeout,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  call_timeout: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    "call_timeout": "callTimeout",
+  });
+});
+/** @internal */
+export type CreateImageTimeout$Outbound = {
+  call_timeout: number;
+};
+
+/** @internal */
+export const CreateImageTimeout$outboundSchema: z.ZodType<
+  CreateImageTimeout$Outbound,
+  z.ZodTypeDef,
+  CreateImageTimeout
+> = z.object({
+  callTimeout: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    callTimeout: "call_timeout",
+  });
+});
+
+export function createImageTimeoutToJSON(
+  createImageTimeout: CreateImageTimeout,
+): string {
+  return JSON.stringify(
+    CreateImageTimeout$outboundSchema.parse(createImageTimeout),
+  );
+}
+export function createImageTimeoutFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateImageTimeout, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateImageTimeout$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateImageTimeout' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateImageOrq$inboundSchema: z.ZodType<
+  CreateImageOrq,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string().optional(),
+  retry: z.lazy(() => CreateImageRetry$inboundSchema).optional(),
+  fallbacks: z.array(z.lazy(() => CreateImageFallbacks$inboundSchema))
+    .optional(),
+  contact: components.PublicContact$inboundSchema.optional(),
+  cache: z.lazy(() => CreateImageCache$inboundSchema).optional(),
+  load_balancer: z.array(z.lazy(() => CreateImageLoadBalancer1$inboundSchema))
+    .optional(),
+  timeout: z.lazy(() => CreateImageTimeout$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "load_balancer": "loadBalancer",
+  });
+});
+/** @internal */
+export type CreateImageOrq$Outbound = {
+  name?: string | undefined;
+  retry?: CreateImageRetry$Outbound | undefined;
+  fallbacks?: Array<CreateImageFallbacks$Outbound> | undefined;
+  contact?: components.PublicContact$Outbound | undefined;
+  cache?: CreateImageCache$Outbound | undefined;
+  load_balancer?: Array<CreateImageLoadBalancer1$Outbound> | undefined;
+  timeout?: CreateImageTimeout$Outbound | undefined;
+};
+
+/** @internal */
+export const CreateImageOrq$outboundSchema: z.ZodType<
+  CreateImageOrq$Outbound,
+  z.ZodTypeDef,
+  CreateImageOrq
+> = z.object({
+  name: z.string().optional(),
+  retry: z.lazy(() => CreateImageRetry$outboundSchema).optional(),
+  fallbacks: z.array(z.lazy(() => CreateImageFallbacks$outboundSchema))
+    .optional(),
+  contact: components.PublicContact$outboundSchema.optional(),
+  cache: z.lazy(() => CreateImageCache$outboundSchema).optional(),
+  loadBalancer: z.array(z.lazy(() => CreateImageLoadBalancer1$outboundSchema))
+    .optional(),
+  timeout: z.lazy(() => CreateImageTimeout$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    loadBalancer: "load_balancer",
+  });
+});
+
+export function createImageOrqToJSON(createImageOrq: CreateImageOrq): string {
+  return JSON.stringify(CreateImageOrq$outboundSchema.parse(createImageOrq));
+}
+export function createImageOrqFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateImageOrq, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateImageOrq$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateImageOrq' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateImageRequestBody$inboundSchema: z.ZodType<
+  CreateImageRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  prompt: z.string(),
+  background: z.nullable(Background$inboundSchema).optional(),
+  model: z.string(),
+  moderation: z.nullable(Moderation$inboundSchema).optional(),
+  n: z.nullable(z.number().int().default(1)),
+  output_compression: z.nullable(z.number().int()).optional(),
+  output_format: z.nullable(OutputFormat$inboundSchema).optional(),
+  quality: z.nullable(Quality$inboundSchema).optional(),
+  response_format: z.nullable(CreateImageResponseFormat$inboundSchema)
+    .optional(),
+  size: z.nullable(z.string()).optional(),
+  style: z.nullable(Style$inboundSchema).optional(),
+  orq: z.lazy(() => CreateImageOrq$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "output_compression": "outputCompression",
+    "output_format": "outputFormat",
+    "response_format": "responseFormat",
+  });
+});
+/** @internal */
+export type CreateImageRequestBody$Outbound = {
+  prompt: string;
+  background?: string | null | undefined;
+  model: string;
+  moderation?: string | null | undefined;
+  n: number | null;
+  output_compression?: number | null | undefined;
+  output_format?: string | null | undefined;
+  quality?: string | null | undefined;
+  response_format?: string | null | undefined;
+  size?: string | null | undefined;
+  style?: string | null | undefined;
+  orq?: CreateImageOrq$Outbound | undefined;
+};
+
+/** @internal */
+export const CreateImageRequestBody$outboundSchema: z.ZodType<
+  CreateImageRequestBody$Outbound,
+  z.ZodTypeDef,
+  CreateImageRequestBody
+> = z.object({
+  prompt: z.string(),
+  background: z.nullable(Background$outboundSchema).optional(),
+  model: z.string(),
+  moderation: z.nullable(Moderation$outboundSchema).optional(),
+  n: z.nullable(z.number().int().default(1)),
+  outputCompression: z.nullable(z.number().int()).optional(),
+  outputFormat: z.nullable(OutputFormat$outboundSchema).optional(),
+  quality: z.nullable(Quality$outboundSchema).optional(),
+  responseFormat: z.nullable(CreateImageResponseFormat$outboundSchema)
+    .optional(),
+  size: z.nullable(z.string()).optional(),
+  style: z.nullable(Style$outboundSchema).optional(),
+  orq: z.lazy(() => CreateImageOrq$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    outputCompression: "output_compression",
+    outputFormat: "output_format",
+    responseFormat: "response_format",
+  });
+});
+
+export function createImageRequestBodyToJSON(
+  createImageRequestBody: CreateImageRequestBody,
+): string {
+  return JSON.stringify(
+    CreateImageRequestBody$outboundSchema.parse(createImageRequestBody),
+  );
+}
+export function createImageRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateImageRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateImageRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateImageRequestBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateImageData$inboundSchema: z.ZodType<
+  CreateImageData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  revised_prompt: z.nullable(z.string()).optional(),
+  b64_json: z.string().optional(),
+  url: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "revised_prompt": "revisedPrompt",
+    "b64_json": "b64Json",
+  });
+});
+/** @internal */
+export type CreateImageData$Outbound = {
+  revised_prompt?: string | null | undefined;
+  b64_json?: string | undefined;
+  url?: string | undefined;
+};
+
+/** @internal */
+export const CreateImageData$outboundSchema: z.ZodType<
+  CreateImageData$Outbound,
+  z.ZodTypeDef,
+  CreateImageData
+> = z.object({
+  revisedPrompt: z.nullable(z.string()).optional(),
+  b64Json: z.string().optional(),
+  url: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    revisedPrompt: "revised_prompt",
+    b64Json: "b64_json",
+  });
+});
+
+export function createImageDataToJSON(
+  createImageData: CreateImageData,
+): string {
+  return JSON.stringify(CreateImageData$outboundSchema.parse(createImageData));
+}
+export function createImageDataFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateImageData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateImageData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateImageData' from JSON`,
+  );
+}
+
+/** @internal */
+export const InputTokensDetails$inboundSchema: z.ZodType<
+  InputTokensDetails,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  image_tokens: z.number().optional(),
+  text_tokens: z.number().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "image_tokens": "imageTokens",
+    "text_tokens": "textTokens",
+  });
+});
+/** @internal */
+export type InputTokensDetails$Outbound = {
+  image_tokens?: number | undefined;
+  text_tokens?: number | undefined;
+};
+
+/** @internal */
+export const InputTokensDetails$outboundSchema: z.ZodType<
+  InputTokensDetails$Outbound,
+  z.ZodTypeDef,
+  InputTokensDetails
+> = z.object({
+  imageTokens: z.number().optional(),
+  textTokens: z.number().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    imageTokens: "image_tokens",
+    textTokens: "text_tokens",
+  });
+});
+
+export function inputTokensDetailsToJSON(
+  inputTokensDetails: InputTokensDetails,
+): string {
+  return JSON.stringify(
+    InputTokensDetails$outboundSchema.parse(inputTokensDetails),
+  );
+}
+export function inputTokensDetailsFromJSON(
+  jsonString: string,
+): SafeParseResult<InputTokensDetails, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => InputTokensDetails$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InputTokensDetails' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateImageUsage$inboundSchema: z.ZodType<
+  CreateImageUsage,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  input_tokens: z.number().optional(),
+  input_tokens_details: z.lazy(() => InputTokensDetails$inboundSchema),
+  output_tokens: z.number().optional(),
+  total_tokens: z.number().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "input_tokens": "inputTokens",
+    "input_tokens_details": "inputTokensDetails",
+    "output_tokens": "outputTokens",
+    "total_tokens": "totalTokens",
+  });
+});
+/** @internal */
+export type CreateImageUsage$Outbound = {
+  input_tokens?: number | undefined;
+  input_tokens_details: InputTokensDetails$Outbound;
+  output_tokens?: number | undefined;
+  total_tokens?: number | undefined;
+};
+
+/** @internal */
+export const CreateImageUsage$outboundSchema: z.ZodType<
+  CreateImageUsage$Outbound,
+  z.ZodTypeDef,
+  CreateImageUsage
+> = z.object({
+  inputTokens: z.number().optional(),
+  inputTokensDetails: z.lazy(() => InputTokensDetails$outboundSchema),
+  outputTokens: z.number().optional(),
+  totalTokens: z.number().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    inputTokens: "input_tokens",
+    inputTokensDetails: "input_tokens_details",
+    outputTokens: "output_tokens",
+    totalTokens: "total_tokens",
+  });
+});
+
+export function createImageUsageToJSON(
+  createImageUsage: CreateImageUsage,
+): string {
+  return JSON.stringify(
+    CreateImageUsage$outboundSchema.parse(createImageUsage),
+  );
+}
+export function createImageUsageFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateImageUsage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateImageUsage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateImageUsage' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateImageResponseBody$inboundSchema: z.ZodType<
+  CreateImageResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  created: z.number(),
+  data: z.array(z.lazy(() => CreateImageData$inboundSchema)),
+  usage: z.lazy(() => CreateImageUsage$inboundSchema).optional(),
+});
+/** @internal */
+export type CreateImageResponseBody$Outbound = {
+  created: number;
+  data: Array<CreateImageData$Outbound>;
+  usage?: CreateImageUsage$Outbound | undefined;
+};
+
+/** @internal */
+export const CreateImageResponseBody$outboundSchema: z.ZodType<
+  CreateImageResponseBody$Outbound,
+  z.ZodTypeDef,
+  CreateImageResponseBody
+> = z.object({
+  created: z.number(),
+  data: z.array(z.lazy(() => CreateImageData$outboundSchema)),
+  usage: z.lazy(() => CreateImageUsage$outboundSchema).optional(),
+});
+
+export function createImageResponseBodyToJSON(
+  createImageResponseBody: CreateImageResponseBody,
+): string {
+  return JSON.stringify(
+    CreateImageResponseBody$outboundSchema.parse(createImageResponseBody),
+  );
+}
+export function createImageResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateImageResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateImageResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateImageResponseBody' from JSON`,
+  );
+}