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