1use std::collections::HashMap;
2
3use crate::base64_serde;
4use crate::config::{GenerationConfig, ModelArmorConfig, SafetySetting};
5use crate::content::Content;
6use crate::enums::{
7 ControlReferenceType, EditMode, ImagePromptLanguage, MaskReferenceMode, PersonGeneration,
8 ReferenceImageType, SafetyFilterLevel, SegmentMode, SubjectReferenceType,
9 VideoCompressionQuality, VideoGenerationMaskMode, VideoGenerationReferenceType,
10};
11use crate::http::{HttpOptions, HttpResponse};
12use crate::operations::OperationError;
13use crate::tool::{Tool, ToolConfig};
14use serde::{Deserialize, Serialize};
15use serde_json::Value;
16
17#[derive(Debug, Clone, Serialize, Deserialize, Default)]
19#[serde(rename_all = "camelCase")]
20pub struct GenerateContentConfig {
21 #[serde(skip_serializing_if = "Option::is_none")]
22 pub system_instruction: Option<Content>,
23 #[serde(skip_serializing_if = "Option::is_none")]
24 pub generation_config: Option<GenerationConfig>,
25 #[serde(skip_serializing_if = "Option::is_none")]
26 pub safety_settings: Option<Vec<SafetySetting>>,
27 #[serde(skip_serializing_if = "Option::is_none")]
30 pub model_armor_config: Option<ModelArmorConfig>,
31 #[serde(skip_serializing_if = "Option::is_none")]
32 pub tools: Option<Vec<Tool>>,
33 #[serde(skip_serializing_if = "Option::is_none")]
34 pub tool_config: Option<ToolConfig>,
35 #[serde(skip_serializing_if = "Option::is_none")]
37 pub automatic_function_calling: Option<AutomaticFunctionCallingConfig>,
38 #[serde(skip_serializing_if = "Option::is_none")]
39 pub cached_content: Option<String>,
40 #[serde(skip_serializing_if = "Option::is_none")]
41 pub labels: Option<HashMap<String, String>>,
42 #[serde(skip_serializing, skip_deserializing)]
46 pub should_return_http_response: Option<bool>,
47}
48
49#[derive(Debug, Clone, Serialize, Deserialize)]
51#[serde(rename_all = "camelCase")]
52pub struct GenerateContentRequest {
53 pub contents: Vec<Content>,
54 #[serde(skip_serializing_if = "Option::is_none")]
55 pub system_instruction: Option<Content>,
56 #[serde(skip_serializing_if = "Option::is_none")]
57 pub generation_config: Option<GenerationConfig>,
58 #[serde(skip_serializing_if = "Option::is_none")]
59 pub safety_settings: Option<Vec<SafetySetting>>,
60 #[serde(skip_serializing_if = "Option::is_none")]
63 pub model_armor_config: Option<ModelArmorConfig>,
64 #[serde(skip_serializing_if = "Option::is_none")]
65 pub tools: Option<Vec<Tool>>,
66 #[serde(skip_serializing_if = "Option::is_none")]
67 pub tool_config: Option<ToolConfig>,
68 #[serde(skip_serializing_if = "Option::is_none")]
69 pub cached_content: Option<String>,
70 #[serde(skip_serializing_if = "Option::is_none")]
71 pub labels: Option<HashMap<String, String>>,
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize, Default)]
76#[serde(rename_all = "camelCase")]
77pub struct AutomaticFunctionCallingConfig {
78 #[serde(skip_serializing_if = "Option::is_none")]
80 pub disable: Option<bool>,
81 #[serde(skip_serializing_if = "Option::is_none")]
83 pub maximum_remote_calls: Option<i32>,
84 #[serde(skip_serializing_if = "Option::is_none")]
86 pub ignore_call_history: Option<bool>,
87}
88
89#[derive(Debug, Clone, Serialize, Deserialize, Default)]
91#[serde(rename_all = "camelCase")]
92pub struct CountTokensConfig {
93 #[serde(skip_serializing_if = "Option::is_none")]
94 pub system_instruction: Option<Content>,
95 #[serde(skip_serializing_if = "Option::is_none")]
96 pub tools: Option<Vec<Tool>>,
97 #[serde(skip_serializing_if = "Option::is_none")]
98 pub generation_config: Option<GenerationConfig>,
99}
100
101#[derive(Debug, Clone, Serialize, Deserialize)]
103#[serde(rename_all = "camelCase")]
104pub struct CountTokensRequest {
105 pub contents: Vec<Content>,
106 #[serde(skip_serializing_if = "Option::is_none")]
107 pub system_instruction: Option<Content>,
108 #[serde(skip_serializing_if = "Option::is_none")]
109 pub tools: Option<Vec<Tool>>,
110 #[serde(skip_serializing_if = "Option::is_none")]
111 pub generation_config: Option<GenerationConfig>,
112}
113
114#[derive(Debug, Clone, Serialize, Deserialize)]
116#[serde(rename_all = "camelCase")]
117pub struct CountTokensResponse {
118 #[serde(skip_serializing_if = "Option::is_none")]
120 pub sdk_http_response: Option<HttpResponse>,
121 #[serde(skip_serializing_if = "Option::is_none")]
122 pub total_tokens: Option<i32>,
123 #[serde(skip_serializing_if = "Option::is_none")]
124 pub cached_content_token_count: Option<i32>,
125}
126
127#[derive(Debug, Clone, Serialize, Deserialize, Default)]
129#[serde(rename_all = "camelCase")]
130pub struct ComputeTokensConfig {
131 #[serde(skip_serializing, skip_deserializing)]
133 pub http_options: Option<HttpOptions>,
134}
135
136#[derive(Debug, Clone, Serialize, Deserialize)]
138#[serde(rename_all = "camelCase")]
139pub struct ComputeTokensRequest {
140 pub contents: Vec<Content>,
141}
142
143#[derive(Debug, Clone, Serialize, Deserialize, Default)]
145#[serde(rename_all = "camelCase")]
146pub struct TokensInfo {
147 #[serde(skip_serializing_if = "Option::is_none")]
149 pub role: Option<String>,
150 #[serde(skip_serializing_if = "Option::is_none")]
152 pub token_ids: Option<Vec<i64>>,
153 #[serde(skip_serializing_if = "Option::is_none")]
155 pub tokens: Option<Vec<String>>,
156}
157
158#[derive(Debug, Clone, Serialize, Deserialize, Default)]
160#[serde(rename_all = "camelCase")]
161pub struct ComputeTokensResponse {
162 #[serde(skip_serializing_if = "Option::is_none")]
164 pub sdk_http_response: Option<HttpResponse>,
165 #[serde(skip_serializing_if = "Option::is_none")]
167 pub tokens_info: Option<Vec<TokensInfo>>,
168}
169
170#[derive(Debug, Clone, Serialize, Deserialize, Default)]
172#[serde(rename_all = "camelCase")]
173pub struct EmbedContentConfig {
174 #[serde(skip_serializing_if = "Option::is_none")]
175 pub task_type: Option<String>,
176 #[serde(skip_serializing_if = "Option::is_none")]
177 pub title: Option<String>,
178 #[serde(skip_serializing_if = "Option::is_none")]
179 pub output_dimensionality: Option<i32>,
180 #[serde(skip_serializing_if = "Option::is_none")]
181 pub mime_type: Option<String>,
182 #[serde(skip_serializing_if = "Option::is_none")]
183 pub auto_truncate: Option<bool>,
184}
185
186#[derive(Debug, Clone, Serialize, Deserialize)]
188#[serde(rename_all = "camelCase")]
189pub struct ContentEmbeddingStatistics {
190 #[serde(skip_serializing_if = "Option::is_none")]
191 pub truncated: Option<bool>,
192 #[serde(skip_serializing_if = "Option::is_none")]
193 pub token_count: Option<f32>,
194}
195
196#[derive(Debug, Clone, Serialize, Deserialize)]
198#[serde(rename_all = "camelCase")]
199pub struct ContentEmbedding {
200 #[serde(skip_serializing_if = "Option::is_none")]
201 pub values: Option<Vec<f32>>,
202 #[serde(skip_serializing_if = "Option::is_none")]
203 pub statistics: Option<ContentEmbeddingStatistics>,
204}
205
206#[derive(Debug, Clone, Serialize, Deserialize)]
208#[serde(rename_all = "camelCase")]
209pub struct EmbedContentMetadata {
210 #[serde(skip_serializing_if = "Option::is_none")]
211 pub billable_character_count: Option<i32>,
212}
213
214#[derive(Debug, Clone, Serialize, Deserialize)]
216#[serde(rename_all = "camelCase")]
217pub struct EmbedContentResponse {
218 #[serde(skip_serializing_if = "Option::is_none")]
220 pub sdk_http_response: Option<HttpResponse>,
221 #[serde(skip_serializing_if = "Option::is_none")]
222 pub embeddings: Option<Vec<ContentEmbedding>>,
223 #[serde(skip_serializing_if = "Option::is_none")]
224 pub metadata: Option<EmbedContentMetadata>,
225}
226
227#[derive(Debug, Clone, Serialize, Deserialize)]
229#[serde(rename_all = "camelCase")]
230pub struct Model {
231 #[serde(skip_serializing_if = "Option::is_none")]
232 pub name: Option<String>,
233 #[serde(skip_serializing_if = "Option::is_none")]
234 pub display_name: Option<String>,
235 #[serde(skip_serializing_if = "Option::is_none")]
236 pub description: Option<String>,
237 #[serde(skip_serializing_if = "Option::is_none")]
238 pub input_token_limit: Option<i32>,
239 #[serde(skip_serializing_if = "Option::is_none")]
240 pub output_token_limit: Option<i32>,
241 #[serde(skip_serializing_if = "Option::is_none")]
242 pub supported_actions: Option<Vec<String>>,
243 #[serde(skip_serializing_if = "Option::is_none")]
244 pub labels: Option<HashMap<String, String>>,
245}
246
247#[derive(Debug, Clone, Serialize, Deserialize, Default)]
249#[serde(rename_all = "camelCase")]
250pub struct ListModelsConfig {
251 #[serde(skip_serializing_if = "Option::is_none")]
252 pub page_size: Option<i32>,
253 #[serde(skip_serializing_if = "Option::is_none")]
254 pub page_token: Option<String>,
255 #[serde(skip_serializing_if = "Option::is_none")]
256 pub filter: Option<String>,
257 #[serde(skip_serializing_if = "Option::is_none")]
258 pub query_base: Option<bool>,
259}
260
261#[derive(Debug, Clone, Serialize, Deserialize)]
263#[serde(rename_all = "camelCase")]
264pub struct ListModelsResponse {
265 #[serde(skip_serializing_if = "Option::is_none")]
267 pub sdk_http_response: Option<HttpResponse>,
268 #[serde(skip_serializing_if = "Option::is_none")]
269 pub models: Option<Vec<Model>>,
270 #[serde(skip_serializing_if = "Option::is_none")]
271 pub next_page_token: Option<String>,
272}
273
274#[derive(Debug, Clone, Serialize, Deserialize, Default)]
276#[serde(rename_all = "camelCase")]
277pub struct UpdateModelConfig {
278 #[serde(skip_serializing, skip_deserializing)]
280 pub http_options: Option<HttpOptions>,
281 #[serde(skip_serializing_if = "Option::is_none")]
282 pub display_name: Option<String>,
283 #[serde(skip_serializing_if = "Option::is_none")]
284 pub description: Option<String>,
285 #[serde(skip_serializing_if = "Option::is_none")]
286 pub default_checkpoint_id: Option<String>,
287}
288
289#[derive(Debug, Clone, Serialize, Deserialize, Default)]
291#[serde(rename_all = "camelCase")]
292pub struct DeleteModelConfig {
293 #[serde(skip_serializing, skip_deserializing)]
295 pub http_options: Option<HttpOptions>,
296}
297
298#[derive(Debug, Clone, Serialize, Deserialize, Default)]
300#[serde(rename_all = "camelCase")]
301pub struct DeleteModelResponse {
302 #[serde(skip_serializing_if = "Option::is_none")]
304 pub sdk_http_response: Option<HttpResponse>,
305}
306
307#[derive(Debug, Clone, Serialize, Deserialize, Default)]
309#[serde(rename_all = "camelCase")]
310pub struct GenerateImagesConfig {
311 #[serde(skip_serializing, skip_deserializing)]
313 pub http_options: Option<HttpOptions>,
314 #[serde(skip_serializing_if = "Option::is_none")]
315 pub output_gcs_uri: Option<String>,
316 #[serde(skip_serializing_if = "Option::is_none")]
317 pub negative_prompt: Option<String>,
318 #[serde(skip_serializing_if = "Option::is_none")]
319 pub number_of_images: Option<i32>,
320 #[serde(skip_serializing_if = "Option::is_none")]
321 pub aspect_ratio: Option<String>,
322 #[serde(skip_serializing_if = "Option::is_none")]
323 pub guidance_scale: Option<f32>,
324 #[serde(skip_serializing_if = "Option::is_none")]
325 pub seed: Option<i32>,
326 #[serde(skip_serializing_if = "Option::is_none")]
327 pub safety_filter_level: Option<SafetyFilterLevel>,
328 #[serde(skip_serializing_if = "Option::is_none")]
329 pub person_generation: Option<PersonGeneration>,
330 #[serde(skip_serializing_if = "Option::is_none")]
331 pub include_safety_attributes: Option<bool>,
332 #[serde(skip_serializing_if = "Option::is_none")]
333 pub include_rai_reason: Option<bool>,
334 #[serde(skip_serializing_if = "Option::is_none")]
335 pub language: Option<ImagePromptLanguage>,
336 #[serde(skip_serializing_if = "Option::is_none")]
337 pub output_mime_type: Option<String>,
338 #[serde(skip_serializing_if = "Option::is_none")]
339 pub output_compression_quality: Option<i32>,
340 #[serde(skip_serializing_if = "Option::is_none")]
341 pub add_watermark: Option<bool>,
342 #[serde(skip_serializing_if = "Option::is_none")]
343 pub labels: Option<HashMap<String, String>>,
344 #[serde(skip_serializing_if = "Option::is_none")]
345 pub image_size: Option<String>,
346 #[serde(skip_serializing_if = "Option::is_none")]
347 pub enhance_prompt: Option<bool>,
348}
349
350#[derive(Debug, Clone, Serialize, Deserialize, Default)]
352#[serde(rename_all = "camelCase")]
353pub struct Image {
354 #[serde(skip_serializing_if = "Option::is_none")]
355 pub gcs_uri: Option<String>,
356 #[serde(
357 default,
358 skip_serializing_if = "Option::is_none",
359 rename = "bytesBase64Encoded",
360 with = "base64_serde::option"
361 )]
362 pub image_bytes: Option<Vec<u8>>,
363 #[serde(skip_serializing_if = "Option::is_none")]
364 pub mime_type: Option<String>,
365}
366
367#[derive(Debug, Clone, Serialize, Deserialize, Default)]
369#[serde(rename_all = "camelCase")]
370pub struct SafetyAttributes {
371 #[serde(skip_serializing_if = "Option::is_none")]
372 pub categories: Option<Vec<String>>,
373 #[serde(skip_serializing_if = "Option::is_none")]
374 pub scores: Option<Vec<f32>>,
375 #[serde(skip_serializing_if = "Option::is_none")]
376 pub content_type: Option<String>,
377}
378
379#[derive(Debug, Clone, Serialize, Deserialize, Default)]
381#[serde(rename_all = "camelCase")]
382pub struct GeneratedImage {
383 #[serde(skip_serializing_if = "Option::is_none")]
384 pub image: Option<Image>,
385 #[serde(skip_serializing_if = "Option::is_none")]
386 pub rai_filtered_reason: Option<String>,
387 #[serde(skip_serializing_if = "Option::is_none")]
388 pub safety_attributes: Option<SafetyAttributes>,
389 #[serde(skip_serializing_if = "Option::is_none")]
390 pub enhanced_prompt: Option<String>,
391}
392
393#[derive(Debug, Clone, Serialize, Deserialize, Default)]
395#[serde(rename_all = "camelCase")]
396pub struct GenerateImagesResponse {
397 #[serde(skip_serializing_if = "Option::is_none")]
399 pub sdk_http_response: Option<HttpResponse>,
400 #[serde(default)]
401 pub generated_images: Vec<GeneratedImage>,
402 #[serde(skip_serializing_if = "Option::is_none")]
403 pub positive_prompt_safety_attributes: Option<SafetyAttributes>,
404}
405
406#[derive(Debug, Clone, Serialize, Deserialize, Default)]
408#[serde(rename_all = "camelCase")]
409pub struct MaskReferenceConfig {
410 #[serde(skip_serializing_if = "Option::is_none")]
411 pub mask_mode: Option<MaskReferenceMode>,
412 #[serde(skip_serializing_if = "Option::is_none")]
413 pub segmentation_classes: Option<Vec<i32>>,
414 #[serde(skip_serializing_if = "Option::is_none")]
415 pub mask_dilation: Option<f32>,
416}
417
418#[derive(Debug, Clone, Serialize, Deserialize, Default)]
420#[serde(rename_all = "camelCase")]
421pub struct ControlReferenceConfig {
422 #[serde(skip_serializing_if = "Option::is_none")]
423 pub control_type: Option<ControlReferenceType>,
424 #[serde(skip_serializing_if = "Option::is_none")]
425 pub enable_control_image_computation: Option<bool>,
426}
427
428#[derive(Debug, Clone, Serialize, Deserialize, Default)]
430#[serde(rename_all = "camelCase")]
431pub struct StyleReferenceConfig {
432 #[serde(skip_serializing_if = "Option::is_none")]
433 pub style_description: Option<String>,
434}
435
436#[derive(Debug, Clone, Serialize, Deserialize, Default)]
438#[serde(rename_all = "camelCase")]
439pub struct SubjectReferenceConfig {
440 #[serde(skip_serializing_if = "Option::is_none")]
441 pub subject_type: Option<SubjectReferenceType>,
442 #[serde(skip_serializing_if = "Option::is_none")]
443 pub subject_description: Option<String>,
444}
445
446#[derive(Debug, Clone, Serialize, Deserialize, Default)]
448#[serde(rename_all = "camelCase")]
449pub struct ReferenceImage {
450 #[serde(skip_serializing_if = "Option::is_none")]
451 pub reference_image: Option<Image>,
452 #[serde(skip_serializing_if = "Option::is_none")]
453 pub reference_id: Option<i32>,
454 #[serde(skip_serializing_if = "Option::is_none")]
455 pub reference_type: Option<ReferenceImageType>,
456 #[serde(skip_serializing_if = "Option::is_none")]
457 pub mask_image_config: Option<MaskReferenceConfig>,
458 #[serde(skip_serializing_if = "Option::is_none")]
459 pub control_image_config: Option<ControlReferenceConfig>,
460 #[serde(skip_serializing_if = "Option::is_none")]
461 pub style_image_config: Option<StyleReferenceConfig>,
462 #[serde(skip_serializing_if = "Option::is_none")]
463 pub subject_image_config: Option<SubjectReferenceConfig>,
464}
465
466#[derive(Debug, Clone, Serialize, Deserialize, Default)]
468#[serde(rename_all = "camelCase")]
469pub struct EditImageConfig {
470 #[serde(skip_serializing, skip_deserializing)]
472 pub http_options: Option<HttpOptions>,
473 #[serde(skip_serializing_if = "Option::is_none")]
474 pub output_gcs_uri: Option<String>,
475 #[serde(skip_serializing_if = "Option::is_none")]
476 pub negative_prompt: Option<String>,
477 #[serde(skip_serializing_if = "Option::is_none")]
478 pub number_of_images: Option<i32>,
479 #[serde(skip_serializing_if = "Option::is_none")]
480 pub aspect_ratio: Option<String>,
481 #[serde(skip_serializing_if = "Option::is_none")]
482 pub guidance_scale: Option<f32>,
483 #[serde(skip_serializing_if = "Option::is_none")]
484 pub seed: Option<i32>,
485 #[serde(skip_serializing_if = "Option::is_none")]
486 pub safety_filter_level: Option<SafetyFilterLevel>,
487 #[serde(skip_serializing_if = "Option::is_none")]
488 pub person_generation: Option<PersonGeneration>,
489 #[serde(skip_serializing_if = "Option::is_none")]
490 pub include_safety_attributes: Option<bool>,
491 #[serde(skip_serializing_if = "Option::is_none")]
492 pub include_rai_reason: Option<bool>,
493 #[serde(skip_serializing_if = "Option::is_none")]
494 pub language: Option<ImagePromptLanguage>,
495 #[serde(skip_serializing_if = "Option::is_none")]
496 pub output_mime_type: Option<String>,
497 #[serde(skip_serializing_if = "Option::is_none")]
498 pub output_compression_quality: Option<i32>,
499 #[serde(skip_serializing_if = "Option::is_none")]
500 pub add_watermark: Option<bool>,
501 #[serde(skip_serializing_if = "Option::is_none")]
502 pub labels: Option<HashMap<String, String>>,
503 #[serde(skip_serializing_if = "Option::is_none")]
504 pub edit_mode: Option<EditMode>,
505 #[serde(skip_serializing_if = "Option::is_none")]
506 pub base_steps: Option<i32>,
507}
508
509#[derive(Debug, Clone, Serialize, Deserialize, Default)]
511#[serde(rename_all = "camelCase")]
512pub struct EditImageResponse {
513 #[serde(skip_serializing_if = "Option::is_none")]
515 pub sdk_http_response: Option<HttpResponse>,
516 #[serde(default)]
517 pub generated_images: Vec<GeneratedImage>,
518}
519
520#[derive(Debug, Clone, Serialize, Deserialize, Default)]
522#[serde(rename_all = "camelCase")]
523pub struct UpscaleImageConfig {
524 #[serde(skip_serializing, skip_deserializing)]
526 pub http_options: Option<HttpOptions>,
527 #[serde(skip_serializing_if = "Option::is_none")]
528 pub output_gcs_uri: Option<String>,
529 #[serde(skip_serializing_if = "Option::is_none")]
530 pub safety_filter_level: Option<SafetyFilterLevel>,
531 #[serde(skip_serializing_if = "Option::is_none")]
532 pub person_generation: Option<PersonGeneration>,
533 #[serde(skip_serializing_if = "Option::is_none")]
534 pub include_rai_reason: Option<bool>,
535 #[serde(skip_serializing_if = "Option::is_none")]
536 pub output_mime_type: Option<String>,
537 #[serde(skip_serializing_if = "Option::is_none")]
538 pub output_compression_quality: Option<i32>,
539 #[serde(skip_serializing_if = "Option::is_none")]
540 pub enhance_input_image: Option<bool>,
541 #[serde(skip_serializing_if = "Option::is_none")]
542 pub image_preservation_factor: Option<f32>,
543 #[serde(skip_serializing_if = "Option::is_none")]
544 pub labels: Option<HashMap<String, String>>,
545 #[serde(skip_serializing_if = "Option::is_none")]
546 pub number_of_images: Option<i32>,
547 #[serde(skip_serializing_if = "Option::is_none")]
548 pub mode: Option<String>,
549}
550
551#[derive(Debug, Clone, Serialize, Deserialize, Default)]
553#[serde(rename_all = "camelCase")]
554pub struct UpscaleImageResponse {
555 #[serde(skip_serializing_if = "Option::is_none")]
557 pub sdk_http_response: Option<HttpResponse>,
558 #[serde(default)]
559 pub generated_images: Vec<GeneratedImage>,
560}
561
562#[derive(Debug, Clone, Serialize, Deserialize, Default)]
564#[serde(rename_all = "camelCase")]
565pub struct ProductImage {
566 #[serde(skip_serializing_if = "Option::is_none")]
567 pub product_image: Option<Image>,
568}
569
570#[derive(Debug, Clone, Serialize, Deserialize, Default)]
572#[serde(rename_all = "camelCase")]
573pub struct RecontextImageSource {
574 #[serde(skip_serializing_if = "Option::is_none")]
575 pub prompt: Option<String>,
576 #[serde(skip_serializing_if = "Option::is_none")]
577 pub person_image: Option<Image>,
578 #[serde(skip_serializing_if = "Option::is_none")]
579 pub product_images: Option<Vec<ProductImage>>,
580}
581
582#[derive(Debug, Clone, Serialize, Deserialize, Default)]
584#[serde(rename_all = "camelCase")]
585pub struct RecontextImageConfig {
586 #[serde(skip_serializing, skip_deserializing)]
588 pub http_options: Option<HttpOptions>,
589 #[serde(skip_serializing_if = "Option::is_none")]
590 pub number_of_images: Option<i32>,
591 #[serde(skip_serializing_if = "Option::is_none")]
592 pub base_steps: Option<i32>,
593 #[serde(skip_serializing_if = "Option::is_none")]
594 pub output_gcs_uri: Option<String>,
595 #[serde(skip_serializing_if = "Option::is_none")]
596 pub seed: Option<i32>,
597 #[serde(skip_serializing_if = "Option::is_none")]
598 pub safety_filter_level: Option<SafetyFilterLevel>,
599 #[serde(skip_serializing_if = "Option::is_none")]
600 pub person_generation: Option<PersonGeneration>,
601 #[serde(skip_serializing_if = "Option::is_none")]
602 pub add_watermark: Option<bool>,
603 #[serde(skip_serializing_if = "Option::is_none")]
604 pub output_mime_type: Option<String>,
605 #[serde(skip_serializing_if = "Option::is_none")]
606 pub output_compression_quality: Option<i32>,
607 #[serde(skip_serializing_if = "Option::is_none")]
608 pub enhance_prompt: Option<bool>,
609 #[serde(skip_serializing_if = "Option::is_none")]
610 pub labels: Option<HashMap<String, String>>,
611}
612
613#[derive(Debug, Clone, Serialize, Deserialize, Default)]
615#[serde(rename_all = "camelCase")]
616pub struct RecontextImageResponse {
617 #[serde(default)]
618 pub generated_images: Vec<GeneratedImage>,
619}
620
621#[derive(Debug, Clone, Serialize, Deserialize, Default)]
623#[serde(rename_all = "camelCase")]
624pub struct ScribbleImage {
625 #[serde(skip_serializing_if = "Option::is_none")]
626 pub image: Option<Image>,
627}
628
629#[derive(Debug, Clone, Serialize, Deserialize, Default)]
631#[serde(rename_all = "camelCase")]
632pub struct SegmentImageSource {
633 #[serde(skip_serializing_if = "Option::is_none")]
634 pub prompt: Option<String>,
635 #[serde(skip_serializing_if = "Option::is_none")]
636 pub image: Option<Image>,
637 #[serde(skip_serializing_if = "Option::is_none")]
638 pub scribble_image: Option<ScribbleImage>,
639}
640
641#[derive(Debug, Clone, Serialize, Deserialize, Default)]
643#[serde(rename_all = "camelCase")]
644pub struct SegmentImageConfig {
645 #[serde(skip_serializing, skip_deserializing)]
647 pub http_options: Option<HttpOptions>,
648 #[serde(skip_serializing_if = "Option::is_none")]
649 pub mode: Option<SegmentMode>,
650 #[serde(skip_serializing_if = "Option::is_none")]
651 pub max_predictions: Option<i32>,
652 #[serde(skip_serializing_if = "Option::is_none")]
653 pub confidence_threshold: Option<f32>,
654 #[serde(skip_serializing_if = "Option::is_none")]
655 pub mask_dilation: Option<f32>,
656 #[serde(skip_serializing_if = "Option::is_none")]
657 pub binary_color_threshold: Option<f32>,
658 #[serde(skip_serializing_if = "Option::is_none")]
659 pub labels: Option<HashMap<String, String>>,
660}
661
662#[derive(Debug, Clone, Serialize, Deserialize, Default)]
664#[serde(rename_all = "camelCase")]
665pub struct EntityLabel {
666 #[serde(skip_serializing_if = "Option::is_none")]
667 pub label: Option<String>,
668 #[serde(skip_serializing_if = "Option::is_none")]
669 pub score: Option<f32>,
670}
671
672#[derive(Debug, Clone, Serialize, Deserialize, Default)]
674#[serde(rename_all = "camelCase")]
675pub struct GeneratedImageMask {
676 #[serde(skip_serializing_if = "Option::is_none")]
677 pub mask: Option<Image>,
678 #[serde(skip_serializing_if = "Option::is_none")]
679 pub labels: Option<Vec<EntityLabel>>,
680}
681
682#[derive(Debug, Clone, Serialize, Deserialize, Default)]
684#[serde(rename_all = "camelCase")]
685pub struct SegmentImageResponse {
686 #[serde(default)]
687 pub generated_masks: Vec<GeneratedImageMask>,
688}
689
690#[derive(Debug, Clone, Serialize, Deserialize, Default)]
692#[serde(rename_all = "camelCase")]
693pub struct Video {
694 #[serde(skip_serializing_if = "Option::is_none")]
695 pub uri: Option<String>,
696 #[serde(
697 default,
698 skip_serializing_if = "Option::is_none",
699 rename = "bytesBase64Encoded",
700 with = "base64_serde::option"
701 )]
702 pub video_bytes: Option<Vec<u8>>,
703 #[serde(skip_serializing_if = "Option::is_none")]
704 pub mime_type: Option<String>,
705}
706
707#[derive(Debug, Clone, Serialize, Deserialize, Default)]
709#[serde(rename_all = "camelCase")]
710pub struct GenerateVideosSource {
711 #[serde(skip_serializing_if = "Option::is_none")]
712 pub prompt: Option<String>,
713 #[serde(skip_serializing_if = "Option::is_none")]
714 pub image: Option<Image>,
715 #[serde(skip_serializing_if = "Option::is_none")]
716 pub video: Option<Video>,
717}
718
719#[derive(Debug, Clone, Serialize, Deserialize, Default)]
721#[serde(rename_all = "camelCase")]
722pub struct VideoGenerationReferenceImage {
723 #[serde(skip_serializing_if = "Option::is_none")]
724 pub image: Option<Image>,
725 #[serde(skip_serializing_if = "Option::is_none")]
726 pub reference_type: Option<VideoGenerationReferenceType>,
727}
728
729#[derive(Debug, Clone, Serialize, Deserialize, Default)]
731#[serde(rename_all = "camelCase")]
732pub struct VideoGenerationMask {
733 #[serde(skip_serializing_if = "Option::is_none")]
734 pub image: Option<Image>,
735 #[serde(skip_serializing_if = "Option::is_none")]
736 pub mask_mode: Option<VideoGenerationMaskMode>,
737}
738
739#[derive(Debug, Clone, Serialize, Deserialize, Default)]
741#[serde(rename_all = "camelCase")]
742pub struct GenerateVideosConfig {
743 #[serde(skip_serializing, skip_deserializing)]
745 pub http_options: Option<HttpOptions>,
746 #[serde(skip_serializing_if = "Option::is_none")]
747 pub number_of_videos: Option<i32>,
748 #[serde(skip_serializing_if = "Option::is_none")]
749 pub output_gcs_uri: Option<String>,
750 #[serde(skip_serializing_if = "Option::is_none")]
751 pub fps: Option<i32>,
752 #[serde(skip_serializing_if = "Option::is_none")]
753 pub duration_seconds: Option<i32>,
754 #[serde(skip_serializing_if = "Option::is_none")]
755 pub seed: Option<i32>,
756 #[serde(skip_serializing_if = "Option::is_none")]
757 pub aspect_ratio: Option<String>,
758 #[serde(skip_serializing_if = "Option::is_none")]
759 pub resolution: Option<String>,
760 #[serde(skip_serializing_if = "Option::is_none")]
761 pub person_generation: Option<String>,
762 #[serde(skip_serializing_if = "Option::is_none")]
763 pub pubsub_topic: Option<String>,
764 #[serde(skip_serializing_if = "Option::is_none")]
765 pub negative_prompt: Option<String>,
766 #[serde(skip_serializing_if = "Option::is_none")]
767 pub enhance_prompt: Option<bool>,
768 #[serde(skip_serializing_if = "Option::is_none")]
769 pub generate_audio: Option<bool>,
770 #[serde(skip_serializing_if = "Option::is_none")]
771 pub last_frame: Option<Image>,
772 #[serde(skip_serializing_if = "Option::is_none")]
773 pub reference_images: Option<Vec<VideoGenerationReferenceImage>>,
774 #[serde(skip_serializing_if = "Option::is_none")]
775 pub mask: Option<VideoGenerationMask>,
776 #[serde(skip_serializing_if = "Option::is_none")]
777 pub compression_quality: Option<VideoCompressionQuality>,
778}
779
780#[derive(Debug, Clone, Serialize, Deserialize, Default)]
782#[serde(rename_all = "camelCase")]
783pub struct GeneratedVideo {
784 #[serde(skip_serializing_if = "Option::is_none")]
785 pub video: Option<Video>,
786}
787
788#[derive(Debug, Clone, Serialize, Deserialize, Default)]
790#[serde(rename_all = "camelCase")]
791pub struct GenerateVideosResponse {
792 #[serde(default)]
793 pub generated_videos: Vec<GeneratedVideo>,
794 #[serde(skip_serializing_if = "Option::is_none")]
795 pub rai_media_filtered_count: Option<i32>,
796 #[serde(skip_serializing_if = "Option::is_none")]
797 pub rai_media_filtered_reasons: Option<Vec<String>>,
798}
799
800#[derive(Debug, Clone, Serialize, Deserialize, Default)]
802#[serde(rename_all = "camelCase")]
803pub struct GenerateVideosOperation {
804 #[serde(skip_serializing_if = "Option::is_none")]
805 pub name: Option<String>,
806 #[serde(skip_serializing_if = "Option::is_none")]
807 pub metadata: Option<Value>,
808 #[serde(skip_serializing_if = "Option::is_none")]
809 pub done: Option<bool>,
810 #[serde(skip_serializing_if = "Option::is_none")]
811 pub error: Option<OperationError>,
812 #[serde(skip_serializing_if = "Option::is_none")]
813 pub response: Option<GenerateVideosResponse>,
814}