skailar 0.0.1

Official Rust SDK for the Skailar API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

//! Image generation request and response types.

use serde::{Deserialize, Serialize};

use crate::types::chat::BuildError;

/// A request to [`generate`](crate::resources::images::Images::generate)
/// images.
///
/// Construct with [`ImageGenerationRequest::builder`].
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ImageGenerationRequest {
    /// Image model identifier (e.g. `"gpt-image-1"`).
    pub model: String,
    /// Text prompt describing the desired image.
    pub prompt: String,
    /// Number of images to generate (1–10).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub n: Option<u32>,
    /// Output size, e.g. `"1024x1024"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub size: Option<String>,
    /// Provider-specific quality (e.g. `"standard"`, `"hd"`).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub quality: Option<String>,
    /// Provider-specific background (e.g. `"transparent"`).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub background: Option<String>,
}

impl ImageGenerationRequest {
    /// Starts a builder for an image generation request.
    pub fn builder() -> ImageGenerationRequestBuilder {
        ImageGenerationRequestBuilder::default()
    }
}

/// Builder for [`ImageGenerationRequest`].
///
/// `model` and `prompt` are required.
#[derive(Debug, Clone, Default)]
pub struct ImageGenerationRequestBuilder {
    model: Option<String>,
    prompt: Option<String>,
    n: Option<u32>,
    size: Option<String>,
    quality: Option<String>,
    background: Option<String>,
}

impl ImageGenerationRequestBuilder {
    /// Sets the image model.
    pub fn model(mut self, model: impl Into<String>) -> Self {
        self.model = Some(model.into());
        self
    }

    /// Sets the prompt.
    pub fn prompt(mut self, prompt: impl Into<String>) -> Self {
        self.prompt = Some(prompt.into());
        self
    }

    /// Sets the number of images to generate.
    pub fn n(mut self, n: u32) -> Self {
        self.n = Some(n);
        self
    }

    /// Sets the output size.
    pub fn size(mut self, size: impl Into<String>) -> Self {
        self.size = Some(size.into());
        self
    }

    /// Sets the quality.
    pub fn quality(mut self, quality: impl Into<String>) -> Self {
        self.quality = Some(quality.into());
        self
    }

    /// Sets the background.
    pub fn background(mut self, background: impl Into<String>) -> Self {
        self.background = Some(background.into());
        self
    }

    /// Finalizes the request.
    ///
    /// # Errors
    ///
    /// Returns [`BuildError::MissingModel`] or [`BuildError::MissingPrompt`] if
    /// the respective field was not set.
    pub fn build(self) -> Result<ImageGenerationRequest, BuildError> {
        let model = self.model.ok_or(BuildError::MissingModel)?;
        let prompt = self.prompt.ok_or(BuildError::MissingPrompt)?;
        Ok(ImageGenerationRequest {
            model,
            prompt,
            n: self.n,
            size: self.size,
            quality: self.quality,
            background: self.background,
        })
    }
}

/// The response from `POST /v1/images/generations`.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ImageGenerationResponse {
    /// Unix epoch seconds at creation.
    pub created: u64,
    /// One entry per generated image.
    pub data: Vec<GeneratedImage>,
}

/// A single generated image.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GeneratedImage {
    /// URL to the generated image, when the provider returns a hosted asset.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    /// Base64-encoded image bytes, when the provider inlines the result.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub b64_json: Option<String>,
    /// Prompt as rewritten by the provider, when applicable.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub revised_prompt: Option<String>,
}