1use crate::shared::FileUpload;
2use derive_builder::Builder;
3use serde::{Deserialize, Serialize};
4use std::collections::HashMap;
5use std::fmt::Display;
6
7#[derive(Serialize, Deserialize, Debug, Default, Builder, Clone, PartialEq)]
8#[builder(name = "CreateImageParametersBuilder")]
9#[builder(setter(into, strip_option), default)]
10pub struct CreateImageParameters {
11 pub prompt: String,
13 #[serde(skip_serializing_if = "Option::is_none")]
17 pub background: Option<BackgroundStyle>,
18 #[serde(skip_serializing_if = "Option::is_none")]
20 pub model: Option<String>,
21 #[serde(skip_serializing_if = "Option::is_none")]
23 pub moderation: Option<ModerationLevel>,
24 #[serde(skip_serializing_if = "Option::is_none")]
26 pub n: Option<u32>,
27 #[serde(skip_serializing_if = "Option::is_none")]
29 pub output_compression: Option<u32>,
30 #[serde(skip_serializing_if = "Option::is_none")]
32 pub output_format: Option<OutputFormat>,
33 #[serde(skip_serializing_if = "Option::is_none")]
36 pub partial_images: Option<u32>,
37 #[serde(skip_serializing_if = "Option::is_none")]
40 pub quality: Option<ImageQuality>,
41 #[serde(skip_serializing_if = "Option::is_none")]
43 pub response_format: Option<ResponseFormat>,
44 #[serde(skip_serializing_if = "Option::is_none")]
47 pub size: Option<ImageSize>,
48 #[serde(skip_serializing_if = "Option::is_none")]
50 pub stream: Option<bool>,
51 #[serde(skip_serializing_if = "Option::is_none")]
55 pub style: Option<ImageStyle>,
56 #[serde(skip_serializing_if = "Option::is_none")]
58 pub safety_identifier: Option<String>,
59 #[serde(skip_serializing_if = "Option::is_none")]
61 pub prompt_cache_key: Option<String>,
62 #[serde(skip_serializing_if = "Option::is_none")]
64 pub user: Option<String>,
65 pub ext: Option<HashMap<String, serde_json::Value>>,
67}
68
69#[derive(Serialize, Deserialize, Debug, Default, Builder, Clone, PartialEq)]
70#[builder(name = "EditImageParametersBuilder")]
71#[builder(setter(into, strip_option), default)]
72pub struct EditImageParameters {
73 pub image: String,
75 pub prompt: Option<String>,
77 #[serde(skip_serializing_if = "Option::is_none")]
81 pub background: Option<BackgroundStyle>,
82 #[serde(skip_serializing_if = "Option::is_none")]
85 pub input_fidelity: Option<InputFidelity>,
86 #[serde(skip_serializing_if = "Option::is_none")]
90 pub mask: Option<FileUpload>,
91 #[serde(skip_serializing_if = "Option::is_none")]
94 pub mime_type: Option<MimeType>,
95 #[serde(skip_serializing_if = "Option::is_none")]
97 pub model: Option<String>,
98 #[serde(skip_serializing_if = "Option::is_none")]
100 pub n: Option<u32>,
101 #[serde(skip_serializing_if = "Option::is_none")]
103 pub output_compression: Option<u32>,
104 #[serde(skip_serializing_if = "Option::is_none")]
106 pub output_format: Option<OutputFormat>,
107 #[serde(skip_serializing_if = "Option::is_none")]
111 pub partial_images: Option<u32>,
112 #[serde(skip_serializing_if = "Option::is_none")]
115 pub quality: Option<ImageQuality>,
116 #[serde(skip_serializing_if = "Option::is_none")]
118 pub response_format: Option<ResponseFormat>,
119 #[serde(skip_serializing_if = "Option::is_none")]
122 pub size: Option<ImageSize>,
123 #[serde(skip_serializing_if = "Option::is_none")]
125 pub stream: Option<bool>,
126 #[serde(skip_serializing_if = "Option::is_none")]
128 pub user: Option<String>,
129}
130
131#[derive(Serialize, Deserialize, Debug, Default, Builder, Clone, PartialEq)]
132#[builder(name = "CreateImageVariationParametersBuilder")]
133#[builder(setter(into, strip_option), default)]
134pub struct CreateImageVariationParameters {
135 pub image: FileUpload,
137 #[serde(skip_serializing_if = "Option::is_none")]
139 pub model: Option<String>,
140 #[serde(skip_serializing_if = "Option::is_none")]
142 pub n: Option<u32>,
143 #[serde(skip_serializing_if = "Option::is_none")]
145 pub response_format: Option<ResponseFormat>,
146 #[serde(skip_serializing_if = "Option::is_none")]
149 pub size: Option<ImageSize>,
150 #[serde(skip_serializing_if = "Option::is_none")]
152 pub user: Option<String>,
153}
154
155#[derive(Default, Serialize, Deserialize, Debug, Clone, PartialEq)]
156pub struct ImageResponse {
157 #[serde(skip_serializing_if = "Option::is_none")]
159 pub background: Option<BackgroundStyle>,
160 #[serde(skip_serializing_if = "Option::is_none")]
162 pub created: Option<u32>,
163 pub data: Vec<ImageData>,
165 #[serde(skip_serializing_if = "Option::is_none")]
167 pub output_format: Option<OutputFormat>,
168 #[serde(skip_serializing_if = "Option::is_none")]
170 pub quality: Option<ImageQuality>,
171 #[serde(skip_serializing_if = "Option::is_none")]
173 pub size: Option<ImageSizeResponse>,
174 #[serde(skip_serializing_if = "Option::is_none")]
176 pub usage: Option<ImageUsage>,
177}
178
179#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
180pub enum ImageSize {
181 #[serde(rename = "256x256")]
182 Size256X256,
183 #[serde(rename = "512x512")]
184 Size512X512,
185 #[serde(rename = "1024x1024")]
186 Size1024X1024,
187 #[serde(rename = "1024x1536")]
188 Size1024X1536,
189 #[serde(rename = "1536x1024")]
190 Size1536X1024,
191 #[serde(rename = "1792x1024")]
192 Size1792X1024,
193 #[serde(rename = "1024x1792")]
194 Size1024X1792,
195 #[serde(rename = "auto")]
196 Auto,
197}
198
199#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
200pub enum ImageSizeResponse {
201 #[serde(rename = "256x256")]
202 Size256X256,
203 #[serde(rename = "512x512")]
204 Size512X512,
205 #[serde(rename = "1024x1024")]
206 Size1024X1024,
207 #[serde(rename = "1024x1536")]
208 Size1024X1536,
209 #[serde(rename = "1536x1024")]
210 Size1536X1024,
211 #[serde(rename = "1792x1024")]
212 Size1792X1024,
213 #[serde(rename = "1024x1792")]
214 Size1024X1792,
215}
216
217#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
218#[serde(rename_all = "snake_case")]
219pub enum BackgroundStyle {
220 Transparent,
221 Opaque,
222 Auto,
223}
224
225#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
226#[serde(rename_all = "snake_case")]
227pub enum ImageQuality {
228 Standard,
229 Hd,
230 High,
231 Medium,
232 Low,
233 Auto,
234}
235
236#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
237#[serde(rename_all = "snake_case")]
238pub enum MimeType {
239 #[serde(rename = "image/png")]
240 Png,
241 #[serde(rename = "image/jpeg")]
242 Jpeg,
243 #[serde(rename = "image/webp")]
244 Webp,
245 #[serde(rename = "application/octet-stream")]
246 OctetStream,
247}
248
249#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
250#[serde(rename_all = "snake_case")]
251pub enum ImageStyle {
252 Vivid,
253 Natural,
254}
255
256#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
257#[serde(rename_all = "snake_case")]
258pub enum ModerationLevel {
259 Auto,
260 Low,
261}
262
263#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
264#[serde(rename_all = "snake_case")]
265pub enum OutputFormat {
266 Png,
267 Jpeg,
268 Webp,
269}
270
271#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
272#[serde(rename_all = "snake_case")]
273pub enum InputFidelity {
274 High,
275 Low,
276}
277
278#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
279#[serde(rename_all = "snake_case")]
280pub enum ResponseFormat {
281 Url,
282 B64Json,
283}
284
285#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
286pub struct ImageUsage {
287 #[serde(default = "zero")]
289 pub input_tokens: u32,
290 pub input_tokens_details: Option<InputTokensDetails>,
292 #[serde(default = "zero")]
294 pub output_tokens: u32,
295 #[serde(default = "zero")]
297 pub total_tokens: u32,
298}
299fn zero() -> u32 {
300 0
301}
302
303#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
304pub struct InputTokensDetails {
305 pub image_tokens: u32,
307 pub text_tokens: u32,
309}
310
311#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
312#[serde(untagged)]
313pub enum ImageData {
314 Url {
315 url: String,
316 #[serde(skip_serializing_if = "Option::is_none")]
317 revised_prompt: Option<String>,
318 },
319 B64Json {
320 b64_json: String,
321 #[serde(skip_serializing_if = "Option::is_none")]
322 revised_prompt: Option<String>,
323 },
324}
325
326impl Display for InputFidelity {
327 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
328 write!(
329 f,
330 "{}",
331 match self {
332 InputFidelity::High => "high",
333 InputFidelity::Low => "low",
334 }
335 )
336 }
337}
338
339impl Display for OutputFormat {
340 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
341 write!(
342 f,
343 "{}",
344 match self {
345 OutputFormat::Png => "png",
346 OutputFormat::Jpeg => "jpeg",
347 OutputFormat::Webp => "webp",
348 }
349 )
350 }
351}
352
353impl Display for BackgroundStyle {
354 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
355 write!(
356 f,
357 "{}",
358 match self {
359 BackgroundStyle::Transparent => "transparent",
360 BackgroundStyle::Opaque => "opaque",
361 BackgroundStyle::Auto => "auto",
362 }
363 )
364 }
365}
366
367impl Display for ImageQuality {
368 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
369 write!(
370 f,
371 "{}",
372 match self {
373 ImageQuality::Standard => "standard",
374 ImageQuality::Hd => "hd",
375 ImageQuality::High => "high",
376 ImageQuality::Medium => "medium",
377 ImageQuality::Low => "low",
378 ImageQuality::Auto => "auto",
379 }
380 )
381 }
382}
383
384impl Display for ImageSize {
385 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
386 write!(
387 f,
388 "{}",
389 match self {
390 ImageSize::Size256X256 => "256x256",
391 ImageSize::Size512X512 => "512x512",
392 ImageSize::Size1024X1024 => "1024x1024",
393 ImageSize::Size1536X1024 => "1536x1024",
394 ImageSize::Size1024X1536 => "1024x1536",
395 ImageSize::Size1792X1024 => "1792x1024",
396 ImageSize::Size1024X1792 => "1024x1792",
397 ImageSize::Auto => "auto",
398 }
399 )
400 }
401}
402
403impl Display for MimeType {
404 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
405 write!(
406 f,
407 "{}",
408 match self {
409 MimeType::Png => "image/png",
410 MimeType::Jpeg => "image/jpeg",
411 MimeType::Webp => "image/webp",
412 MimeType::OctetStream => "application/octet-stream",
413 }
414 )
415 }
416}
417
418impl Display for ResponseFormat {
419 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
420 write!(
421 f,
422 "{}",
423 match self {
424 ResponseFormat::Url => "url",
425 ResponseFormat::B64Json => "b64_json",
426 }
427 )
428 }
429}