1use std::collections::BTreeMap;
2
3use serde::{Deserialize, Serialize};
4
5use super::common::{BatchState, ExtraFields, JsonMap, Status};
6use super::embeddings::{EmbedContentRequest, EmbedContentResponse};
7use super::generate_content::{GenerateContentRequest, GenerateContentResponse};
8
9#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10#[serde(rename_all = "camelCase")]
11pub struct BatchGenerateContentRequestBody {
12 #[serde(skip_serializing_if = "Option::is_none")]
13 pub batch: Option<GenerateContentBatch>,
14 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
15 pub extra: ExtraFields,
16}
17
18pub type BatchGenerateContentResponseBody = Operation;
19
20#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
21#[serde(rename_all = "camelCase")]
22pub struct AsyncBatchEmbedContentRequestBody {
23 #[serde(skip_serializing_if = "Option::is_none")]
24 pub batch: Option<EmbedContentBatch>,
25 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
26 pub extra: ExtraFields,
27}
28
29pub type AsyncBatchEmbedContentResponseBody = Operation;
30
31#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
32#[serde(rename_all = "camelCase")]
33pub struct GetBatchRequest {
34 #[serde(skip_serializing_if = "Option::is_none")]
35 pub name: Option<String>,
36 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
37 pub extra: ExtraFields,
38}
39
40#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
41#[serde(rename_all = "camelCase")]
42pub struct ListBatchesRequest {
43 #[serde(skip_serializing_if = "Option::is_none")]
44 pub name: Option<String>,
45 #[serde(skip_serializing_if = "Option::is_none")]
46 pub filter: Option<String>,
47 #[serde(skip_serializing_if = "Option::is_none")]
48 pub page_size: Option<i32>,
49 #[serde(skip_serializing_if = "Option::is_none")]
50 pub page_token: Option<String>,
51 #[serde(skip_serializing_if = "Option::is_none")]
52 pub return_partial_success: Option<bool>,
53 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
54 pub extra: ExtraFields,
55}
56
57#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
58#[serde(rename_all = "camelCase")]
59pub struct ListBatchesResponse {
60 #[serde(default, skip_serializing_if = "Vec::is_empty")]
61 pub operations: Vec<Operation>,
62 #[serde(skip_serializing_if = "Option::is_none")]
63 pub next_page_token: Option<String>,
64 #[serde(default, skip_serializing_if = "Vec::is_empty")]
65 pub unreachable: Vec<String>,
66 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
67 pub extra: ExtraFields,
68}
69
70#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
71#[serde(rename_all = "camelCase")]
72pub struct CancelBatchRequest {
73 #[serde(skip_serializing_if = "Option::is_none")]
74 pub name: Option<String>,
75 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
76 pub extra: ExtraFields,
77}
78
79pub type CancelBatchResponseBody = JsonMap;
80
81#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
82#[serde(rename_all = "camelCase")]
83pub struct DeleteBatchRequest {
84 #[serde(skip_serializing_if = "Option::is_none")]
85 pub name: Option<String>,
86 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
87 pub extra: ExtraFields,
88}
89
90pub type DeleteBatchResponseBody = JsonMap;
91
92#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
93#[serde(rename_all = "camelCase")]
94pub struct UpdateGenerateContentBatchQuery {
95 #[serde(skip_serializing_if = "Option::is_none")]
96 pub update_mask: Option<String>,
97 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
98 pub extra: ExtraFields,
99}
100
101pub type UpdateGenerateContentBatchRequestBody = GenerateContentBatch;
102pub type UpdateGenerateContentBatchResponseBody = GenerateContentBatch;
103
104#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
105#[serde(rename_all = "camelCase")]
106pub struct UpdateEmbedContentBatchQuery {
107 #[serde(skip_serializing_if = "Option::is_none")]
108 pub update_mask: Option<String>,
109 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
110 pub extra: ExtraFields,
111}
112
113pub type UpdateEmbedContentBatchRequestBody = EmbedContentBatch;
114pub type UpdateEmbedContentBatchResponseBody = EmbedContentBatch;
115
116#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
117#[serde(rename_all = "camelCase")]
118pub struct Operation {
119 #[serde(skip_serializing_if = "Option::is_none")]
120 pub name: Option<String>,
121 #[serde(skip_serializing_if = "Option::is_none")]
122 pub metadata: Option<JsonMap>,
123 #[serde(skip_serializing_if = "Option::is_none")]
124 pub done: Option<bool>,
125 #[serde(flatten, skip_serializing_if = "Option::is_none")]
126 pub result: Option<OperationResult>,
127 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
128 pub extra: ExtraFields,
129}
130
131#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
132#[serde(untagged)]
133pub enum OperationResult {
134 Error { error: Status },
135 Response { response: JsonMap },
136}
137
138#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
139#[serde(rename_all = "camelCase")]
140pub struct GenerateContentBatch {
141 #[serde(skip_serializing_if = "Option::is_none")]
142 pub model: Option<String>,
143 #[serde(skip_serializing_if = "Option::is_none")]
144 pub name: Option<String>,
145 #[serde(skip_serializing_if = "Option::is_none")]
146 pub display_name: Option<String>,
147 #[serde(skip_serializing_if = "Option::is_none")]
148 pub input_config: Option<InputConfig>,
149 #[serde(skip_serializing_if = "Option::is_none")]
150 pub output: Option<GenerateContentBatchOutput>,
151 #[serde(skip_serializing_if = "Option::is_none")]
152 pub create_time: Option<String>,
153 #[serde(skip_serializing_if = "Option::is_none")]
154 pub end_time: Option<String>,
155 #[serde(skip_serializing_if = "Option::is_none")]
156 pub update_time: Option<String>,
157 #[serde(skip_serializing_if = "Option::is_none")]
158 pub batch_stats: Option<BatchStats>,
159 #[serde(skip_serializing_if = "Option::is_none")]
160 pub state: Option<BatchState>,
161 #[serde(skip_serializing_if = "Option::is_none")]
162 pub priority: Option<String>,
163 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
164 pub extra: ExtraFields,
165}
166
167#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
168#[serde(rename_all = "camelCase")]
169pub struct InputConfig {
170 #[serde(flatten, skip_serializing_if = "Option::is_none")]
171 pub source: Option<InputConfigSource>,
172 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
173 pub extra: ExtraFields,
174}
175
176#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
177#[serde(untagged)]
178pub enum InputConfigSource {
179 String {
180 #[serde(rename = "fileName")]
181 file_name: String,
182 },
183 Requests {
184 requests: InlinedRequests,
185 },
186}
187
188#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
189#[serde(rename_all = "camelCase")]
190pub struct InlinedRequests {
191 #[serde(default, skip_serializing_if = "Vec::is_empty")]
192 pub requests: Vec<InlinedRequest>,
193 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
194 pub extra: ExtraFields,
195}
196
197#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
198#[serde(rename_all = "camelCase")]
199pub struct InlinedRequest {
200 #[serde(skip_serializing_if = "Option::is_none")]
201 pub request: Option<GenerateContentRequest>,
202 #[serde(skip_serializing_if = "Option::is_none")]
203 pub metadata: Option<JsonMap>,
204 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
205 pub extra: ExtraFields,
206}
207
208#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
209#[serde(rename_all = "camelCase")]
210pub struct GenerateContentBatchOutput {
211 #[serde(flatten, skip_serializing_if = "Option::is_none")]
212 pub output: Option<GenerateContentBatchOutputData>,
213 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
214 pub extra: ExtraFields,
215}
216
217#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
218#[serde(untagged)]
219pub enum GenerateContentBatchOutputData {
220 ResponsesFile {
221 #[serde(rename = "responsesFile")]
222 responses_file: String,
223 },
224 InlinedResponses {
225 #[serde(rename = "inlinedResponses")]
226 inlined_responses: InlinedResponses,
227 },
228}
229
230#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
231#[serde(rename_all = "camelCase")]
232pub struct InlinedResponses {
233 #[serde(default, skip_serializing_if = "Vec::is_empty")]
234 pub inlined_responses: Vec<InlinedResponse>,
235 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
236 pub extra: ExtraFields,
237}
238
239#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
240#[serde(rename_all = "camelCase")]
241pub struct InlinedResponse {
242 #[serde(skip_serializing_if = "Option::is_none")]
243 pub metadata: Option<JsonMap>,
244 #[serde(flatten, skip_serializing_if = "Option::is_none")]
245 pub output: Option<InlinedResponseOutput>,
246 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
247 pub extra: ExtraFields,
248}
249
250#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
251#[serde(untagged)]
252pub enum InlinedResponseOutput {
253 Error {
254 error: Status,
255 },
256 Response {
257 response: Box<GenerateContentResponse>,
258 },
259}
260
261#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
262#[serde(rename_all = "camelCase")]
263pub struct BatchStats {
264 #[serde(skip_serializing_if = "Option::is_none")]
265 pub request_count: Option<String>,
266 #[serde(skip_serializing_if = "Option::is_none")]
267 pub successful_request_count: Option<String>,
268 #[serde(skip_serializing_if = "Option::is_none")]
269 pub failed_request_count: Option<String>,
270 #[serde(skip_serializing_if = "Option::is_none")]
271 pub pending_request_count: Option<String>,
272 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
273 pub extra: ExtraFields,
274}
275
276#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
277#[serde(rename_all = "camelCase")]
278pub struct EmbedContentBatch {
279 #[serde(skip_serializing_if = "Option::is_none")]
280 pub model: Option<String>,
281 #[serde(skip_serializing_if = "Option::is_none")]
282 pub name: Option<String>,
283 #[serde(skip_serializing_if = "Option::is_none")]
284 pub display_name: Option<String>,
285 #[serde(skip_serializing_if = "Option::is_none")]
286 pub input_config: Option<InputEmbedContentConfig>,
287 #[serde(skip_serializing_if = "Option::is_none")]
288 pub output: Option<EmbedContentBatchOutput>,
289 #[serde(skip_serializing_if = "Option::is_none")]
290 pub create_time: Option<String>,
291 #[serde(skip_serializing_if = "Option::is_none")]
292 pub end_time: Option<String>,
293 #[serde(skip_serializing_if = "Option::is_none")]
294 pub update_time: Option<String>,
295 #[serde(skip_serializing_if = "Option::is_none")]
296 pub batch_stats: Option<BatchStats>,
297 #[serde(skip_serializing_if = "Option::is_none")]
298 pub state: Option<BatchState>,
299 #[serde(skip_serializing_if = "Option::is_none")]
300 pub priority: Option<String>,
301 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
302 pub extra: ExtraFields,
303}
304
305#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
306#[serde(rename_all = "camelCase")]
307pub struct InputEmbedContentConfig {
308 #[serde(flatten, skip_serializing_if = "Option::is_none")]
309 pub source: Option<InputEmbedContentConfigSource>,
310 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
311 pub extra: ExtraFields,
312}
313
314#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
315#[serde(untagged)]
316pub enum InputEmbedContentConfigSource {
317 String {
318 #[serde(rename = "fileName")]
319 file_name: String,
320 },
321 Requests {
322 requests: InlinedEmbedContentRequests,
323 },
324}
325
326#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
327#[serde(rename_all = "camelCase")]
328pub struct InlinedEmbedContentRequests {
329 #[serde(default, skip_serializing_if = "Vec::is_empty")]
330 pub requests: Vec<InlinedEmbedContentRequest>,
331 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
332 pub extra: ExtraFields,
333}
334
335#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
336#[serde(rename_all = "camelCase")]
337pub struct InlinedEmbedContentRequest {
338 #[serde(skip_serializing_if = "Option::is_none")]
339 pub request: Option<EmbedContentRequest>,
340 #[serde(skip_serializing_if = "Option::is_none")]
341 pub metadata: Option<JsonMap>,
342 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
343 pub extra: ExtraFields,
344}
345
346#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
347#[serde(rename_all = "camelCase")]
348pub struct EmbedContentBatchOutput {
349 #[serde(flatten, skip_serializing_if = "Option::is_none")]
350 pub output: Option<EmbedContentBatchOutputData>,
351 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
352 pub extra: ExtraFields,
353}
354
355#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
356#[serde(untagged)]
357pub enum EmbedContentBatchOutputData {
358 ResponsesFile {
359 #[serde(rename = "responsesFile")]
360 responses_file: String,
361 },
362 InlinedResponses {
363 #[serde(rename = "inlinedResponses")]
364 inlined_responses: InlinedEmbedContentResponses,
365 },
366}
367
368#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
369#[serde(rename_all = "camelCase")]
370pub struct InlinedEmbedContentResponses {
371 #[serde(default, skip_serializing_if = "Vec::is_empty")]
372 pub inlined_responses: Vec<InlinedEmbedContentResponse>,
373 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
374 pub extra: ExtraFields,
375}
376
377#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
378#[serde(rename_all = "camelCase")]
379pub struct InlinedEmbedContentResponse {
380 #[serde(skip_serializing_if = "Option::is_none")]
381 pub metadata: Option<JsonMap>,
382 #[serde(flatten, skip_serializing_if = "Option::is_none")]
383 pub output: Option<InlinedEmbedContentResponseOutput>,
384 #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
385 pub extra: ExtraFields,
386}
387
388#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
389#[serde(untagged)]
390pub enum InlinedEmbedContentResponseOutput {
391 Error { error: Status },
392 Response { response: EmbedContentResponse },
393}