openai-types 0.1.3

// AUTO-GENERATED by py2rust — do not edit.
// Re-generate: python3 scripts/py2rust.py sync <python_dir> <rust_dir>
// Domain: image
#![allow(unused_imports)]

use serde::{Deserialize, Serialize};
use super::*;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageCreateVariationParamsResponseFormat {
    #[serde(rename = "url")]
    Url,
    #[serde(rename = "b64_json")]
    B64Json,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageCreateVariationParamsSize {
    #[serde(rename = "256x256")]
    V256x256,
    #[serde(rename = "512x512")]
    V512x512,
    #[serde(rename = "1024x1024")]
    V1024x1024,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ImageCreateVariationParams {
    /// The image to use as the basis for the variation(s).
    pub image: serde_json::Value,
    /// The model to use for image generation.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub model: Option<String>,
    /// The number of images to generate. Must be between 1 and 10.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub n: Option<i64>,
    /// The format in which the generated images are returned.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub response_format: Option<ImageCreateVariationParamsResponseFormat>,
    /// The size of the generated images.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub size: Option<ImageCreateVariationParamsSize>,
    /// A unique identifier representing your end-user, which can help OpenAI to monitor
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub user: Option<String>,
}

/// The input tokens detailed information for the image generation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct UsageInputTokensDetails {
    /// The number of image tokens in the input prompt.
    pub image_tokens: i64,
    /// The number of text tokens in the input prompt.
    pub text_tokens: i64,
}

/// For the GPT image models only, the token usage information for the image generation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct Usage {
    /// The number of tokens (images and text) in the input prompt.
    pub input_tokens: i64,
    /// The input tokens detailed information for the image generation.
    pub input_tokens_details: UsageInputTokensDetails,
    /// The number of image tokens in the output image.
    pub output_tokens: i64,
    /// The total number of tokens (images and text) used for the image generation.
    pub total_tokens: i64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageEditCompletedEventBackground {
    #[serde(rename = "transparent")]
    Transparent,
    #[serde(rename = "opaque")]
    Opaque,
    #[serde(rename = "auto")]
    Auto,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageEditCompletedEventOutputFormat {
    #[serde(rename = "png")]
    Png,
    #[serde(rename = "webp")]
    Webp,
    #[serde(rename = "jpeg")]
    Jpeg,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageEditCompletedEventQuality {
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "auto")]
    Auto,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageEditCompletedEventSize {
    #[serde(rename = "1024x1024")]
    V1024x1024,
    #[serde(rename = "1024x1536")]
    V1024x1536,
    #[serde(rename = "1536x1024")]
    V1536x1024,
    #[serde(rename = "auto")]
    Auto,
}

/// Emitted when image editing has completed and the final image is available.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ImageEditCompletedEvent {
    /// Base64-encoded final edited image data, suitable for rendering as an image.
    pub b64_json: String,
    /// The background setting for the edited image.
    pub background: ImageEditCompletedEventBackground,
    /// The Unix timestamp when the event was created.
    pub created_at: i64,
    /// The output format for the edited image.
    pub output_format: ImageEditCompletedEventOutputFormat,
    /// The quality setting for the edited image.
    pub quality: ImageEditCompletedEventQuality,
    /// The size of the edited image.
    pub size: ImageEditCompletedEventSize,
    /// The type of the event. Always `image_edit.completed`.
    #[serde(rename = "type")]
    pub type_: String,
    /// For the GPT image models only, the token usage information for the image
    pub usage: Usage,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageEditParamsBaseBackground {
    #[serde(rename = "transparent")]
    Transparent,
    #[serde(rename = "opaque")]
    Opaque,
    #[serde(rename = "auto")]
    Auto,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageEditParamsBaseInputFidelity {
    #[serde(rename = "high")]
    High,
    #[serde(rename = "low")]
    Low,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageEditParamsBaseOutputFormat {
    #[serde(rename = "png")]
    Png,
    #[serde(rename = "jpeg")]
    Jpeg,
    #[serde(rename = "webp")]
    Webp,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageEditParamsBaseQuality {
    #[serde(rename = "standard")]
    Standard,
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "auto")]
    Auto,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageEditParamsBaseResponseFormat {
    #[serde(rename = "url")]
    Url,
    #[serde(rename = "b64_json")]
    B64Json,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageEditParamsBaseSize {
    #[serde(rename = "256x256")]
    V256x256,
    #[serde(rename = "512x512")]
    V512x512,
    #[serde(rename = "1024x1024")]
    V1024x1024,
    #[serde(rename = "1536x1024")]
    V1536x1024,
    #[serde(rename = "1024x1536")]
    V1024x1536,
    #[serde(rename = "auto")]
    Auto,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ImageEditParamsBase {
    /// The image(s) to edit. Must be a supported image file or an array of images.
    pub image: serde_json::Value,
    /// A text description of the desired image(s).
    pub prompt: String,
    /// Allows to set transparency for the background of the generated image(s). This
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub background: Option<ImageEditParamsBaseBackground>,
    /// Control how much effort the model will exert to match the style and features,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub input_fidelity: Option<ImageEditParamsBaseInputFidelity>,
    /// An additional image whose fully transparent areas (e.g.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub mask: Option<serde_json::Value>,
    /// The model to use for image generation. Defaults to `gpt-image-1.5`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub model: Option<String>,
    /// The number of images to generate. Must be between 1 and 10.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub n: Option<i64>,
    /// The compression level (0-100%) for the generated images.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output_compression: Option<i64>,
    /// The format in which the generated images are returned.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output_format: Option<ImageEditParamsBaseOutputFormat>,
    /// The number of partial images to generate.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub partial_images: Option<i64>,
    /// The quality of the image that will be generated for GPT image models.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub quality: Option<ImageEditParamsBaseQuality>,
    /// The format in which the generated images are returned.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub response_format: Option<ImageEditParamsBaseResponseFormat>,
    /// The size of the generated images.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub size: Option<ImageEditParamsBaseSize>,
    /// A unique identifier representing your end-user, which can help OpenAI to monitor
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub user: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageEditPartialImageEventBackground {
    #[serde(rename = "transparent")]
    Transparent,
    #[serde(rename = "opaque")]
    Opaque,
    #[serde(rename = "auto")]
    Auto,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageEditPartialImageEventOutputFormat {
    #[serde(rename = "png")]
    Png,
    #[serde(rename = "webp")]
    Webp,
    #[serde(rename = "jpeg")]
    Jpeg,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageEditPartialImageEventQuality {
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "auto")]
    Auto,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageEditPartialImageEventSize {
    #[serde(rename = "1024x1024")]
    V1024x1024,
    #[serde(rename = "1024x1536")]
    V1024x1536,
    #[serde(rename = "1536x1024")]
    V1536x1024,
    #[serde(rename = "auto")]
    Auto,
}

/// Emitted when a partial image is available during image editing streaming.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ImageEditPartialImageEvent {
    /// Base64-encoded partial image data, suitable for rendering as an image.
    pub b64_json: String,
    /// The background setting for the requested edited image.
    pub background: ImageEditPartialImageEventBackground,
    /// The Unix timestamp when the event was created.
    pub created_at: i64,
    /// The output format for the requested edited image.
    pub output_format: ImageEditPartialImageEventOutputFormat,
    /// 0-based index for the partial image (streaming).
    pub partial_image_index: i64,
    /// The quality setting for the requested edited image.
    pub quality: ImageEditPartialImageEventQuality,
    /// The size of the requested edited image.
    pub size: ImageEditPartialImageEventSize,
    /// The type of the event. Always `image_edit.partial_image`.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type ImageEditStreamEvent = serde_json::Value;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenCompletedEventBackground {
    #[serde(rename = "transparent")]
    Transparent,
    #[serde(rename = "opaque")]
    Opaque,
    #[serde(rename = "auto")]
    Auto,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenCompletedEventOutputFormat {
    #[serde(rename = "png")]
    Png,
    #[serde(rename = "webp")]
    Webp,
    #[serde(rename = "jpeg")]
    Jpeg,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenCompletedEventQuality {
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "auto")]
    Auto,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenCompletedEventSize {
    #[serde(rename = "1024x1024")]
    V1024x1024,
    #[serde(rename = "1024x1536")]
    V1024x1536,
    #[serde(rename = "1536x1024")]
    V1536x1024,
    #[serde(rename = "auto")]
    Auto,
}

/// Emitted when image generation has completed and the final image is available.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ImageGenCompletedEvent {
    /// Base64-encoded image data, suitable for rendering as an image.
    pub b64_json: String,
    /// The background setting for the generated image.
    pub background: ImageGenCompletedEventBackground,
    /// The Unix timestamp when the event was created.
    pub created_at: i64,
    /// The output format for the generated image.
    pub output_format: ImageGenCompletedEventOutputFormat,
    /// The quality setting for the generated image.
    pub quality: ImageGenCompletedEventQuality,
    /// The size of the generated image.
    pub size: ImageGenCompletedEventSize,
    /// The type of the event. Always `image_generation.completed`.
    #[serde(rename = "type")]
    pub type_: String,
    /// For the GPT image models only, the token usage information for the image
    pub usage: Usage,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenPartialImageEventBackground {
    #[serde(rename = "transparent")]
    Transparent,
    #[serde(rename = "opaque")]
    Opaque,
    #[serde(rename = "auto")]
    Auto,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenPartialImageEventOutputFormat {
    #[serde(rename = "png")]
    Png,
    #[serde(rename = "webp")]
    Webp,
    #[serde(rename = "jpeg")]
    Jpeg,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenPartialImageEventQuality {
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "auto")]
    Auto,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenPartialImageEventSize {
    #[serde(rename = "1024x1024")]
    V1024x1024,
    #[serde(rename = "1024x1536")]
    V1024x1536,
    #[serde(rename = "1536x1024")]
    V1536x1024,
    #[serde(rename = "auto")]
    Auto,
}

/// Emitted when a partial image is available during image generation streaming.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ImageGenPartialImageEvent {
    /// Base64-encoded partial image data, suitable for rendering as an image.
    pub b64_json: String,
    /// The background setting for the requested image.
    pub background: ImageGenPartialImageEventBackground,
    /// The Unix timestamp when the event was created.
    pub created_at: i64,
    /// The output format for the requested image.
    pub output_format: ImageGenPartialImageEventOutputFormat,
    /// 0-based index for the partial image (streaming).
    pub partial_image_index: i64,
    /// The quality setting for the requested image.
    pub quality: ImageGenPartialImageEventQuality,
    /// The size of the requested image.
    pub size: ImageGenPartialImageEventSize,
    /// The type of the event. Always `image_generation.partial_image`.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type ImageGenStreamEvent = serde_json::Value;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenerateParamsBaseBackground {
    #[serde(rename = "transparent")]
    Transparent,
    #[serde(rename = "opaque")]
    Opaque,
    #[serde(rename = "auto")]
    Auto,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenerateParamsBaseModeration {
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "auto")]
    Auto,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenerateParamsBaseOutputFormat {
    #[serde(rename = "png")]
    Png,
    #[serde(rename = "jpeg")]
    Jpeg,
    #[serde(rename = "webp")]
    Webp,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenerateParamsBaseQuality {
    #[serde(rename = "standard")]
    Standard,
    #[serde(rename = "hd")]
    Hd,
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "auto")]
    Auto,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenerateParamsBaseResponseFormat {
    #[serde(rename = "url")]
    Url,
    #[serde(rename = "b64_json")]
    B64Json,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenerateParamsBaseSize {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "1024x1024")]
    V1024x1024,
    #[serde(rename = "1536x1024")]
    V1536x1024,
    #[serde(rename = "1024x1536")]
    V1024x1536,
    #[serde(rename = "256x256")]
    V256x256,
    #[serde(rename = "512x512")]
    V512x512,
    #[serde(rename = "1792x1024")]
    V1792x1024,
    #[serde(rename = "1024x1792")]
    V1024x1792,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenerateParamsBaseStyle {
    #[serde(rename = "vivid")]
    Vivid,
    #[serde(rename = "natural")]
    Natural,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ImageGenerateParamsBase {
    /// A text description of the desired image(s).
    pub prompt: String,
    /// Allows to set transparency for the background of the generated image(s). This
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub background: Option<ImageGenerateParamsBaseBackground>,
    /// The model to use for image generation.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub model: Option<String>,
    /// Control the content-moderation level for images generated by the GPT image
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub moderation: Option<ImageGenerateParamsBaseModeration>,
    /// The number of images to generate.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub n: Option<i64>,
    /// The compression level (0-100%) for the generated images.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output_compression: Option<i64>,
    /// The format in which the generated images are returned.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output_format: Option<ImageGenerateParamsBaseOutputFormat>,
    /// The number of partial images to generate.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub partial_images: Option<i64>,
    /// The quality of the image that will be generated.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub quality: Option<ImageGenerateParamsBaseQuality>,
    /// The format in which generated images with `dall-e-2` and `dall-e-3` are
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub response_format: Option<ImageGenerateParamsBaseResponseFormat>,
    /// The size of the generated images.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub size: Option<ImageGenerateParamsBaseSize>,
    /// The style of the generated images.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub style: Option<ImageGenerateParamsBaseStyle>,
    /// A unique identifier representing your end-user, which can help OpenAI to monitor
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub user: Option<String>,
}

pub type ImageGenerateParams = serde_json::Value;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageModel {
    #[serde(rename = "gpt-image-1.5")]
    GptImage15,
    #[serde(rename = "dall-e-2")]
    DallE2,
    #[serde(rename = "dall-e-3")]
    DallE3,
    #[serde(rename = "gpt-image-1")]
    GptImage1,
    #[serde(rename = "gpt-image-1-mini")]
    GptImage1Mini,
}

/// The output token details for the image generation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct UsageOutputTokensDetails {
    /// The number of image output tokens generated by the model.
    pub image_tokens: i64,
    /// The number of text output tokens generated by the model.
    pub text_tokens: i64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImagesResponseBackground {
    #[serde(rename = "transparent")]
    Transparent,
    #[serde(rename = "opaque")]
    Opaque,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImagesResponseOutputFormat {
    #[serde(rename = "png")]
    Png,
    #[serde(rename = "webp")]
    Webp,
    #[serde(rename = "jpeg")]
    Jpeg,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImagesResponseQuality {
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImagesResponseSize {
    #[serde(rename = "1024x1024")]
    V1024x1024,
    #[serde(rename = "1024x1536")]
    V1024x1536,
    #[serde(rename = "1536x1024")]
    V1536x1024,
}