1use super::content::ChatMessage;
2use super::content::present_nullable;
3use super::tools::{ChatTool, ToolChoice};
4use crate::{Rest, WireRequest};
5use serde::{Deserialize, Serialize};
6use std::collections::BTreeMap;
7
8#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
9#[serde(rename_all = "snake_case")]
10#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
11#[derive(gproxy_protocol_macros::DeclaredFields)]
12pub struct GenerateContentRequestBody {
13 pub messages: Vec<ChatMessage>,
14 pub model: String,
15 #[serde(
16 default,
17 deserialize_with = "present_nullable",
18 skip_serializing_if = "Option::is_none"
19 )]
20 pub audio: Option<Option<ChatAudioParam>>,
21 #[serde(
22 default,
23 deserialize_with = "present_nullable",
24 skip_serializing_if = "Option::is_none"
25 )]
26 pub frequency_penalty: Option<Option<f64>>,
27 #[serde(skip_serializing_if = "Option::is_none")]
28 pub function_call: Option<FunctionCallChoice>,
29 #[serde(skip_serializing_if = "Option::is_none")]
30 pub functions: Option<Vec<LegacyFunction>>,
31 #[serde(
32 default,
33 deserialize_with = "present_nullable",
34 skip_serializing_if = "Option::is_none"
35 )]
36 pub logit_bias: Option<Option<BTreeMap<String, f64>>>,
37 #[serde(
38 default,
39 deserialize_with = "present_nullable",
40 skip_serializing_if = "Option::is_none"
41 )]
42 pub logprobs: Option<Option<bool>>,
43 #[serde(
44 default,
45 deserialize_with = "present_nullable",
46 skip_serializing_if = "Option::is_none"
47 )]
48 pub max_completion_tokens: Option<Option<i64>>,
49 #[serde(
50 default,
51 deserialize_with = "present_nullable",
52 skip_serializing_if = "Option::is_none"
53 )]
54 pub max_tokens: Option<Option<i64>>,
55 #[serde(
56 default,
57 deserialize_with = "present_nullable",
58 skip_serializing_if = "Option::is_none"
59 )]
60 pub metadata: Option<Option<BTreeMap<String, String>>>,
61 #[serde(
62 default,
63 deserialize_with = "present_nullable",
64 skip_serializing_if = "Option::is_none"
65 )]
66 pub modalities: Option<Option<Vec<Modality>>>,
67 #[serde(
68 default,
69 deserialize_with = "present_nullable",
70 skip_serializing_if = "Option::is_none"
71 )]
72 pub moderation: Option<Option<Moderation>>,
73 #[serde(
74 default,
75 deserialize_with = "present_nullable",
76 skip_serializing_if = "Option::is_none"
77 )]
78 pub n: Option<Option<i64>>,
79 #[serde(skip_serializing_if = "Option::is_none")]
80 pub parallel_tool_calls: Option<bool>,
81 #[serde(
82 default,
83 deserialize_with = "present_nullable",
84 skip_serializing_if = "Option::is_none"
85 )]
86 pub prediction: Option<Option<Prediction>>,
87 #[serde(
88 default,
89 deserialize_with = "present_nullable",
90 skip_serializing_if = "Option::is_none"
91 )]
92 pub presence_penalty: Option<Option<f64>>,
93 #[serde(
94 default,
95 deserialize_with = "present_nullable",
96 skip_serializing_if = "Option::is_none"
97 )]
98 pub prompt_cache_key: Option<Option<String>>,
99 #[serde(skip_serializing_if = "Option::is_none")]
100 pub prompt_cache_options: Option<PromptCacheOptions>,
101 #[serde(
102 default,
103 deserialize_with = "present_nullable",
104 skip_serializing_if = "Option::is_none"
105 )]
106 pub prompt_cache_retention: Option<Option<PromptCacheRetention>>,
107 #[serde(
108 default,
109 deserialize_with = "present_nullable",
110 skip_serializing_if = "Option::is_none"
111 )]
112 pub reasoning_effort: Option<Option<ReasoningEffort>>,
113 #[serde(skip_serializing_if = "Option::is_none")]
114 pub response_format: Option<ResponseFormat>,
115 #[serde(
116 default,
117 deserialize_with = "present_nullable",
118 skip_serializing_if = "Option::is_none"
119 )]
120 pub safety_identifier: Option<Option<String>>,
121 #[serde(
122 default,
123 deserialize_with = "present_nullable",
124 skip_serializing_if = "Option::is_none"
125 )]
126 pub seed: Option<Option<i64>>,
127 #[serde(
128 default,
129 deserialize_with = "present_nullable",
130 skip_serializing_if = "Option::is_none"
131 )]
132 pub service_tier: Option<Option<ServiceTier>>,
133 #[serde(
134 default,
135 deserialize_with = "present_nullable",
136 skip_serializing_if = "Option::is_none"
137 )]
138 pub stop: Option<Option<Stop>>,
139 #[serde(
140 default,
141 deserialize_with = "present_nullable",
142 skip_serializing_if = "Option::is_none"
143 )]
144 pub store: Option<Option<bool>>,
145 #[serde(
146 default,
147 deserialize_with = "present_nullable",
148 skip_serializing_if = "Option::is_none"
149 )]
150 pub stream: Option<Option<bool>>,
151 #[serde(
152 default,
153 deserialize_with = "present_nullable",
154 skip_serializing_if = "Option::is_none"
155 )]
156 pub stream_options: Option<Option<StreamOptions>>,
157 #[serde(
158 default,
159 deserialize_with = "present_nullable",
160 skip_serializing_if = "Option::is_none"
161 )]
162 pub temperature: Option<Option<f64>>,
163 #[serde(skip_serializing_if = "Option::is_none")]
164 pub tool_choice: Option<ToolChoice>,
165 #[serde(skip_serializing_if = "Option::is_none")]
166 pub tools: Option<Vec<ChatTool>>,
167 #[serde(
168 default,
169 deserialize_with = "present_nullable",
170 skip_serializing_if = "Option::is_none"
171 )]
172 pub top_logprobs: Option<Option<i64>>,
173 #[serde(
174 default,
175 deserialize_with = "present_nullable",
176 skip_serializing_if = "Option::is_none"
177 )]
178 pub top_p: Option<Option<f64>>,
179 #[serde(skip_serializing_if = "Option::is_none")]
180 pub user: Option<String>,
181 #[serde(
182 default,
183 deserialize_with = "present_nullable",
184 skip_serializing_if = "Option::is_none"
185 )]
186 pub verbosity: Option<Option<Verbosity>>,
187 #[serde(skip_serializing_if = "Option::is_none")]
188 pub web_search_options: Option<WebSearchOptions>,
189 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
190 pub rest: Rest,
191}
192pub type GenerateContentRequest = WireRequest<GenerateContentRequestBody>;
193
194#[derive(
195 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
196)]
197#[serde(rename_all = "snake_case")]
198#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
199#[derive(gproxy_protocol_macros::DeclaredFields)]
200pub struct ChatAudioParam {
201 pub voice: AudioVoice,
202 pub format: ChatAudioFormat,
203 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
204 pub rest: Rest,
205}
206#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
207#[serde(untagged)]
208#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
209#[derive(gproxy_protocol_macros::DeclaredFields)]
210pub enum AudioVoice {
211 Name(AudioVoiceName),
212 Custom(CustomVoice),
213 String(String),
214}
215#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
216#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
217#[derive(gproxy_protocol_macros::DeclaredFields)]
218pub enum AudioVoiceName {
219 #[serde(rename = "alloy")]
220 Alloy,
221 #[serde(rename = "ash")]
222 Ash,
223 #[serde(rename = "ballad")]
224 Ballad,
225 #[serde(rename = "coral")]
226 Coral,
227 #[serde(rename = "echo")]
228 Echo,
229 #[serde(rename = "fable")]
230 Fable,
231 #[serde(rename = "nova")]
232 Nova,
233 #[serde(rename = "onyx")]
234 Onyx,
235 #[serde(rename = "sage")]
236 Sage,
237 #[serde(rename = "shimmer")]
238 Shimmer,
239 #[serde(rename = "verse")]
240 Verse,
241 #[serde(rename = "marin")]
242 Marin,
243 #[serde(rename = "cedar")]
244 Cedar,
245}
246#[derive(
247 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
248)]
249#[serde(rename_all = "snake_case")]
250#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
251#[derive(gproxy_protocol_macros::DeclaredFields)]
252pub struct CustomVoice {
253 pub id: String,
254 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
255 pub rest: Rest,
256}
257#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
258#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
259#[derive(gproxy_protocol_macros::DeclaredFields)]
260pub enum ChatAudioFormat {
261 #[serde(rename = "wav")]
262 Wav,
263 #[serde(rename = "aac")]
264 Aac,
265 #[serde(rename = "mp3")]
266 Mp3,
267 #[serde(rename = "flac")]
268 Flac,
269 #[serde(rename = "opus")]
270 Opus,
271 #[serde(rename = "pcm16")]
272 Pcm16,
273}
274#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
275#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
276#[derive(gproxy_protocol_macros::DeclaredFields)]
277pub enum Modality {
278 #[serde(rename = "text")]
279 Text,
280 #[serde(rename = "audio")]
281 Audio,
282}
283#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
284#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
285#[derive(gproxy_protocol_macros::DeclaredFields)]
286pub enum FunctionCallMode {
287 #[serde(rename = "none")]
288 None,
289 #[serde(rename = "auto")]
290 Auto,
291}
292#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
293#[serde(untagged)]
294#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
295#[derive(gproxy_protocol_macros::DeclaredFields)]
296pub enum FunctionCallChoice {
297 Mode(FunctionCallMode),
298 Name(LegacyFunctionChoice),
299}
300#[derive(
301 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
302)]
303#[serde(rename_all = "snake_case")]
304#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
305#[derive(gproxy_protocol_macros::DeclaredFields)]
306pub struct LegacyFunctionChoice {
307 pub name: String,
308 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
309 pub rest: Rest,
310}
311#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
312#[serde(rename_all = "snake_case")]
313#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
314#[derive(gproxy_protocol_macros::DeclaredFields)]
315pub struct LegacyFunction {
316 pub name: String,
317 #[serde(skip_serializing_if = "Option::is_none")]
318 pub description: Option<String>,
319 #[serde(skip_serializing_if = "Option::is_none")]
320 pub parameters: Option<Rest>,
321 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
322 pub rest: Rest,
323}
324#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
325#[serde(rename_all = "snake_case")]
326#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
327#[derive(gproxy_protocol_macros::DeclaredFields)]
328pub struct Moderation {
329 pub model: String,
330 #[serde(
331 default,
332 deserialize_with = "present_nullable",
333 skip_serializing_if = "Option::is_none"
334 )]
335 pub policy: Option<Option<ModerationPolicy>>,
336 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
337 pub rest: Rest,
338}
339#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
340#[serde(rename_all = "snake_case")]
341#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
342#[derive(gproxy_protocol_macros::DeclaredFields)]
343pub struct ModerationPolicy {
344 #[serde(
345 default,
346 deserialize_with = "present_nullable",
347 skip_serializing_if = "Option::is_none"
348 )]
349 pub input: Option<Option<ModerationMode>>,
350 #[serde(
351 default,
352 deserialize_with = "present_nullable",
353 skip_serializing_if = "Option::is_none"
354 )]
355 pub output: Option<Option<ModerationMode>>,
356 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
357 pub rest: Rest,
358}
359#[derive(
360 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
361)]
362#[serde(rename_all = "snake_case")]
363#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
364#[derive(gproxy_protocol_macros::DeclaredFields)]
365pub struct ModerationMode {
366 pub mode: ModerationModeType,
367 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
368 pub rest: Rest,
369}
370#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
371#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
372#[derive(gproxy_protocol_macros::DeclaredFields)]
373pub enum ModerationModeType {
374 #[serde(rename = "score")]
375 Score,
376 #[serde(rename = "block")]
377 Block,
378}
379#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
380#[serde(rename_all = "snake_case")]
381#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
382#[derive(gproxy_protocol_macros::DeclaredFields)]
383pub struct Prediction {
384 #[serde(rename = "type")]
385 pub type_: PredictionType,
386 pub content: super::content::TextContent,
387 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
388 pub rest: Rest,
389}
390#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
391#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
392#[derive(gproxy_protocol_macros::DeclaredFields)]
393pub enum PredictionType {
394 #[serde(rename = "content")]
395 Content,
396}
397#[derive(
398 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
399)]
400#[serde(rename_all = "snake_case")]
401#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
402#[derive(gproxy_protocol_macros::DeclaredFields)]
403pub struct PromptCacheOptions {
404 #[serde(skip_serializing_if = "Option::is_none")]
405 pub mode: Option<PromptCacheOptionMode>,
406 #[serde(skip_serializing_if = "Option::is_none")]
407 pub ttl: Option<PromptCacheTtl>,
408 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
409 pub rest: Rest,
410}
411#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
412#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
413#[derive(gproxy_protocol_macros::DeclaredFields)]
414pub enum PromptCacheOptionMode {
415 #[serde(rename = "implicit")]
416 Implicit,
417 #[serde(rename = "explicit")]
418 Explicit,
419}
420#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
421#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
422#[derive(gproxy_protocol_macros::DeclaredFields)]
423pub enum PromptCacheTtl {
424 #[serde(rename = "30m")]
425 ThirtyMinutes,
426}
427#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
428#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
429#[derive(gproxy_protocol_macros::DeclaredFields)]
430pub enum PromptCacheRetention {
431 #[serde(rename = "in_memory")]
432 InMemory,
433 #[serde(rename = "24h")]
434 TwentyFourHours,
435}
436#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
437#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
438#[derive(gproxy_protocol_macros::DeclaredFields)]
439pub enum ReasoningEffort {
440 #[serde(rename = "none")]
441 None,
442 #[serde(rename = "minimal")]
443 Minimal,
444 #[serde(rename = "low")]
445 Low,
446 #[serde(rename = "medium")]
447 Medium,
448 #[serde(rename = "high")]
449 High,
450 #[serde(rename = "xhigh")]
451 XHigh,
452 #[serde(rename = "max")]
453 Max,
454}
455#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
456#[serde(untagged)]
457#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
458#[derive(gproxy_protocol_macros::DeclaredFields)]
459pub enum ResponseFormat {
460 Text(TextResponseFormat),
461 JsonSchema(JsonSchemaResponseFormat),
462 JsonObject(JsonObjectResponseFormat),
463}
464#[derive(
465 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
466)]
467#[serde(rename_all = "snake_case")]
468#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
469#[derive(gproxy_protocol_macros::DeclaredFields)]
470pub struct TextResponseFormat {
471 #[serde(rename = "type")]
472 pub type_: TextResponseType,
473 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
474 pub rest: Rest,
475}
476#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
477#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
478#[derive(gproxy_protocol_macros::DeclaredFields)]
479pub enum TextResponseType {
480 #[serde(rename = "text")]
481 Text,
482}
483#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
484#[serde(rename_all = "snake_case")]
485#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
486#[derive(gproxy_protocol_macros::DeclaredFields)]
487pub struct JsonSchemaResponseFormat {
488 #[serde(rename = "type")]
489 pub type_: JsonSchemaResponseType,
490 pub json_schema: JsonSchemaFormat,
491 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
492 pub rest: Rest,
493}
494#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
495#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
496#[derive(gproxy_protocol_macros::DeclaredFields)]
497pub enum JsonSchemaResponseType {
498 #[serde(rename = "json_schema")]
499 JsonSchema,
500}
501#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
502#[serde(rename_all = "snake_case")]
503#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
504#[derive(gproxy_protocol_macros::DeclaredFields)]
505pub struct JsonSchemaFormat {
506 pub name: String,
507 #[serde(skip_serializing_if = "Option::is_none")]
508 pub description: Option<String>,
509 #[serde(skip_serializing_if = "Option::is_none")]
510 pub schema: Option<Rest>,
511 #[serde(
512 default,
513 deserialize_with = "present_nullable",
514 skip_serializing_if = "Option::is_none"
515 )]
516 pub strict: Option<Option<bool>>,
517 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
518 pub rest: Rest,
519}
520#[derive(
521 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
522)]
523#[serde(rename_all = "snake_case")]
524#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
525#[derive(gproxy_protocol_macros::DeclaredFields)]
526pub struct JsonObjectResponseFormat {
527 #[serde(rename = "type")]
528 pub type_: JsonObjectResponseType,
529 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
530 pub rest: Rest,
531}
532#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
533#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
534#[derive(gproxy_protocol_macros::DeclaredFields)]
535pub enum JsonObjectResponseType {
536 #[serde(rename = "json_object")]
537 JsonObject,
538}
539#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
540#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
541#[derive(gproxy_protocol_macros::DeclaredFields)]
542pub enum ServiceTier {
543 #[serde(rename = "auto")]
544 Auto,
545 #[serde(rename = "default")]
546 Default,
547 #[serde(rename = "flex")]
548 Flex,
549 #[serde(rename = "scale")]
550 Scale,
551 #[serde(rename = "priority")]
552 Priority,
553 #[serde(rename = "fast")]
554 Fast,
555 #[serde(rename = "ultrafast")]
556 Ultrafast,
557}
558#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
559#[serde(untagged)]
560#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
561#[derive(gproxy_protocol_macros::DeclaredFields)]
562pub enum Stop {
563 String(String),
564 Sequences(Vec<String>),
565}
566#[derive(
567 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
568)]
569#[serde(rename_all = "snake_case")]
570#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
571#[derive(gproxy_protocol_macros::DeclaredFields)]
572pub struct StreamOptions {
573 #[serde(skip_serializing_if = "Option::is_none")]
574 pub include_obfuscation: Option<bool>,
575 #[serde(skip_serializing_if = "Option::is_none")]
576 pub include_usage: Option<bool>,
577 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
578 pub rest: Rest,
579}
580#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
581#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
582#[derive(gproxy_protocol_macros::DeclaredFields)]
583pub enum Verbosity {
584 #[serde(rename = "low")]
585 Low,
586 #[serde(rename = "medium")]
587 Medium,
588 #[serde(rename = "high")]
589 High,
590}
591#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
592#[serde(rename_all = "snake_case")]
593#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
594#[derive(gproxy_protocol_macros::DeclaredFields)]
595pub struct WebSearchOptions {
596 #[serde(skip_serializing_if = "Option::is_none")]
597 pub search_context_size: Option<SearchContextSize>,
598 #[serde(
599 default,
600 deserialize_with = "present_nullable",
601 skip_serializing_if = "Option::is_none"
602 )]
603 pub user_location: Option<Option<UserLocation>>,
604 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
605 pub rest: Rest,
606}
607#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
608#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
609#[derive(gproxy_protocol_macros::DeclaredFields)]
610pub enum SearchContextSize {
611 #[serde(rename = "low")]
612 Low,
613 #[serde(rename = "medium")]
614 Medium,
615 #[serde(rename = "high")]
616 High,
617}
618#[derive(
619 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
620)]
621#[serde(rename_all = "snake_case")]
622#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
623#[derive(gproxy_protocol_macros::DeclaredFields)]
624pub struct UserLocation {
625 #[serde(rename = "type")]
626 pub type_: UserLocationType,
627 pub approximate: ApproximateLocation,
628 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
629 pub rest: Rest,
630}
631#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
632#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
633#[derive(gproxy_protocol_macros::DeclaredFields)]
634pub enum UserLocationType {
635 #[serde(rename = "approximate")]
636 Approximate,
637}
638#[derive(
639 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
640)]
641#[serde(rename_all = "snake_case")]
642#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
643#[derive(gproxy_protocol_macros::DeclaredFields)]
644pub struct ApproximateLocation {
645 #[serde(skip_serializing_if = "Option::is_none")]
646 pub city: Option<String>,
647 #[serde(skip_serializing_if = "Option::is_none")]
648 pub country: Option<String>,
649 #[serde(skip_serializing_if = "Option::is_none")]
650 pub region: Option<String>,
651 #[serde(skip_serializing_if = "Option::is_none")]
652 pub timezone: Option<String>,
653 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
654 pub rest: Rest,
655}