1use crate::connection::{HttpBody, MultipartPart};
6use crate::{Rest, WireRequest, WireResponse};
7use serde::{Deserialize, Serialize};
8fn optional<'de, D, T>(d: D) -> Result<Option<T>, D::Error>
9where
10 D: serde::Deserializer<'de>,
11 T: Deserialize<'de>,
12{
13 T::deserialize(d).map(Some)
14}
15fn nullable<'de, D, T>(d: D) -> Result<Option<Option<T>>, D::Error>
16where
17 D: serde::Deserializer<'de>,
18 T: Deserialize<'de>,
19{
20 Option::<T>::deserialize(d).map(Some)
21}
22
23#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
24#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
25#[derive(gproxy_protocol_macros::DeclaredFields)]
26#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
27pub enum ImageBackground {
28 #[serde(rename = "transparent")]
29 Transparent,
30 #[serde(rename = "opaque")]
31 Opaque,
32 #[serde(rename = "auto")]
33 Auto,
34}
35
36#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
37#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
38#[derive(gproxy_protocol_macros::DeclaredFields)]
39#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
40pub enum ImageModeration {
41 #[serde(rename = "low")]
42 Low,
43 #[serde(rename = "auto")]
44 Auto,
45}
46
47#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
48#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
49#[derive(gproxy_protocol_macros::DeclaredFields)]
50#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
51pub enum ImageOutputFormat {
52 #[serde(rename = "png")]
53 Png,
54 #[serde(rename = "jpeg")]
55 Jpeg,
56 #[serde(rename = "webp")]
57 Webp,
58}
59
60#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
61#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
62#[derive(gproxy_protocol_macros::DeclaredFields)]
63#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
64pub enum ImageQuality {
65 #[serde(rename = "standard")]
66 Standard,
67 #[serde(rename = "hd")]
68 Hd,
69 #[serde(rename = "low")]
70 Low,
71 #[serde(rename = "medium")]
72 Medium,
73 #[serde(rename = "high")]
74 High,
75 #[serde(rename = "auto")]
76 Auto,
77 #[serde(rename = "xhigh")]
78 Xhigh,
79 #[serde(rename = "max")]
80 Max,
81}
82
83#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
84#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
85#[derive(gproxy_protocol_macros::DeclaredFields)]
86#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
87pub enum ImageResponseFormat {
88 #[serde(rename = "url")]
89 Url,
90 #[serde(rename = "b64_json")]
91 B64Json,
92}
93
94#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
95#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
96#[derive(gproxy_protocol_macros::DeclaredFields)]
97#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
98pub enum ImageStyle {
99 #[serde(rename = "vivid")]
100 Vivid,
101 #[serde(rename = "natural")]
102 Natural,
103}
104
105#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
106#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
107#[derive(gproxy_protocol_macros::DeclaredFields)]
108#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
109pub enum InputFidelity {
110 #[serde(rename = "high")]
111 High,
112 #[serde(rename = "low")]
113 Low,
114}
115
116#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
117#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
118#[derive(gproxy_protocol_macros::DeclaredFields)]
119#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
120pub enum EditedImageQuality {
121 #[serde(rename = "low")]
122 Low,
123 #[serde(rename = "medium")]
124 Medium,
125 #[serde(rename = "high")]
126 High,
127 #[serde(rename = "auto")]
128 Auto,
129 #[serde(rename = "xhigh")]
130 Xhigh,
131 #[serde(rename = "max")]
132 Max,
133}
134
135#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
136#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
137#[derive(gproxy_protocol_macros::DeclaredFields)]
138#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
139pub enum EditedImageSize {
140 #[serde(rename = "auto")]
141 Auto,
142 #[serde(rename = "1024x1024")]
143 Square,
144 #[serde(rename = "1536x1024")]
145 Landscape,
146 #[serde(rename = "1024x1536")]
147 Portrait,
148 #[serde(untagged)]
149 Custom(String),
150}
151
152#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
153#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
154#[derive(gproxy_protocol_macros::DeclaredFields)]
155#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
156pub enum OutputImageBackground {
157 #[serde(rename = "transparent")]
158 Transparent,
159 #[serde(rename = "opaque")]
160 Opaque,
161}
162
163#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
164#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
165#[derive(gproxy_protocol_macros::DeclaredFields)]
166#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
167pub enum OutputImageQuality {
168 #[serde(rename = "low")]
169 Low,
170 #[serde(rename = "medium")]
171 Medium,
172 #[serde(rename = "high")]
173 High,
174 #[serde(rename = "xhigh")]
175 Xhigh,
176 #[serde(rename = "max")]
177 Max,
178}
179
180#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
181#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
182#[derive(gproxy_protocol_macros::DeclaredFields)]
183#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
184pub enum OutputImageSize {
185 #[serde(rename = "1024x1024")]
186 Square,
187 #[serde(rename = "1024x1536")]
188 Portrait,
189 #[serde(rename = "1536x1024")]
190 Landscape,
191 #[serde(untagged)]
192 Custom(String),
193}
194
195#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
196#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
197#[derive(gproxy_protocol_macros::DeclaredFields)]
198#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
199pub enum MultipartImageQuality {
200 #[serde(rename = "standard")]
201 Standard,
202 #[serde(rename = "low")]
203 Low,
204 #[serde(rename = "medium")]
205 Medium,
206 #[serde(rename = "high")]
207 High,
208 #[serde(rename = "xhigh")]
209 Xhigh,
210 #[serde(rename = "max")]
211 Max,
212 #[serde(rename = "auto")]
213 Auto,
214}
215
216#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
217#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
218#[derive(gproxy_protocol_macros::DeclaredFields)]
219#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
220pub enum StreamImageQuality {
221 #[serde(rename = "low")]
222 Low,
223 #[serde(rename = "medium")]
224 Medium,
225 #[serde(rename = "high")]
226 High,
227 #[serde(rename = "xhigh")]
228 Xhigh,
229 #[serde(rename = "max")]
230 Max,
231 #[serde(rename = "auto")]
232 Auto,
233}
234
235#[derive(
236 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
237)]
238#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
239#[derive(gproxy_protocol_macros::DeclaredFields)]
240#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
241pub struct CreateImageRequestBody {
242 pub prompt: String,
243 #[serde(
244 default,
245 deserialize_with = "nullable",
246 skip_serializing_if = "Option::is_none"
247 )]
248 pub background: Option<Option<ImageBackground>>,
249 #[serde(
250 default,
251 deserialize_with = "nullable",
252 skip_serializing_if = "Option::is_none"
253 )]
254 pub model: Option<Option<String>>,
255 #[serde(
256 default,
257 deserialize_with = "nullable",
258 skip_serializing_if = "Option::is_none"
259 )]
260 pub moderation: Option<Option<ImageModeration>>,
261 #[serde(
262 default,
263 deserialize_with = "nullable",
264 skip_serializing_if = "Option::is_none"
265 )]
266 pub n: Option<Option<i64>>,
267 #[serde(
268 default,
269 deserialize_with = "nullable",
270 skip_serializing_if = "Option::is_none"
271 )]
272 pub output_compression: Option<Option<i64>>,
273 #[serde(
274 default,
275 deserialize_with = "nullable",
276 skip_serializing_if = "Option::is_none"
277 )]
278 pub output_format: Option<Option<ImageOutputFormat>>,
279 #[serde(
280 default,
281 deserialize_with = "nullable",
282 skip_serializing_if = "Option::is_none"
283 )]
284 pub partial_images: Option<Option<i64>>,
285 #[serde(
286 default,
287 deserialize_with = "nullable",
288 skip_serializing_if = "Option::is_none"
289 )]
290 pub quality: Option<Option<ImageQuality>>,
291 #[serde(
292 default,
293 deserialize_with = "nullable",
294 skip_serializing_if = "Option::is_none"
295 )]
296 pub response_format: Option<Option<ImageResponseFormat>>,
297 #[serde(
298 default,
299 deserialize_with = "nullable",
300 skip_serializing_if = "Option::is_none"
301 )]
302 pub size: Option<Option<String>>,
303 #[serde(
304 default,
305 deserialize_with = "nullable",
306 skip_serializing_if = "Option::is_none"
307 )]
308 pub stream: Option<Option<bool>>,
309 #[serde(
310 default,
311 deserialize_with = "nullable",
312 skip_serializing_if = "Option::is_none"
313 )]
314 pub style: Option<Option<ImageStyle>>,
315 #[serde(
316 default,
317 deserialize_with = "optional",
318 skip_serializing_if = "Option::is_none"
319 )]
320 pub user: Option<String>,
321 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
322 pub rest: Rest,
323}
324
325#[derive(
326 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
327)]
328#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
329#[derive(gproxy_protocol_macros::DeclaredFields)]
330#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
331pub struct ImageReference {
332 #[serde(
333 default,
334 deserialize_with = "optional",
335 skip_serializing_if = "Option::is_none"
336 )]
337 pub file_id: Option<String>,
338 #[serde(
339 default,
340 deserialize_with = "optional",
341 skip_serializing_if = "Option::is_none"
342 )]
343 pub image_url: Option<String>,
344 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
345 pub rest: Rest,
346}
347
348#[derive(
349 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
350)]
351#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
352#[derive(gproxy_protocol_macros::DeclaredFields)]
353#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
354pub struct EditImageJsonBody {
355 pub images: Vec<ImageReference>,
356 pub prompt: String,
357 #[serde(
358 default,
359 deserialize_with = "nullable",
360 skip_serializing_if = "Option::is_none"
361 )]
362 pub background: Option<Option<ImageBackground>>,
363 #[serde(
364 default,
365 deserialize_with = "nullable",
366 skip_serializing_if = "Option::is_none"
367 )]
368 pub model: Option<Option<String>>,
369 #[serde(
370 default,
371 deserialize_with = "nullable",
372 skip_serializing_if = "Option::is_none"
373 )]
374 pub moderation: Option<Option<ImageModeration>>,
375 #[serde(
376 default,
377 deserialize_with = "nullable",
378 skip_serializing_if = "Option::is_none"
379 )]
380 pub n: Option<Option<i64>>,
381 #[serde(
382 default,
383 deserialize_with = "nullable",
384 skip_serializing_if = "Option::is_none"
385 )]
386 pub output_compression: Option<Option<i64>>,
387 #[serde(
388 default,
389 deserialize_with = "nullable",
390 skip_serializing_if = "Option::is_none"
391 )]
392 pub output_format: Option<Option<ImageOutputFormat>>,
393 #[serde(
394 default,
395 deserialize_with = "nullable",
396 skip_serializing_if = "Option::is_none"
397 )]
398 pub partial_images: Option<Option<i64>>,
399 #[serde(
400 default,
401 deserialize_with = "nullable",
402 skip_serializing_if = "Option::is_none"
403 )]
404 pub input_fidelity: Option<Option<InputFidelity>>,
405 #[serde(
406 default,
407 deserialize_with = "optional",
408 skip_serializing_if = "Option::is_none"
409 )]
410 pub mask: Option<ImageReference>,
411 #[serde(
412 default,
413 deserialize_with = "nullable",
414 skip_serializing_if = "Option::is_none"
415 )]
416 pub quality: Option<Option<EditedImageQuality>>,
417 #[serde(
418 default,
419 deserialize_with = "nullable",
420 skip_serializing_if = "Option::is_none"
421 )]
422 pub size: Option<Option<EditedImageSize>>,
423 #[serde(
424 default,
425 deserialize_with = "nullable",
426 skip_serializing_if = "Option::is_none"
427 )]
428 pub stream: Option<Option<bool>>,
429 #[serde(
430 default,
431 deserialize_with = "optional",
432 skip_serializing_if = "Option::is_none"
433 )]
434 pub user: Option<String>,
435 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
436 pub rest: Rest,
437}
438
439#[derive(Debug, gproxy_protocol_macros::WireBuilder)]
440#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
441#[derive(gproxy_protocol_macros::DeclaredFields)]
442#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
443pub struct EditImageMultipartForm {
444 pub image: Vec<MultipartPart>,
445 pub prompt: String,
446 pub mask: Option<MultipartPart>,
447 pub background: Option<Option<ImageBackground>>,
448 pub model: Option<Option<String>>,
449 pub n: Option<Option<i64>>,
450 pub output_compression: Option<Option<i64>>,
451 pub output_format: Option<Option<ImageOutputFormat>>,
452 pub partial_images: Option<Option<i64>>,
453 pub input_fidelity: Option<Option<InputFidelity>>,
454 pub quality: Option<Option<MultipartImageQuality>>,
455 pub size: Option<Option<String>>,
456 pub response_format: Option<Option<ImageResponseFormat>>,
457 pub stream: Option<Option<bool>>,
458 pub user: Option<String>,
459}
460
461#[derive(
462 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
463)]
464#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
465#[derive(gproxy_protocol_macros::DeclaredFields)]
466#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
467pub struct ImagesResponse {
468 pub created: i64,
469 #[serde(
470 default,
471 deserialize_with = "optional",
472 skip_serializing_if = "Option::is_none"
473 )]
474 pub background: Option<OutputImageBackground>,
475 #[serde(
476 default,
477 deserialize_with = "optional",
478 skip_serializing_if = "Option::is_none"
479 )]
480 pub data: Option<Vec<GeneratedImage>>,
481 #[serde(
482 default,
483 deserialize_with = "optional",
484 skip_serializing_if = "Option::is_none"
485 )]
486 pub output_format: Option<ImageOutputFormat>,
487 #[serde(
488 default,
489 deserialize_with = "optional",
490 skip_serializing_if = "Option::is_none"
491 )]
492 pub quality: Option<OutputImageQuality>,
493 #[serde(
494 default,
495 deserialize_with = "optional",
496 skip_serializing_if = "Option::is_none"
497 )]
498 pub size: Option<OutputImageSize>,
499 #[serde(
500 default,
501 deserialize_with = "optional",
502 skip_serializing_if = "Option::is_none"
503 )]
504 pub usage: Option<ImageUsage>,
505 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
506 pub rest: Rest,
507}
508
509#[derive(
510 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
511)]
512#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
513#[derive(gproxy_protocol_macros::DeclaredFields)]
514#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
515pub struct GeneratedImage {
516 #[serde(
517 default,
518 deserialize_with = "optional",
519 skip_serializing_if = "Option::is_none"
520 )]
521 pub b64_json: Option<String>,
522 #[serde(
523 default,
524 deserialize_with = "optional",
525 skip_serializing_if = "Option::is_none"
526 )]
527 pub url: Option<String>,
528 #[serde(
529 default,
530 deserialize_with = "optional",
531 skip_serializing_if = "Option::is_none"
532 )]
533 pub revised_prompt: Option<String>,
534 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
535 pub rest: Rest,
536}
537
538#[derive(
539 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
540)]
541#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
542#[derive(gproxy_protocol_macros::DeclaredFields)]
543#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
544pub struct ImageUsage {
545 pub input_tokens: i64,
546 pub input_tokens_details: ImageTokenDetails,
547 pub output_tokens: i64,
548 pub total_tokens: i64,
549 #[serde(
550 default,
551 deserialize_with = "optional",
552 skip_serializing_if = "Option::is_none"
553 )]
554 pub output_tokens_details: Option<ImageTokenDetails>,
555 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
556 pub rest: Rest,
557}
558
559#[derive(
560 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
561)]
562#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
563#[derive(gproxy_protocol_macros::DeclaredFields)]
564#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
565pub struct ImageTokenDetails {
566 pub image_tokens: i64,
567 pub text_tokens: i64,
568 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
569 pub rest: Rest,
570}
571
572#[derive(
573 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
574)]
575#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
576#[derive(gproxy_protocol_macros::DeclaredFields)]
577#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
578pub struct ImagePartialEvent {
579 pub b64_json: String,
580 pub background: ImageBackground,
581 pub created_at: i64,
582 pub output_format: ImageOutputFormat,
583 pub partial_image_index: i64,
584 pub quality: StreamImageQuality,
585 pub size: String,
586 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
587 pub rest: Rest,
588}
589
590#[derive(
591 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
592)]
593#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
594#[derive(gproxy_protocol_macros::DeclaredFields)]
595#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
596pub struct ImageCompletedEvent {
597 pub b64_json: String,
598 pub background: ImageBackground,
599 pub created_at: i64,
600 pub output_format: ImageOutputFormat,
601 pub quality: StreamImageQuality,
602 pub size: String,
603 pub usage: ImageUsage,
604 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
605 pub rest: Rest,
606}
607
608#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
609#[serde(tag = "type")]
610#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
611#[derive(gproxy_protocol_macros::DeclaredFields)]
612#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
613pub enum ImageGenerationStreamEvent {
614 #[serde(rename = "image_generation.partial_image")]
615 Partial(ImagePartialEvent),
616 #[serde(rename = "image_generation.completed")]
617 Completed(ImageCompletedEvent),
618}
619
620#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
621#[serde(tag = "type")]
622#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
623#[derive(gproxy_protocol_macros::DeclaredFields)]
624#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
625pub enum ImageEditStreamEvent {
626 #[serde(rename = "image_edit.partial_image")]
627 Partial(ImagePartialEvent),
628 #[serde(rename = "image_edit.completed")]
629 Completed(ImageCompletedEvent),
630}
631
632pub type CreateImageRequest = WireRequest<CreateImageRequestBody>;
633pub type CreateImageResponse = WireResponse<ImagesResponse>;
634pub type CreateImageStreamResponse = WireResponse<crate::connection::ByteStream>;
635pub type EditImageJsonRequest = WireRequest<EditImageJsonBody>;
636pub type EditImageMultipartRequest = WireRequest<EditImageMultipartForm>;
637pub type RawEditImageRequest = WireRequest<crate::connection::Multipart>;
638pub type EditImageResponse = WireResponse<ImagesResponse>;
639pub type EditImageStreamResponse = WireResponse<crate::connection::ByteStream>;
640pub type RawImageResponse = WireResponse<HttpBody>;