1use crate::serde_helpers::double_option;
4
5#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6pub struct AccessToken {
7 #[serde(default, skip_serializing_if = "Option::is_none")]
8 pub access_token: Option<String>,
9 #[serde(default, skip_serializing_if = "Option::is_none")]
10 pub expires_in: Option<i64>,
11 #[serde(default, skip_serializing_if = "Option::is_none")]
12 pub token_type: Option<AccessTokenTokenType>,
13 #[serde(default, skip_serializing_if = "Option::is_none")]
14 pub restricted_to: Option<Vec<ResourceScope>>,
15 #[serde(default, skip_serializing_if = "Option::is_none")]
16 pub refresh_token: Option<String>,
17 #[serde(default, skip_serializing_if = "Option::is_none")]
18 pub issued_token_type: Option<AccessTokenIssuedTokenType>,
19}
20
21#[derive(Clone, Debug, PartialEq)]
22pub enum AiAgent {
23 AiAgentAsk(AiAgentAsk),
24 AiAgentTextGen(AiAgentTextGen),
25 AiAgentExtract(AiAgentExtract),
26 AiAgentExtractStructured(AiAgentExtractStructured),
27 Unknown(serde_json::Value),
29}
30
31impl serde::Serialize for AiAgent {
32 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
33 match self {
34 Self::AiAgentAsk(inner) => inner.serialize(serializer),
35 Self::AiAgentTextGen(inner) => inner.serialize(serializer),
36 Self::AiAgentExtract(inner) => inner.serialize(serializer),
37 Self::AiAgentExtractStructured(inner) => inner.serialize(serializer),
38 Self::Unknown(inner) => inner.serialize(serializer),
39 }
40 }
41}
42
43impl<'de> serde::Deserialize<'de> for AiAgent {
44 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
45 let value = serde_json::Value::deserialize(deserializer)?;
46 let tag = value
47 .get("type")
48 .and_then(serde_json::Value::as_str)
49 .map(str::to_owned);
50 match tag.as_deref() {
51 Some("ai_agent_ask") => Ok(Self::AiAgentAsk(
52 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
53 )),
54 Some("ai_agent_text_gen") => Ok(Self::AiAgentTextGen(
55 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
56 )),
57 Some("ai_agent_extract") => Ok(Self::AiAgentExtract(
58 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
59 )),
60 Some("ai_agent_extract_structured") => Ok(Self::AiAgentExtractStructured(
61 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
62 )),
63 _ => Ok(Self::Unknown(value)),
64 }
65 }
66}
67
68#[derive(Clone, Debug, PartialEq)]
69pub enum AiAgentAllowedEntity {
70 User(UserBase),
71 Group(GroupBase),
72 Unknown(serde_json::Value),
74}
75
76impl serde::Serialize for AiAgentAllowedEntity {
77 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
78 match self {
79 Self::User(inner) => inner.serialize(serializer),
80 Self::Group(inner) => inner.serialize(serializer),
81 Self::Unknown(inner) => inner.serialize(serializer),
82 }
83 }
84}
85
86impl<'de> serde::Deserialize<'de> for AiAgentAllowedEntity {
87 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
88 let value = serde_json::Value::deserialize(deserializer)?;
89 let tag = value
90 .get("type")
91 .and_then(serde_json::Value::as_str)
92 .map(str::to_owned);
93 match tag.as_deref() {
94 Some("user") => Ok(Self::User(
95 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
96 )),
97 Some("group") => Ok(Self::Group(
98 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
99 )),
100 _ => Ok(Self::Unknown(value)),
101 }
102 }
103}
104
105#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
106pub struct AiAgentAsk {
107 pub r#type: AiAgentAskType,
108 #[serde(default, skip_serializing_if = "Option::is_none")]
109 pub long_text: Option<AiAgentLongTextTool>,
110 #[serde(default, skip_serializing_if = "Option::is_none")]
111 pub basic_text: Option<AiAgentBasicTextTool>,
112 #[serde(default, skip_serializing_if = "Option::is_none")]
113 pub spreadsheet: Option<AiAgentSpreadsheetTool>,
114 #[serde(default, skip_serializing_if = "Option::is_none")]
115 pub long_text_multi: Option<AiAgentLongTextTool>,
116 #[serde(default, skip_serializing_if = "Option::is_none")]
117 pub basic_text_multi: Option<AiAgentBasicTextTool>,
118 #[serde(default, skip_serializing_if = "Option::is_none")]
119 pub basic_image: Option<AiAgentBasicTextTool>,
120 #[serde(default, skip_serializing_if = "Option::is_none")]
121 pub basic_image_multi: Option<AiAgentBasicTextTool>,
122}
123
124#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
125pub struct AiAgentBasicGenTool {
126 #[serde(default, skip_serializing_if = "Option::is_none")]
127 pub model: Option<String>,
128 #[serde(default, skip_serializing_if = "Option::is_none")]
129 pub num_tokens_for_completion: Option<i64>,
130 #[serde(default, skip_serializing_if = "Option::is_none")]
131 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
132 #[serde(default, skip_serializing_if = "Option::is_none")]
133 pub system_message: Option<String>,
134 #[serde(default, skip_serializing_if = "Option::is_none")]
135 pub prompt_template: Option<String>,
136 #[serde(default, skip_serializing_if = "Option::is_none")]
137 pub embeddings: Option<AiAgentBasicGenToolEmbeddings>,
138 #[serde(default, skip_serializing_if = "Option::is_none")]
139 pub content_template: Option<String>,
140}
141
142#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
143pub struct AiAgentBasicTextTool {
144 #[serde(default, skip_serializing_if = "Option::is_none")]
145 pub model: Option<String>,
146 #[serde(default, skip_serializing_if = "Option::is_none")]
147 pub num_tokens_for_completion: Option<i64>,
148 #[serde(default, skip_serializing_if = "Option::is_none")]
149 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
150 #[serde(default, skip_serializing_if = "Option::is_none")]
151 pub system_message: Option<String>,
152 #[serde(default, skip_serializing_if = "Option::is_none")]
153 pub prompt_template: Option<String>,
154}
155
156#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
157pub struct AiAgentBasicTextToolBase {
158 #[serde(default, skip_serializing_if = "Option::is_none")]
159 pub model: Option<String>,
160 #[serde(default, skip_serializing_if = "Option::is_none")]
161 pub num_tokens_for_completion: Option<i64>,
162 #[serde(default, skip_serializing_if = "Option::is_none")]
163 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
164}
165
166#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
167pub struct AiAgentBasicTextToolTextGen {
168 #[serde(default, skip_serializing_if = "Option::is_none")]
169 pub model: Option<String>,
170 #[serde(default, skip_serializing_if = "Option::is_none")]
171 pub num_tokens_for_completion: Option<i64>,
172 #[serde(default, skip_serializing_if = "Option::is_none")]
173 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
174 #[serde(default, skip_serializing_if = "Option::is_none")]
175 pub system_message: Option<String>,
176 #[serde(default, skip_serializing_if = "Option::is_none")]
177 pub prompt_template: Option<String>,
178}
179
180#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
181pub struct AiAgentExtract {
182 pub r#type: AiAgentExtractType,
183 #[serde(default, skip_serializing_if = "Option::is_none")]
184 pub long_text: Option<AiAgentLongTextTool>,
185 #[serde(default, skip_serializing_if = "Option::is_none")]
186 pub basic_text: Option<AiAgentBasicTextTool>,
187 #[serde(default, skip_serializing_if = "Option::is_none")]
188 pub basic_image: Option<AiAgentBasicTextTool>,
189}
190
191#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
192pub struct AiAgentExtractStructured {
193 pub r#type: AiAgentExtractStructuredType,
194 #[serde(default, skip_serializing_if = "Option::is_none")]
195 pub long_text: Option<AiAgentLongTextTool>,
196 #[serde(default, skip_serializing_if = "Option::is_none")]
197 pub basic_text: Option<AiAgentBasicTextTool>,
198 #[serde(default, skip_serializing_if = "Option::is_none")]
199 pub basic_image: Option<AiAgentBasicTextTool>,
200}
201
202#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
203pub struct AiAgentInfo {
204 #[serde(default, skip_serializing_if = "Option::is_none")]
205 pub models: Option<Vec<AiAgentInfoModels>>,
206 #[serde(default, skip_serializing_if = "Option::is_none")]
207 pub processor: Option<String>,
208}
209
210#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
211pub struct AiAgentLongTextTool {
212 #[serde(default, skip_serializing_if = "Option::is_none")]
213 pub model: Option<String>,
214 #[serde(default, skip_serializing_if = "Option::is_none")]
215 pub num_tokens_for_completion: Option<i64>,
216 #[serde(default, skip_serializing_if = "Option::is_none")]
217 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
218 #[serde(default, skip_serializing_if = "Option::is_none")]
219 pub system_message: Option<String>,
220 #[serde(default, skip_serializing_if = "Option::is_none")]
221 pub prompt_template: Option<String>,
222 #[serde(default, skip_serializing_if = "Option::is_none")]
223 pub embeddings: Option<AiAgentBasicGenToolEmbeddings>,
224}
225
226#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
227pub struct AiAgentLongTextToolTextGen {
228 #[serde(default, skip_serializing_if = "Option::is_none")]
229 pub model: Option<String>,
230 #[serde(default, skip_serializing_if = "Option::is_none")]
231 pub num_tokens_for_completion: Option<i64>,
232 #[serde(default, skip_serializing_if = "Option::is_none")]
233 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
234 #[serde(default, skip_serializing_if = "Option::is_none")]
235 pub system_message: Option<String>,
236 #[serde(default, skip_serializing_if = "Option::is_none")]
237 pub prompt_template: Option<String>,
238 #[serde(default, skip_serializing_if = "Option::is_none")]
239 pub embeddings: Option<AiAgentBasicGenToolEmbeddings>,
240}
241
242#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
243pub struct AiAgentReference {
244 pub r#type: AiAgentReferenceType,
245 pub id: String,
246}
247
248#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
249pub struct AiAgentSpreadsheetTool {
250 #[serde(default, skip_serializing_if = "Option::is_none")]
251 pub model: Option<String>,
252 #[serde(default, skip_serializing_if = "Option::is_none")]
253 pub num_tokens_for_completion: Option<i64>,
254 #[serde(default, skip_serializing_if = "Option::is_none")]
255 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
256}
257
258#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
259pub struct AiAgentTextGen {
260 pub r#type: AiAgentTextGenType,
261 #[serde(default, skip_serializing_if = "Option::is_none")]
262 pub basic_gen: Option<AiAgentBasicGenTool>,
263}
264
265#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
266pub struct AiAsk {
267 pub mode: AiAskMode,
268 pub prompt: String,
269 pub items: Vec<AiItemAsk>,
270 #[serde(default, skip_serializing_if = "Option::is_none")]
271 pub dialogue_history: Option<Vec<AiDialogueHistory>>,
272 #[serde(default, skip_serializing_if = "Option::is_none")]
273 pub include_citations: Option<bool>,
274 #[serde(default, skip_serializing_if = "Option::is_none")]
275 pub ai_agent: Option<AiAskAgent>,
276}
277
278#[derive(Clone, Debug, PartialEq)]
279pub enum AiAskAgent {
280 AiAgentId(AiAgentReference),
281 AiAgentAsk(AiAgentAsk),
282 Unknown(serde_json::Value),
284}
285
286impl serde::Serialize for AiAskAgent {
287 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
288 match self {
289 Self::AiAgentId(inner) => inner.serialize(serializer),
290 Self::AiAgentAsk(inner) => inner.serialize(serializer),
291 Self::Unknown(inner) => inner.serialize(serializer),
292 }
293 }
294}
295
296impl<'de> serde::Deserialize<'de> for AiAskAgent {
297 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
298 let value = serde_json::Value::deserialize(deserializer)?;
299 let tag = value
300 .get("type")
301 .and_then(serde_json::Value::as_str)
302 .map(str::to_owned);
303 match tag.as_deref() {
304 Some("ai_agent_id") => Ok(Self::AiAgentId(
305 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
306 )),
307 Some("ai_agent_ask") => Ok(Self::AiAgentAsk(
308 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
309 )),
310 _ => Ok(Self::Unknown(value)),
311 }
312 }
313}
314
315#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
316pub struct AiCitation {
317 #[serde(default, skip_serializing_if = "Option::is_none")]
318 pub content: Option<String>,
319 #[serde(default, skip_serializing_if = "Option::is_none")]
320 pub id: Option<String>,
321 #[serde(default, skip_serializing_if = "Option::is_none")]
322 pub r#type: Option<AiCitationType>,
323 #[serde(default, skip_serializing_if = "Option::is_none")]
324 pub name: Option<String>,
325}
326
327#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
328pub struct AiDialogueHistory {
329 #[serde(default, skip_serializing_if = "Option::is_none")]
330 pub prompt: Option<String>,
331 #[serde(default, skip_serializing_if = "Option::is_none")]
332 pub answer: Option<String>,
333 #[serde(default, skip_serializing_if = "Option::is_none")]
334 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
335}
336
337#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
338pub struct AiExtract {
339 pub prompt: String,
340 pub items: Vec<AiItemBase>,
341 #[serde(default, skip_serializing_if = "Option::is_none")]
342 pub ai_agent: Option<AiExtractAgent>,
343}
344
345#[derive(Clone, Debug, PartialEq)]
346pub enum AiExtractAgent {
347 AiAgentId(AiAgentReference),
348 AiAgentExtract(AiAgentExtract),
349 Unknown(serde_json::Value),
351}
352
353impl serde::Serialize for AiExtractAgent {
354 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
355 match self {
356 Self::AiAgentId(inner) => inner.serialize(serializer),
357 Self::AiAgentExtract(inner) => inner.serialize(serializer),
358 Self::Unknown(inner) => inner.serialize(serializer),
359 }
360 }
361}
362
363impl<'de> serde::Deserialize<'de> for AiExtractAgent {
364 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
365 let value = serde_json::Value::deserialize(deserializer)?;
366 let tag = value
367 .get("type")
368 .and_then(serde_json::Value::as_str)
369 .map(str::to_owned);
370 match tag.as_deref() {
371 Some("ai_agent_id") => Ok(Self::AiAgentId(
372 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
373 )),
374 Some("ai_agent_extract") => Ok(Self::AiAgentExtract(
375 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
376 )),
377 _ => Ok(Self::Unknown(value)),
378 }
379 }
380}
381
382#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
383pub struct AiExtractFieldOption {
384 pub key: String,
385}
386
387#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
388pub struct AiExtractResponse {}
389
390#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
391pub struct AiExtractStructured {
392 pub items: Vec<AiItemBase>,
393 #[serde(default, skip_serializing_if = "Option::is_none")]
394 pub metadata_template: Option<AiExtractStructuredMetadataTemplate>,
395 #[serde(default, skip_serializing_if = "Option::is_none")]
396 pub fields: Option<Vec<AiExtractStructuredFields>>,
397 #[serde(default, skip_serializing_if = "Option::is_none")]
398 pub ai_agent: Option<AiExtractStructuredAgent>,
399 #[serde(default, skip_serializing_if = "Option::is_none")]
400 pub include_confidence_score: Option<bool>,
401 #[serde(default, skip_serializing_if = "Option::is_none")]
402 pub include_reference: Option<bool>,
403 #[serde(default, skip_serializing_if = "Option::is_none")]
404 pub taxonomy_sources: Option<Vec<AiTaxonomySource>>,
405}
406
407#[derive(Clone, Debug, PartialEq)]
408pub enum AiExtractStructuredAgent {
409 AiAgentId(AiAgentReference),
410 AiAgentExtractStructured(AiAgentExtractStructured),
411 Unknown(serde_json::Value),
413}
414
415impl serde::Serialize for AiExtractStructuredAgent {
416 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
417 match self {
418 Self::AiAgentId(inner) => inner.serialize(serializer),
419 Self::AiAgentExtractStructured(inner) => inner.serialize(serializer),
420 Self::Unknown(inner) => inner.serialize(serializer),
421 }
422 }
423}
424
425impl<'de> serde::Deserialize<'de> for AiExtractStructuredAgent {
426 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
427 let value = serde_json::Value::deserialize(deserializer)?;
428 let tag = value
429 .get("type")
430 .and_then(serde_json::Value::as_str)
431 .map(str::to_owned);
432 match tag.as_deref() {
433 Some("ai_agent_id") => Ok(Self::AiAgentId(
434 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
435 )),
436 Some("ai_agent_extract_structured") => Ok(Self::AiAgentExtractStructured(
437 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
438 )),
439 _ => Ok(Self::Unknown(value)),
440 }
441 }
442}
443
444#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
445pub struct AiExtractStructuredResponse {
446 pub answer: AiExtractResponse,
447 pub created_at: chrono::DateTime<chrono::Utc>,
448 #[serde(default, skip_serializing_if = "Option::is_none")]
449 pub completion_reason: Option<String>,
450 #[serde(default, skip_serializing_if = "Option::is_none")]
451 pub confidence_score: Option<std::collections::HashMap<String, serde_json::Value>>,
452 #[serde(default, skip_serializing_if = "Option::is_none")]
453 pub reference: Option<std::collections::HashMap<String, serde_json::Value>>,
454 #[serde(default, skip_serializing_if = "Option::is_none")]
455 pub ai_agent_info: Option<AiAgentInfo>,
456}
457
458#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
459pub struct AiExtractSubField {
460 pub key: String,
461 #[serde(default, skip_serializing_if = "Option::is_none")]
462 pub description: Option<String>,
463 #[serde(
464 rename = "displayName",
465 default,
466 skip_serializing_if = "Option::is_none"
467 )]
468 pub display_name: Option<String>,
469 #[serde(default, skip_serializing_if = "Option::is_none")]
470 pub prompt: Option<String>,
471 #[serde(default, skip_serializing_if = "Option::is_none")]
472 pub r#type: Option<String>,
473 #[serde(default, skip_serializing_if = "Option::is_none")]
474 pub options: Option<Vec<AiExtractFieldOption>>,
475}
476
477#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
478pub struct AiItemBase {
479 pub id: String,
480 pub r#type: AiCitationType,
481 #[serde(default, skip_serializing_if = "Option::is_none")]
482 pub content: Option<String>,
483}
484
485#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
486pub struct AiItemAsk {
487 pub id: String,
488 pub r#type: AiItemAskType,
489 #[serde(default, skip_serializing_if = "Option::is_none")]
490 pub content: Option<String>,
491}
492
493#[derive(Clone, Debug, PartialEq)]
494pub enum AiLlmEndpointParams {
495 OpenaiParams(AiLlmEndpointParamsOpenAi),
496 GoogleParams(AiLlmEndpointParamsGoogle),
497 AwsParams(AiLlmEndpointParamsAWS),
498 IbmParams(AiLlmEndpointParamsIBM),
499 Unknown(serde_json::Value),
501}
502
503impl serde::Serialize for AiLlmEndpointParams {
504 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
505 match self {
506 Self::OpenaiParams(inner) => inner.serialize(serializer),
507 Self::GoogleParams(inner) => inner.serialize(serializer),
508 Self::AwsParams(inner) => inner.serialize(serializer),
509 Self::IbmParams(inner) => inner.serialize(serializer),
510 Self::Unknown(inner) => inner.serialize(serializer),
511 }
512 }
513}
514
515impl<'de> serde::Deserialize<'de> for AiLlmEndpointParams {
516 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
517 let value = serde_json::Value::deserialize(deserializer)?;
518 let tag = value
519 .get("type")
520 .and_then(serde_json::Value::as_str)
521 .map(str::to_owned);
522 match tag.as_deref() {
523 Some("openai_params") => Ok(Self::OpenaiParams(
524 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
525 )),
526 Some("google_params") => Ok(Self::GoogleParams(
527 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
528 )),
529 Some("aws_params") => Ok(Self::AwsParams(
530 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
531 )),
532 Some("ibm_params") => Ok(Self::IbmParams(
533 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
534 )),
535 _ => Ok(Self::Unknown(value)),
536 }
537 }
538}
539
540#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
541pub struct AiLlmEndpointParamsAWS {
542 pub r#type: AiLlmEndpointParamsAWSType,
543 #[serde(
544 default,
545 skip_serializing_if = "Option::is_none",
546 deserialize_with = "double_option"
547 )]
548 pub temperature: Option<Option<f64>>,
549 #[serde(
550 default,
551 skip_serializing_if = "Option::is_none",
552 deserialize_with = "double_option"
553 )]
554 pub top_p: Option<Option<f64>>,
555}
556
557#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
558pub struct AiLlmEndpointParamsGoogle {
559 pub r#type: AiLlmEndpointParamsGoogleType,
560 #[serde(
561 default,
562 skip_serializing_if = "Option::is_none",
563 deserialize_with = "double_option"
564 )]
565 pub temperature: Option<Option<f64>>,
566 #[serde(
567 default,
568 skip_serializing_if = "Option::is_none",
569 deserialize_with = "double_option"
570 )]
571 pub top_p: Option<Option<f64>>,
572 #[serde(
573 default,
574 skip_serializing_if = "Option::is_none",
575 deserialize_with = "double_option"
576 )]
577 pub top_k: Option<Option<f64>>,
578}
579
580#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
581pub struct AiLlmEndpointParamsIBM {
582 pub r#type: AiLlmEndpointParamsIBMType,
583 #[serde(
584 default,
585 skip_serializing_if = "Option::is_none",
586 deserialize_with = "double_option"
587 )]
588 pub temperature: Option<Option<f64>>,
589 #[serde(
590 default,
591 skip_serializing_if = "Option::is_none",
592 deserialize_with = "double_option"
593 )]
594 pub top_p: Option<Option<f64>>,
595 #[serde(
596 default,
597 skip_serializing_if = "Option::is_none",
598 deserialize_with = "double_option"
599 )]
600 pub top_k: Option<Option<f64>>,
601}
602
603#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
604pub struct AiLlmEndpointParamsOpenAi {
605 pub r#type: AiLlmEndpointParamsOpenAiType,
606 #[serde(
607 default,
608 skip_serializing_if = "Option::is_none",
609 deserialize_with = "double_option"
610 )]
611 pub temperature: Option<Option<f64>>,
612 #[serde(
613 default,
614 skip_serializing_if = "Option::is_none",
615 deserialize_with = "double_option"
616 )]
617 pub top_p: Option<Option<f64>>,
618 #[serde(
619 default,
620 skip_serializing_if = "Option::is_none",
621 deserialize_with = "double_option"
622 )]
623 pub frequency_penalty: Option<Option<f64>>,
624 #[serde(
625 default,
626 skip_serializing_if = "Option::is_none",
627 deserialize_with = "double_option"
628 )]
629 pub presence_penalty: Option<Option<f64>>,
630 #[serde(
631 default,
632 skip_serializing_if = "Option::is_none",
633 deserialize_with = "double_option"
634 )]
635 pub stop: Option<Option<String>>,
636}
637
638#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
639pub struct AiMultipleAgentResponse {
640 #[serde(default, skip_serializing_if = "Option::is_none")]
641 pub limit: Option<i64>,
642 #[serde(
643 default,
644 skip_serializing_if = "Option::is_none",
645 deserialize_with = "double_option"
646 )]
647 pub next_marker: Option<Option<String>>,
648 #[serde(
649 default,
650 skip_serializing_if = "Option::is_none",
651 deserialize_with = "double_option"
652 )]
653 pub prev_marker: Option<Option<String>>,
654 pub entries: Vec<AiSingleAgentResponseFull>,
655}
656
657#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
658pub struct AiOptionsRules {
659 #[serde(default, skip_serializing_if = "Option::is_none")]
660 pub multi_select: Option<bool>,
661 #[serde(default, skip_serializing_if = "Option::is_none")]
662 pub selectable_levels: Option<Vec<i64>>,
663}
664
665#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
666pub struct AiResponse {
667 pub answer: String,
668 pub created_at: chrono::DateTime<chrono::Utc>,
669 #[serde(default, skip_serializing_if = "Option::is_none")]
670 pub completion_reason: Option<String>,
671 #[serde(default, skip_serializing_if = "Option::is_none")]
672 pub ai_agent_info: Option<AiAgentInfo>,
673}
674
675#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
676pub struct AiResponseFull {
677 pub answer: String,
678 pub created_at: chrono::DateTime<chrono::Utc>,
679 #[serde(default, skip_serializing_if = "Option::is_none")]
680 pub completion_reason: Option<String>,
681 #[serde(default, skip_serializing_if = "Option::is_none")]
682 pub ai_agent_info: Option<AiAgentInfo>,
683 #[serde(default, skip_serializing_if = "Option::is_none")]
684 pub citations: Option<Vec<AiCitation>>,
685}
686
687#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
688pub struct AiSingleAgentResponse {
689 pub id: String,
690 #[serde(default, skip_serializing_if = "Option::is_none")]
691 pub r#type: Option<AiSingleAgentResponseType>,
692 pub origin: String,
693 pub name: String,
694 pub access_state: String,
695 #[serde(default, skip_serializing_if = "Option::is_none")]
696 pub created_by: Option<UserBase>,
697 #[serde(default, skip_serializing_if = "Option::is_none")]
698 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
699 #[serde(default, skip_serializing_if = "Option::is_none")]
700 pub modified_by: Option<UserBase>,
701 #[serde(default, skip_serializing_if = "Option::is_none")]
702 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
703 #[serde(default, skip_serializing_if = "Option::is_none")]
704 pub icon_reference: Option<String>,
705 #[serde(default, skip_serializing_if = "Option::is_none")]
706 pub allowed_entities: Option<Vec<AiAgentAllowedEntity>>,
707}
708
709#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
710pub struct AiSingleAgentResponseFull {
711 pub id: String,
712 #[serde(default, skip_serializing_if = "Option::is_none")]
713 pub r#type: Option<AiSingleAgentResponseType>,
714 pub origin: String,
715 pub name: String,
716 pub access_state: String,
717 #[serde(default, skip_serializing_if = "Option::is_none")]
718 pub created_by: Option<UserBase>,
719 #[serde(default, skip_serializing_if = "Option::is_none")]
720 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
721 #[serde(default, skip_serializing_if = "Option::is_none")]
722 pub modified_by: Option<UserBase>,
723 #[serde(default, skip_serializing_if = "Option::is_none")]
724 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
725 #[serde(default, skip_serializing_if = "Option::is_none")]
726 pub icon_reference: Option<String>,
727 #[serde(default, skip_serializing_if = "Option::is_none")]
728 pub allowed_entities: Option<Vec<AiAgentAllowedEntity>>,
729 #[serde(default, skip_serializing_if = "Option::is_none")]
730 pub ask: Option<AiStudioAgentAskResponse>,
731 #[serde(default, skip_serializing_if = "Option::is_none")]
732 pub text_gen: Option<AiStudioAgentTextGenResponse>,
733 #[serde(default, skip_serializing_if = "Option::is_none")]
734 pub extract: Option<AiStudioAgentExtractResponse>,
735}
736
737#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
738pub struct AiStudioAgentAsk {
739 pub r#type: AiAgentAskType,
740 pub access_state: String,
741 pub description: String,
742 #[serde(
743 default,
744 skip_serializing_if = "Option::is_none",
745 deserialize_with = "double_option"
746 )]
747 pub custom_instructions: Option<Option<String>>,
748 #[serde(default, skip_serializing_if = "Option::is_none")]
749 pub suggested_questions: Option<Vec<String>>,
750 #[serde(default, skip_serializing_if = "Option::is_none")]
751 pub long_text: Option<AiStudioAgentLongTextTool>,
752 #[serde(default, skip_serializing_if = "Option::is_none")]
753 pub basic_text: Option<AiStudioAgentBasicTextTool>,
754 #[serde(default, skip_serializing_if = "Option::is_none")]
755 pub basic_image: Option<AiStudioAgentBasicTextTool>,
756 #[serde(default, skip_serializing_if = "Option::is_none")]
757 pub spreadsheet: Option<AiStudioAgentSpreadsheetTool>,
758 #[serde(default, skip_serializing_if = "Option::is_none")]
759 pub long_text_multi: Option<AiStudioAgentLongTextTool>,
760 #[serde(default, skip_serializing_if = "Option::is_none")]
761 pub basic_text_multi: Option<AiStudioAgentBasicTextTool>,
762 #[serde(default, skip_serializing_if = "Option::is_none")]
763 pub basic_image_multi: Option<AiStudioAgentBasicTextTool>,
764}
765
766#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
767pub struct AiStudioAgentAskResponse {
768 pub r#type: AiAgentAskType,
769 pub access_state: String,
770 pub description: String,
771 #[serde(
772 default,
773 skip_serializing_if = "Option::is_none",
774 deserialize_with = "double_option"
775 )]
776 pub custom_instructions: Option<Option<String>>,
777 #[serde(default, skip_serializing_if = "Option::is_none")]
778 pub suggested_questions: Option<Vec<String>>,
779 #[serde(default, skip_serializing_if = "Option::is_none")]
780 pub long_text: Option<AiStudioAgentLongTextToolResponse>,
781 #[serde(default, skip_serializing_if = "Option::is_none")]
782 pub basic_text: Option<AiStudioAgentBasicTextToolResponse>,
783 #[serde(default, skip_serializing_if = "Option::is_none")]
784 pub basic_image: Option<AiStudioAgentBasicTextToolResponse>,
785 #[serde(default, skip_serializing_if = "Option::is_none")]
786 pub spreadsheet: Option<AiStudioAgentSpreadsheetToolResponse>,
787 #[serde(default, skip_serializing_if = "Option::is_none")]
788 pub long_text_multi: Option<AiStudioAgentLongTextToolResponse>,
789 #[serde(default, skip_serializing_if = "Option::is_none")]
790 pub basic_text_multi: Option<AiStudioAgentBasicTextToolResponse>,
791 #[serde(default, skip_serializing_if = "Option::is_none")]
792 pub basic_image_multi: Option<AiStudioAgentBasicTextToolResponse>,
793}
794
795#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
796pub struct AiStudioAgentBasicGenTool {
797 #[serde(default, skip_serializing_if = "Option::is_none")]
798 pub model: Option<String>,
799 #[serde(default, skip_serializing_if = "Option::is_none")]
800 pub num_tokens_for_completion: Option<i64>,
801 #[serde(default, skip_serializing_if = "Option::is_none")]
802 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
803 #[serde(default, skip_serializing_if = "Option::is_none")]
804 pub system_message: Option<String>,
805 #[serde(default, skip_serializing_if = "Option::is_none")]
806 pub prompt_template: Option<String>,
807 #[serde(default, skip_serializing_if = "Option::is_none")]
808 pub embeddings: Option<AiAgentBasicGenToolEmbeddings>,
809 #[serde(default, skip_serializing_if = "Option::is_none")]
810 pub content_template: Option<String>,
811 #[serde(default, skip_serializing_if = "Option::is_none")]
812 pub is_custom_instructions_included: Option<bool>,
813}
814
815#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
816pub struct AiStudioAgentBasicGenToolResponse {
817 #[serde(default, skip_serializing_if = "Option::is_none")]
818 pub model: Option<String>,
819 #[serde(default, skip_serializing_if = "Option::is_none")]
820 pub num_tokens_for_completion: Option<i64>,
821 #[serde(default, skip_serializing_if = "Option::is_none")]
822 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
823 #[serde(default, skip_serializing_if = "Option::is_none")]
824 pub system_message: Option<String>,
825 #[serde(default, skip_serializing_if = "Option::is_none")]
826 pub prompt_template: Option<String>,
827 #[serde(default, skip_serializing_if = "Option::is_none")]
828 pub embeddings: Option<AiAgentBasicGenToolEmbeddings>,
829 #[serde(default, skip_serializing_if = "Option::is_none")]
830 pub content_template: Option<String>,
831 #[serde(default, skip_serializing_if = "Option::is_none")]
832 pub is_custom_instructions_included: Option<bool>,
833 #[serde(default, skip_serializing_if = "Option::is_none")]
834 pub warnings: Option<Vec<String>>,
835}
836
837#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
838pub struct AiStudioAgentBasicTextTool {
839 #[serde(default, skip_serializing_if = "Option::is_none")]
840 pub model: Option<String>,
841 #[serde(default, skip_serializing_if = "Option::is_none")]
842 pub num_tokens_for_completion: Option<i64>,
843 #[serde(default, skip_serializing_if = "Option::is_none")]
844 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
845 #[serde(default, skip_serializing_if = "Option::is_none")]
846 pub system_message: Option<String>,
847 #[serde(default, skip_serializing_if = "Option::is_none")]
848 pub prompt_template: Option<String>,
849 #[serde(default, skip_serializing_if = "Option::is_none")]
850 pub is_custom_instructions_included: Option<bool>,
851}
852
853#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
854pub struct AiStudioAgentBasicTextToolResponse {
855 #[serde(default, skip_serializing_if = "Option::is_none")]
856 pub model: Option<String>,
857 #[serde(default, skip_serializing_if = "Option::is_none")]
858 pub num_tokens_for_completion: Option<i64>,
859 #[serde(default, skip_serializing_if = "Option::is_none")]
860 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
861 #[serde(default, skip_serializing_if = "Option::is_none")]
862 pub system_message: Option<String>,
863 #[serde(default, skip_serializing_if = "Option::is_none")]
864 pub prompt_template: Option<String>,
865 #[serde(default, skip_serializing_if = "Option::is_none")]
866 pub is_custom_instructions_included: Option<bool>,
867 #[serde(default, skip_serializing_if = "Option::is_none")]
868 pub warnings: Option<Vec<String>>,
869}
870
871#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
872pub struct AiStudioAgentExtract {
873 pub r#type: AiAgentExtractType,
874 pub access_state: String,
875 pub description: String,
876 #[serde(
877 default,
878 skip_serializing_if = "Option::is_none",
879 deserialize_with = "double_option"
880 )]
881 pub custom_instructions: Option<Option<String>>,
882 #[serde(default, skip_serializing_if = "Option::is_none")]
883 pub long_text: Option<AiStudioAgentLongTextTool>,
884 #[serde(default, skip_serializing_if = "Option::is_none")]
885 pub basic_text: Option<AiStudioAgentBasicTextTool>,
886 #[serde(default, skip_serializing_if = "Option::is_none")]
887 pub basic_image: Option<AiStudioAgentBasicTextTool>,
888}
889
890#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
891pub struct AiStudioAgentExtractResponse {
892 pub r#type: AiAgentExtractType,
893 pub access_state: String,
894 pub description: String,
895 #[serde(
896 default,
897 skip_serializing_if = "Option::is_none",
898 deserialize_with = "double_option"
899 )]
900 pub custom_instructions: Option<Option<String>>,
901 #[serde(default, skip_serializing_if = "Option::is_none")]
902 pub long_text: Option<AiStudioAgentLongTextToolResponse>,
903 #[serde(default, skip_serializing_if = "Option::is_none")]
904 pub basic_text: Option<AiStudioAgentBasicTextToolResponse>,
905 #[serde(default, skip_serializing_if = "Option::is_none")]
906 pub basic_image: Option<AiStudioAgentBasicTextToolResponse>,
907}
908
909#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
910pub struct AiStudioAgentLongTextTool {
911 #[serde(default, skip_serializing_if = "Option::is_none")]
912 pub model: Option<String>,
913 #[serde(default, skip_serializing_if = "Option::is_none")]
914 pub num_tokens_for_completion: Option<i64>,
915 #[serde(default, skip_serializing_if = "Option::is_none")]
916 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
917 #[serde(default, skip_serializing_if = "Option::is_none")]
918 pub system_message: Option<String>,
919 #[serde(default, skip_serializing_if = "Option::is_none")]
920 pub prompt_template: Option<String>,
921 #[serde(default, skip_serializing_if = "Option::is_none")]
922 pub embeddings: Option<AiAgentBasicGenToolEmbeddings>,
923 #[serde(default, skip_serializing_if = "Option::is_none")]
924 pub is_custom_instructions_included: Option<bool>,
925}
926
927#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
928pub struct AiStudioAgentLongTextToolResponse {
929 #[serde(default, skip_serializing_if = "Option::is_none")]
930 pub model: Option<String>,
931 #[serde(default, skip_serializing_if = "Option::is_none")]
932 pub num_tokens_for_completion: Option<i64>,
933 #[serde(default, skip_serializing_if = "Option::is_none")]
934 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
935 #[serde(default, skip_serializing_if = "Option::is_none")]
936 pub system_message: Option<String>,
937 #[serde(default, skip_serializing_if = "Option::is_none")]
938 pub prompt_template: Option<String>,
939 #[serde(default, skip_serializing_if = "Option::is_none")]
940 pub embeddings: Option<AiAgentBasicGenToolEmbeddings>,
941 #[serde(default, skip_serializing_if = "Option::is_none")]
942 pub is_custom_instructions_included: Option<bool>,
943 #[serde(default, skip_serializing_if = "Option::is_none")]
944 pub warnings: Option<Vec<String>>,
945}
946
947pub type AiStudioAgentSpreadsheetTool = AiAgentSpreadsheetTool;
948
949#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
950pub struct AiStudioAgentSpreadsheetToolResponse {
951 #[serde(default, skip_serializing_if = "Option::is_none")]
952 pub model: Option<String>,
953 #[serde(default, skip_serializing_if = "Option::is_none")]
954 pub num_tokens_for_completion: Option<i64>,
955 #[serde(default, skip_serializing_if = "Option::is_none")]
956 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
957 #[serde(default, skip_serializing_if = "Option::is_none")]
958 pub warnings: Option<Vec<String>>,
959}
960
961#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
962pub struct AiStudioAgentTextGen {
963 pub r#type: AiAgentTextGenType,
964 pub access_state: String,
965 pub description: String,
966 #[serde(
967 default,
968 skip_serializing_if = "Option::is_none",
969 deserialize_with = "double_option"
970 )]
971 pub custom_instructions: Option<Option<String>>,
972 #[serde(default, skip_serializing_if = "Option::is_none")]
973 pub suggested_questions: Option<Vec<String>>,
974 #[serde(default, skip_serializing_if = "Option::is_none")]
975 pub basic_gen: Option<AiStudioAgentBasicGenTool>,
976}
977
978#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
979pub struct AiStudioAgentTextGenResponse {
980 pub r#type: AiAgentTextGenType,
981 pub access_state: String,
982 pub description: String,
983 #[serde(
984 default,
985 skip_serializing_if = "Option::is_none",
986 deserialize_with = "double_option"
987 )]
988 pub custom_instructions: Option<Option<String>>,
989 #[serde(default, skip_serializing_if = "Option::is_none")]
990 pub suggested_questions: Option<Vec<String>>,
991 #[serde(default, skip_serializing_if = "Option::is_none")]
992 pub basic_gen: Option<AiStudioAgentBasicGenToolResponse>,
993}
994
995#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
996pub struct AiTaxonomyFileReference {
997 #[serde(default, skip_serializing_if = "Option::is_none")]
998 pub r#type: Option<AiCitationType>,
999 #[serde(default, skip_serializing_if = "Option::is_none")]
1000 pub taxonomy_key: Option<String>,
1001 #[serde(default, skip_serializing_if = "Option::is_none")]
1002 pub id: Option<String>,
1003}
1004
1005#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1006pub struct AiTaxonomyReference {
1007 #[serde(default, skip_serializing_if = "Option::is_none")]
1008 pub r#type: Option<AiTaxonomyReferenceType>,
1009 #[serde(default, skip_serializing_if = "Option::is_none")]
1010 pub taxonomy_key: Option<String>,
1011 #[serde(default, skip_serializing_if = "Option::is_none")]
1012 pub namespace: Option<String>,
1013}
1014
1015#[derive(Clone, Debug, PartialEq)]
1016pub enum AiTaxonomySource {
1017 Taxonomy(AiTaxonomyReference),
1018 File(AiTaxonomyFileReference),
1019 Unknown(serde_json::Value),
1021}
1022
1023impl serde::Serialize for AiTaxonomySource {
1024 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1025 match self {
1026 Self::Taxonomy(inner) => inner.serialize(serializer),
1027 Self::File(inner) => inner.serialize(serializer),
1028 Self::Unknown(inner) => inner.serialize(serializer),
1029 }
1030 }
1031}
1032
1033impl<'de> serde::Deserialize<'de> for AiTaxonomySource {
1034 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1035 let value = serde_json::Value::deserialize(deserializer)?;
1036 let tag = value
1037 .get("type")
1038 .and_then(serde_json::Value::as_str)
1039 .map(str::to_owned);
1040 match tag.as_deref() {
1041 Some("taxonomy") => Ok(Self::Taxonomy(
1042 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1043 )),
1044 Some("file") => Ok(Self::File(
1045 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1046 )),
1047 _ => Ok(Self::Unknown(value)),
1048 }
1049 }
1050}
1051
1052#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1053pub struct AiTextGen {
1054 pub prompt: String,
1055 pub items: Vec<AiTextGenItems>,
1056 #[serde(default, skip_serializing_if = "Option::is_none")]
1057 pub dialogue_history: Option<Vec<AiDialogueHistory>>,
1058 #[serde(default, skip_serializing_if = "Option::is_none")]
1059 pub ai_agent: Option<AiTextGenAgent>,
1060}
1061
1062#[derive(Clone, Debug, PartialEq)]
1063pub enum AiTextGenAgent {
1064 AiAgentId(AiAgentReference),
1065 AiAgentTextGen(AiAgentTextGen),
1066 Unknown(serde_json::Value),
1068}
1069
1070impl serde::Serialize for AiTextGenAgent {
1071 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1072 match self {
1073 Self::AiAgentId(inner) => inner.serialize(serializer),
1074 Self::AiAgentTextGen(inner) => inner.serialize(serializer),
1075 Self::Unknown(inner) => inner.serialize(serializer),
1076 }
1077 }
1078}
1079
1080impl<'de> serde::Deserialize<'de> for AiTextGenAgent {
1081 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1082 let value = serde_json::Value::deserialize(deserializer)?;
1083 let tag = value
1084 .get("type")
1085 .and_then(serde_json::Value::as_str)
1086 .map(str::to_owned);
1087 match tag.as_deref() {
1088 Some("ai_agent_id") => Ok(Self::AiAgentId(
1089 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1090 )),
1091 Some("ai_agent_text_gen") => Ok(Self::AiAgentTextGen(
1092 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1093 )),
1094 _ => Ok(Self::Unknown(value)),
1095 }
1096 }
1097}
1098
1099#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1100pub struct AppItem {
1101 pub id: String,
1102 pub r#type: AppItemType,
1103 pub application_type: String,
1104}
1105
1106#[derive(Clone, Debug, PartialEq)]
1107pub enum AppItemAssociatedItem {
1108 File(FileBase),
1109 Folder(FolderBase),
1110 WebLink(WebLinkBase),
1111 Unknown(serde_json::Value),
1113}
1114
1115impl serde::Serialize for AppItemAssociatedItem {
1116 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1117 match self {
1118 Self::File(inner) => inner.serialize(serializer),
1119 Self::Folder(inner) => inner.serialize(serializer),
1120 Self::WebLink(inner) => inner.serialize(serializer),
1121 Self::Unknown(inner) => inner.serialize(serializer),
1122 }
1123 }
1124}
1125
1126impl<'de> serde::Deserialize<'de> for AppItemAssociatedItem {
1127 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1128 let value = serde_json::Value::deserialize(deserializer)?;
1129 let tag = value
1130 .get("type")
1131 .and_then(serde_json::Value::as_str)
1132 .map(str::to_owned);
1133 match tag.as_deref() {
1134 Some("file") => Ok(Self::File(
1135 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1136 )),
1137 Some("folder") => Ok(Self::Folder(
1138 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1139 )),
1140 Some("web_link") => Ok(Self::WebLink(
1141 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1142 )),
1143 _ => Ok(Self::Unknown(value)),
1144 }
1145 }
1146}
1147
1148#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1149pub struct AppItemAssociation {
1150 pub id: String,
1151 pub r#type: AppItemAssociationType,
1152 pub app_item: AppItem,
1153 pub item: AppItemAssociatedItem,
1154}
1155
1156#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1157pub struct AppItemAssociations {
1158 #[serde(default, skip_serializing_if = "Option::is_none")]
1159 pub limit: Option<i64>,
1160 #[serde(
1161 default,
1162 skip_serializing_if = "Option::is_none",
1163 deserialize_with = "double_option"
1164 )]
1165 pub next_marker: Option<Option<String>>,
1166 #[serde(
1167 default,
1168 skip_serializing_if = "Option::is_none",
1169 deserialize_with = "double_option"
1170 )]
1171 pub prev_marker: Option<Option<String>>,
1172 #[serde(default, skip_serializing_if = "Option::is_none")]
1173 pub entries: Option<Vec<AppItemAssociation>>,
1174}
1175
1176#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1177pub struct AppItemEventSource {
1178 pub id: String,
1179 pub r#type: AppItemType,
1180 pub app_item_type: String,
1181 #[serde(default, skip_serializing_if = "Option::is_none")]
1182 pub user: Option<UserMini>,
1183 #[serde(default, skip_serializing_if = "Option::is_none")]
1184 pub group: Option<GroupMini>,
1185}
1186
1187#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1188pub struct Classification {
1189 #[serde(
1190 rename = "Box__Security__Classification__Key",
1191 default,
1192 skip_serializing_if = "Option::is_none"
1193 )]
1194 pub box_security_classification_key: Option<String>,
1195 #[serde(rename = "$parent", default, skip_serializing_if = "Option::is_none")]
1196 pub parent: Option<String>,
1197 #[serde(rename = "$template", default, skip_serializing_if = "Option::is_none")]
1198 pub template: Option<ClassificationTemplate2>,
1199 #[serde(rename = "$scope", default, skip_serializing_if = "Option::is_none")]
1200 pub scope: Option<String>,
1201 #[serde(rename = "$version", default, skip_serializing_if = "Option::is_none")]
1202 pub version: Option<i64>,
1203 #[serde(rename = "$type", default, skip_serializing_if = "Option::is_none")]
1204 pub r#type: Option<String>,
1205 #[serde(
1206 rename = "$typeVersion",
1207 default,
1208 skip_serializing_if = "Option::is_none"
1209 )]
1210 pub type_version: Option<f64>,
1211 #[serde(rename = "$canEdit", default, skip_serializing_if = "Option::is_none")]
1212 pub can_edit: Option<bool>,
1213}
1214
1215#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1216pub struct ClassificationTemplate {
1217 pub id: String,
1218 pub r#type: MetadataTemplateType,
1219 pub scope: String,
1220 #[serde(rename = "templateKey")]
1221 pub template_key: ClassificationTemplate2,
1222 #[serde(rename = "displayName")]
1223 pub display_name: ClassificationTemplateDisplayName,
1224 #[serde(default, skip_serializing_if = "Option::is_none")]
1225 pub hidden: Option<bool>,
1226 #[serde(
1227 rename = "copyInstanceOnItemCopy",
1228 default,
1229 skip_serializing_if = "Option::is_none"
1230 )]
1231 pub copy_instance_on_item_copy: Option<bool>,
1232 pub fields: Vec<ClassificationTemplateFields>,
1233}
1234
1235#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1236pub struct ClientError {
1237 #[serde(default, skip_serializing_if = "Option::is_none")]
1238 pub r#type: Option<ClientErrorType>,
1239 #[serde(default, skip_serializing_if = "Option::is_none")]
1240 pub status: Option<i64>,
1241 #[serde(default, skip_serializing_if = "Option::is_none")]
1242 pub code: Option<ClientErrorCode>,
1243 #[serde(default, skip_serializing_if = "Option::is_none")]
1244 pub message: Option<String>,
1245 #[serde(
1246 default,
1247 skip_serializing_if = "Option::is_none",
1248 deserialize_with = "double_option"
1249 )]
1250 pub context_info: Option<Option<std::collections::HashMap<String, serde_json::Value>>>,
1251 #[serde(default, skip_serializing_if = "Option::is_none")]
1252 pub help_url: Option<String>,
1253 #[serde(default, skip_serializing_if = "Option::is_none")]
1254 pub request_id: Option<String>,
1255}
1256
1257#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1258pub struct Collaboration {
1259 pub id: String,
1260 pub r#type: CollaborationType,
1261 #[serde(
1262 default,
1263 skip_serializing_if = "Option::is_none",
1264 deserialize_with = "double_option"
1265 )]
1266 pub item: Option<Option<CollaborationItem>>,
1267 #[serde(
1268 default,
1269 skip_serializing_if = "Option::is_none",
1270 deserialize_with = "double_option"
1271 )]
1272 pub app_item: Option<Option<AppItem>>,
1273 #[serde(default, skip_serializing_if = "Option::is_none")]
1274 pub accessible_by: Option<CollaborationAccessGrantee>,
1275 #[serde(
1276 default,
1277 skip_serializing_if = "Option::is_none",
1278 deserialize_with = "double_option"
1279 )]
1280 pub invite_email: Option<Option<String>>,
1281 #[serde(default, skip_serializing_if = "Option::is_none")]
1282 pub role: Option<CollaborationRole>,
1283 #[serde(
1284 default,
1285 skip_serializing_if = "Option::is_none",
1286 deserialize_with = "double_option"
1287 )]
1288 pub expires_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1289 #[serde(default, skip_serializing_if = "Option::is_none")]
1290 pub is_access_only: Option<bool>,
1291 #[serde(default, skip_serializing_if = "Option::is_none")]
1292 pub status: Option<CollaborationStatus>,
1293 #[serde(default, skip_serializing_if = "Option::is_none")]
1294 pub acknowledged_at: Option<chrono::DateTime<chrono::Utc>>,
1295 #[serde(default, skip_serializing_if = "Option::is_none")]
1296 pub created_by: Option<UserCollaborations>,
1297 #[serde(default, skip_serializing_if = "Option::is_none")]
1298 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1299 #[serde(default, skip_serializing_if = "Option::is_none")]
1300 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
1301 #[serde(default, skip_serializing_if = "Option::is_none")]
1302 pub acceptance_requirements_status: Option<CollaborationAcceptanceRequirementsStatus>,
1303}
1304
1305#[derive(Clone, Debug, PartialEq)]
1306pub enum CollaborationAccessGrantee {
1307 User(UserCollaborations),
1308 Group(GroupMini),
1309 Unknown(serde_json::Value),
1311}
1312
1313impl serde::Serialize for CollaborationAccessGrantee {
1314 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1315 match self {
1316 Self::User(inner) => inner.serialize(serializer),
1317 Self::Group(inner) => inner.serialize(serializer),
1318 Self::Unknown(inner) => inner.serialize(serializer),
1319 }
1320 }
1321}
1322
1323impl<'de> serde::Deserialize<'de> for CollaborationAccessGrantee {
1324 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1325 let value = serde_json::Value::deserialize(deserializer)?;
1326 let tag = value
1327 .get("type")
1328 .and_then(serde_json::Value::as_str)
1329 .map(str::to_owned);
1330 match tag.as_deref() {
1331 Some("user") => Ok(Self::User(
1332 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1333 )),
1334 Some("group") => Ok(Self::Group(
1335 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1336 )),
1337 _ => Ok(Self::Unknown(value)),
1338 }
1339 }
1340}
1341
1342#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1343pub struct CollaborationAllowlistEntries {
1344 #[serde(default, skip_serializing_if = "Option::is_none")]
1345 pub limit: Option<i64>,
1346 #[serde(
1347 default,
1348 skip_serializing_if = "Option::is_none",
1349 deserialize_with = "double_option"
1350 )]
1351 pub next_marker: Option<Option<String>>,
1352 #[serde(
1353 default,
1354 skip_serializing_if = "Option::is_none",
1355 deserialize_with = "double_option"
1356 )]
1357 pub prev_marker: Option<Option<String>>,
1358 #[serde(default, skip_serializing_if = "Option::is_none")]
1359 pub entries: Option<Vec<CollaborationAllowlistEntry>>,
1360}
1361
1362#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1363pub struct CollaborationAllowlistEntry {
1364 #[serde(default, skip_serializing_if = "Option::is_none")]
1365 pub id: Option<String>,
1366 #[serde(default, skip_serializing_if = "Option::is_none")]
1367 pub r#type: Option<CollaborationAllowlistEntryType>,
1368 #[serde(default, skip_serializing_if = "Option::is_none")]
1369 pub domain: Option<String>,
1370 #[serde(default, skip_serializing_if = "Option::is_none")]
1371 pub direction: Option<CollaborationAllowlistEntryDirection>,
1372 #[serde(default, skip_serializing_if = "Option::is_none")]
1373 pub enterprise: Option<CollaborationAllowlistEntryEnterprise>,
1374 #[serde(default, skip_serializing_if = "Option::is_none")]
1375 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1376}
1377
1378#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1379pub struct CollaborationAllowlistExemptTarget {
1380 #[serde(default, skip_serializing_if = "Option::is_none")]
1381 pub id: Option<String>,
1382 #[serde(default, skip_serializing_if = "Option::is_none")]
1383 pub r#type: Option<CollaborationAllowlistExemptTargetType>,
1384 #[serde(default, skip_serializing_if = "Option::is_none")]
1385 pub enterprise: Option<CollaborationAllowlistEntryEnterprise>,
1386 #[serde(default, skip_serializing_if = "Option::is_none")]
1387 pub user: Option<UserMini>,
1388 #[serde(default, skip_serializing_if = "Option::is_none")]
1389 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1390 #[serde(default, skip_serializing_if = "Option::is_none")]
1391 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
1392}
1393
1394#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1395pub struct CollaborationAllowlistExemptTargets {
1396 #[serde(default, skip_serializing_if = "Option::is_none")]
1397 pub limit: Option<i64>,
1398 #[serde(
1399 default,
1400 skip_serializing_if = "Option::is_none",
1401 deserialize_with = "double_option"
1402 )]
1403 pub next_marker: Option<Option<String>>,
1404 #[serde(
1405 default,
1406 skip_serializing_if = "Option::is_none",
1407 deserialize_with = "double_option"
1408 )]
1409 pub prev_marker: Option<Option<String>>,
1410 #[serde(default, skip_serializing_if = "Option::is_none")]
1411 pub entries: Option<Vec<CollaborationAllowlistExemptTarget>>,
1412}
1413
1414#[derive(Clone, Debug, PartialEq)]
1415pub enum CollaborationItem {
1416 File(File),
1417 Folder(Folder),
1418 WebLink(WebLink),
1419 Unknown(serde_json::Value),
1421}
1422
1423impl serde::Serialize for CollaborationItem {
1424 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1425 match self {
1426 Self::File(inner) => inner.serialize(serializer),
1427 Self::Folder(inner) => inner.serialize(serializer),
1428 Self::WebLink(inner) => inner.serialize(serializer),
1429 Self::Unknown(inner) => inner.serialize(serializer),
1430 }
1431 }
1432}
1433
1434impl<'de> serde::Deserialize<'de> for CollaborationItem {
1435 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1436 let value = serde_json::Value::deserialize(deserializer)?;
1437 let tag = value
1438 .get("type")
1439 .and_then(serde_json::Value::as_str)
1440 .map(str::to_owned);
1441 match tag.as_deref() {
1442 Some("file") => Ok(Self::File(
1443 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1444 )),
1445 Some("folder") => Ok(Self::Folder(
1446 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1447 )),
1448 Some("web_link") => Ok(Self::WebLink(
1449 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1450 )),
1451 _ => Ok(Self::Unknown(value)),
1452 }
1453 }
1454}
1455
1456#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1457pub struct Collaborations {
1458 #[serde(default, skip_serializing_if = "Option::is_none")]
1459 pub limit: Option<i64>,
1460 #[serde(
1461 default,
1462 skip_serializing_if = "Option::is_none",
1463 deserialize_with = "double_option"
1464 )]
1465 pub next_marker: Option<Option<String>>,
1466 #[serde(
1467 default,
1468 skip_serializing_if = "Option::is_none",
1469 deserialize_with = "double_option"
1470 )]
1471 pub prev_marker: Option<Option<String>>,
1472 #[serde(default, skip_serializing_if = "Option::is_none")]
1473 pub entries: Option<Vec<Collaboration>>,
1474}
1475
1476#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1477pub struct CollaborationsOffsetPaginated {
1478 #[serde(default, skip_serializing_if = "Option::is_none")]
1479 pub total_count: Option<i64>,
1480 #[serde(default, skip_serializing_if = "Option::is_none")]
1481 pub limit: Option<i64>,
1482 #[serde(default, skip_serializing_if = "Option::is_none")]
1483 pub offset: Option<i64>,
1484 #[serde(default, skip_serializing_if = "Option::is_none")]
1485 pub entries: Option<Vec<Collaboration>>,
1486}
1487
1488#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1489pub struct CollaboratorVariable {
1490 pub r#type: CollaboratorVariableType,
1491 pub variable_type: CollaboratorVariableVariableType,
1492 pub variable_value: Vec<CollaboratorVariableVariableValue>,
1493}
1494
1495#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1496pub struct Collection {
1497 #[serde(default, skip_serializing_if = "Option::is_none")]
1498 pub id: Option<String>,
1499 #[serde(default, skip_serializing_if = "Option::is_none")]
1500 pub r#type: Option<CollectionType>,
1501 #[serde(default, skip_serializing_if = "Option::is_none")]
1502 pub name: Option<CollectionName>,
1503 #[serde(default, skip_serializing_if = "Option::is_none")]
1504 pub collection_type: Option<CollectionCollectionType>,
1505}
1506
1507#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1508pub struct Collections {
1509 #[serde(default, skip_serializing_if = "Option::is_none")]
1510 pub total_count: Option<i64>,
1511 #[serde(default, skip_serializing_if = "Option::is_none")]
1512 pub limit: Option<i64>,
1513 #[serde(default, skip_serializing_if = "Option::is_none")]
1514 pub offset: Option<i64>,
1515 #[serde(default, skip_serializing_if = "Option::is_none")]
1516 pub order: Option<Vec<CollectionsOrder>>,
1517 #[serde(default, skip_serializing_if = "Option::is_none")]
1518 pub entries: Option<Vec<Collection>>,
1519}
1520
1521#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1522pub struct Comment {
1523 #[serde(default, skip_serializing_if = "Option::is_none")]
1524 pub id: Option<String>,
1525 #[serde(default, skip_serializing_if = "Option::is_none")]
1526 pub r#type: Option<CommentType>,
1527 #[serde(default, skip_serializing_if = "Option::is_none")]
1528 pub is_reply_comment: Option<bool>,
1529 #[serde(default, skip_serializing_if = "Option::is_none")]
1530 pub message: Option<String>,
1531 #[serde(default, skip_serializing_if = "Option::is_none")]
1532 pub created_by: Option<UserMini>,
1533 #[serde(default, skip_serializing_if = "Option::is_none")]
1534 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1535 #[serde(default, skip_serializing_if = "Option::is_none")]
1536 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
1537 #[serde(default, skip_serializing_if = "Option::is_none")]
1538 pub item: Option<CommentItem>,
1539}
1540
1541#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1542pub struct CommentBase {
1543 #[serde(default, skip_serializing_if = "Option::is_none")]
1544 pub id: Option<String>,
1545 #[serde(default, skip_serializing_if = "Option::is_none")]
1546 pub r#type: Option<CommentType>,
1547}
1548
1549#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1550pub struct CommentFull {
1551 #[serde(default, skip_serializing_if = "Option::is_none")]
1552 pub id: Option<String>,
1553 #[serde(default, skip_serializing_if = "Option::is_none")]
1554 pub r#type: Option<CommentType>,
1555 #[serde(default, skip_serializing_if = "Option::is_none")]
1556 pub is_reply_comment: Option<bool>,
1557 #[serde(default, skip_serializing_if = "Option::is_none")]
1558 pub message: Option<String>,
1559 #[serde(default, skip_serializing_if = "Option::is_none")]
1560 pub created_by: Option<UserMini>,
1561 #[serde(default, skip_serializing_if = "Option::is_none")]
1562 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1563 #[serde(default, skip_serializing_if = "Option::is_none")]
1564 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
1565 #[serde(default, skip_serializing_if = "Option::is_none")]
1566 pub item: Option<CommentItem>,
1567 #[serde(default, skip_serializing_if = "Option::is_none")]
1568 pub tagged_message: Option<String>,
1569}
1570
1571#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1572pub struct Comments {
1573 #[serde(default, skip_serializing_if = "Option::is_none")]
1574 pub total_count: Option<i64>,
1575 #[serde(default, skip_serializing_if = "Option::is_none")]
1576 pub limit: Option<i64>,
1577 #[serde(default, skip_serializing_if = "Option::is_none")]
1578 pub offset: Option<i64>,
1579 #[serde(default, skip_serializing_if = "Option::is_none")]
1580 pub order: Option<Vec<CollectionsOrder>>,
1581 #[serde(default, skip_serializing_if = "Option::is_none")]
1582 pub entries: Option<Vec<CommentFull>>,
1583}
1584
1585#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1586pub struct CompletionRuleVariable {
1587 pub r#type: CollaboratorVariableType,
1588 pub variable_type: CompletionRuleVariableVariableType,
1589 pub variable_value: CompletionRuleVariableVariableValue,
1590}
1591
1592#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1593pub struct ConflictError {
1594 #[serde(default, skip_serializing_if = "Option::is_none")]
1595 pub r#type: Option<ClientErrorType>,
1596 #[serde(default, skip_serializing_if = "Option::is_none")]
1597 pub status: Option<i64>,
1598 #[serde(default, skip_serializing_if = "Option::is_none")]
1599 pub code: Option<ClientErrorCode>,
1600 #[serde(default, skip_serializing_if = "Option::is_none")]
1601 pub message: Option<String>,
1602 #[serde(default, skip_serializing_if = "Option::is_none")]
1603 pub context_info: Option<ConflictErrorContextInfo>,
1604 #[serde(default, skip_serializing_if = "Option::is_none")]
1605 pub help_url: Option<String>,
1606 #[serde(default, skip_serializing_if = "Option::is_none")]
1607 pub request_id: Option<String>,
1608}
1609
1610#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1611pub struct CreateAiAgent {
1612 pub r#type: AiSingleAgentResponseType,
1613 pub name: String,
1614 pub access_state: String,
1615 #[serde(default, skip_serializing_if = "Option::is_none")]
1616 pub icon_reference: Option<String>,
1617 #[serde(default, skip_serializing_if = "Option::is_none")]
1618 pub allowed_entities: Option<Vec<AiAgentAllowedEntity>>,
1619 #[serde(default, skip_serializing_if = "Option::is_none")]
1620 pub ask: Option<AiStudioAgentAsk>,
1621 #[serde(default, skip_serializing_if = "Option::is_none")]
1622 pub text_gen: Option<AiStudioAgentTextGen>,
1623 #[serde(default, skip_serializing_if = "Option::is_none")]
1624 pub extract: Option<AiStudioAgentExtract>,
1625}
1626
1627#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1628pub struct DevicePinner {
1629 #[serde(default, skip_serializing_if = "Option::is_none")]
1630 pub id: Option<String>,
1631 #[serde(default, skip_serializing_if = "Option::is_none")]
1632 pub r#type: Option<DevicePinnerType>,
1633 #[serde(default, skip_serializing_if = "Option::is_none")]
1634 pub owned_by: Option<UserMini>,
1635 #[serde(default, skip_serializing_if = "Option::is_none")]
1636 pub product_name: Option<String>,
1637}
1638
1639#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1640pub struct DevicePinners {
1641 #[serde(default, skip_serializing_if = "Option::is_none")]
1642 pub entries: Option<Vec<DevicePinner>>,
1643 #[serde(default, skip_serializing_if = "Option::is_none")]
1644 pub limit: Option<i64>,
1645 #[serde(default, skip_serializing_if = "Option::is_none")]
1646 pub next_marker: Option<i64>,
1647 #[serde(default, skip_serializing_if = "Option::is_none")]
1648 pub order: Option<Vec<DevicePinnersOrder>>,
1649}
1650
1651#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1652pub struct EmailAlias {
1653 #[serde(default, skip_serializing_if = "Option::is_none")]
1654 pub id: Option<String>,
1655 #[serde(default, skip_serializing_if = "Option::is_none")]
1656 pub r#type: Option<EmailAliasType>,
1657 #[serde(default, skip_serializing_if = "Option::is_none")]
1658 pub email: Option<String>,
1659 #[serde(default, skip_serializing_if = "Option::is_none")]
1660 pub is_confirmed: Option<bool>,
1661}
1662
1663#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1664pub struct EmailAliases {
1665 #[serde(default, skip_serializing_if = "Option::is_none")]
1666 pub total_count: Option<i64>,
1667 #[serde(default, skip_serializing_if = "Option::is_none")]
1668 pub entries: Option<Vec<EmailAlias>>,
1669}
1670
1671#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1672pub struct EnterpriseBase {
1673 #[serde(default, skip_serializing_if = "Option::is_none")]
1674 pub id: Option<String>,
1675 #[serde(default, skip_serializing_if = "Option::is_none")]
1676 pub r#type: Option<EnterpriseType>,
1677}
1678
1679#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1680pub struct Event {
1681 #[serde(default, skip_serializing_if = "Option::is_none")]
1682 pub r#type: Option<String>,
1683 #[serde(default, skip_serializing_if = "Option::is_none")]
1684 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1685 #[serde(default, skip_serializing_if = "Option::is_none")]
1686 pub recorded_at: Option<chrono::DateTime<chrono::Utc>>,
1687 #[serde(default, skip_serializing_if = "Option::is_none")]
1688 pub event_id: Option<String>,
1689 #[serde(default, skip_serializing_if = "Option::is_none")]
1690 pub created_by: Option<UserMini>,
1691 #[serde(default, skip_serializing_if = "Option::is_none")]
1692 pub event_type: Option<EventEventType>,
1693 #[serde(default, skip_serializing_if = "Option::is_none")]
1694 pub session_id: Option<String>,
1695 #[serde(default, skip_serializing_if = "Option::is_none")]
1696 pub source: Option<EventSourceResource>,
1697 #[serde(default, skip_serializing_if = "Option::is_none")]
1698 pub additional_details: Option<std::collections::HashMap<String, serde_json::Value>>,
1699}
1700
1701#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1702pub struct Events {
1703 #[serde(default, skip_serializing_if = "Option::is_none")]
1704 pub chunk_size: Option<i64>,
1705 #[serde(default, skip_serializing_if = "Option::is_none")]
1706 pub next_stream_position: Option<EventsNextStreamPosition>,
1707 #[serde(default, skip_serializing_if = "Option::is_none")]
1708 pub entries: Option<Vec<Event>>,
1709}
1710
1711#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1712pub struct EventSource {
1713 pub item_type: EventSourceItemType,
1714 pub item_id: String,
1715 pub item_name: String,
1716 #[serde(default, skip_serializing_if = "Option::is_none")]
1717 pub classification: Option<EventSourceClassification>,
1718 #[serde(
1719 default,
1720 skip_serializing_if = "Option::is_none",
1721 deserialize_with = "double_option"
1722 )]
1723 pub parent: Option<Option<FolderMini>>,
1724 #[serde(default, skip_serializing_if = "Option::is_none")]
1725 pub owned_by: Option<UserMini>,
1726}
1727
1728#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1729#[serde(transparent)]
1730pub struct EventSourceResource(pub serde_json::Value);
1731
1732#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1733pub struct File {
1734 pub id: String,
1735 #[serde(
1736 default,
1737 skip_serializing_if = "Option::is_none",
1738 deserialize_with = "double_option"
1739 )]
1740 pub etag: Option<Option<String>>,
1741 pub r#type: AiCitationType,
1742 #[serde(default, skip_serializing_if = "Option::is_none")]
1743 pub sequence_id: Option<String>,
1744 #[serde(default, skip_serializing_if = "Option::is_none")]
1745 pub name: Option<String>,
1746 #[serde(default, skip_serializing_if = "Option::is_none")]
1747 pub sha1: Option<String>,
1748 #[serde(default, skip_serializing_if = "Option::is_none")]
1749 pub file_version: Option<FileVersionMini>,
1750 #[serde(default, skip_serializing_if = "Option::is_none")]
1751 pub description: Option<String>,
1752 #[serde(default, skip_serializing_if = "Option::is_none")]
1753 pub size: Option<i64>,
1754 #[serde(default, skip_serializing_if = "Option::is_none")]
1755 pub path_collection: Option<FilePathCollection>,
1756 #[serde(default, skip_serializing_if = "Option::is_none")]
1757 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1758 #[serde(default, skip_serializing_if = "Option::is_none")]
1759 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
1760 #[serde(
1761 default,
1762 skip_serializing_if = "Option::is_none",
1763 deserialize_with = "double_option"
1764 )]
1765 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1766 #[serde(
1767 default,
1768 skip_serializing_if = "Option::is_none",
1769 deserialize_with = "double_option"
1770 )]
1771 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1772 #[serde(
1773 default,
1774 skip_serializing_if = "Option::is_none",
1775 deserialize_with = "double_option"
1776 )]
1777 pub content_created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1778 #[serde(
1779 default,
1780 skip_serializing_if = "Option::is_none",
1781 deserialize_with = "double_option"
1782 )]
1783 pub content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1784 #[serde(default, skip_serializing_if = "Option::is_none")]
1785 pub created_by: Option<UserMini>,
1786 #[serde(default, skip_serializing_if = "Option::is_none")]
1787 pub modified_by: Option<UserMini>,
1788 #[serde(default, skip_serializing_if = "Option::is_none")]
1789 pub owned_by: Option<UserMini>,
1790 #[serde(
1791 default,
1792 skip_serializing_if = "Option::is_none",
1793 deserialize_with = "double_option"
1794 )]
1795 pub shared_link: Option<Option<FileSharedLink>>,
1796 #[serde(
1797 default,
1798 skip_serializing_if = "Option::is_none",
1799 deserialize_with = "double_option"
1800 )]
1801 pub parent: Option<Option<FolderMini>>,
1802 #[serde(default, skip_serializing_if = "Option::is_none")]
1803 pub item_status: Option<FileItemStatus>,
1804}
1805
1806#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1807pub struct FileBase {
1808 pub id: String,
1809 #[serde(
1810 default,
1811 skip_serializing_if = "Option::is_none",
1812 deserialize_with = "double_option"
1813 )]
1814 pub etag: Option<Option<String>>,
1815 pub r#type: AiCitationType,
1816}
1817
1818#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1819pub struct FileFull {
1820 pub id: String,
1821 #[serde(
1822 default,
1823 skip_serializing_if = "Option::is_none",
1824 deserialize_with = "double_option"
1825 )]
1826 pub etag: Option<Option<String>>,
1827 pub r#type: AiCitationType,
1828 #[serde(default, skip_serializing_if = "Option::is_none")]
1829 pub sequence_id: Option<String>,
1830 #[serde(default, skip_serializing_if = "Option::is_none")]
1831 pub name: Option<String>,
1832 #[serde(default, skip_serializing_if = "Option::is_none")]
1833 pub sha1: Option<String>,
1834 #[serde(default, skip_serializing_if = "Option::is_none")]
1835 pub file_version: Option<FileVersionMini>,
1836 #[serde(default, skip_serializing_if = "Option::is_none")]
1837 pub description: Option<String>,
1838 #[serde(default, skip_serializing_if = "Option::is_none")]
1839 pub size: Option<i64>,
1840 #[serde(default, skip_serializing_if = "Option::is_none")]
1841 pub path_collection: Option<FilePathCollection>,
1842 #[serde(default, skip_serializing_if = "Option::is_none")]
1843 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1844 #[serde(default, skip_serializing_if = "Option::is_none")]
1845 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
1846 #[serde(
1847 default,
1848 skip_serializing_if = "Option::is_none",
1849 deserialize_with = "double_option"
1850 )]
1851 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1852 #[serde(
1853 default,
1854 skip_serializing_if = "Option::is_none",
1855 deserialize_with = "double_option"
1856 )]
1857 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1858 #[serde(
1859 default,
1860 skip_serializing_if = "Option::is_none",
1861 deserialize_with = "double_option"
1862 )]
1863 pub content_created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1864 #[serde(
1865 default,
1866 skip_serializing_if = "Option::is_none",
1867 deserialize_with = "double_option"
1868 )]
1869 pub content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1870 #[serde(default, skip_serializing_if = "Option::is_none")]
1871 pub created_by: Option<UserMini>,
1872 #[serde(default, skip_serializing_if = "Option::is_none")]
1873 pub modified_by: Option<UserMini>,
1874 #[serde(default, skip_serializing_if = "Option::is_none")]
1875 pub owned_by: Option<UserMini>,
1876 #[serde(
1877 default,
1878 skip_serializing_if = "Option::is_none",
1879 deserialize_with = "double_option"
1880 )]
1881 pub shared_link: Option<Option<FileSharedLink>>,
1882 #[serde(
1883 default,
1884 skip_serializing_if = "Option::is_none",
1885 deserialize_with = "double_option"
1886 )]
1887 pub parent: Option<Option<FolderMini>>,
1888 #[serde(default, skip_serializing_if = "Option::is_none")]
1889 pub item_status: Option<FileItemStatus>,
1890 #[serde(default, skip_serializing_if = "Option::is_none")]
1891 pub version_number: Option<String>,
1892 #[serde(default, skip_serializing_if = "Option::is_none")]
1893 pub comment_count: Option<i64>,
1894 #[serde(default, skip_serializing_if = "Option::is_none")]
1895 pub permissions: Option<FileFullPermissions>,
1896 #[serde(default, skip_serializing_if = "Option::is_none")]
1897 pub tags: Option<Vec<String>>,
1898 #[serde(
1899 default,
1900 skip_serializing_if = "Option::is_none",
1901 deserialize_with = "double_option"
1902 )]
1903 pub lock: Option<Option<FileFullLock>>,
1904 #[serde(default, skip_serializing_if = "Option::is_none")]
1905 pub extension: Option<String>,
1906 #[serde(default, skip_serializing_if = "Option::is_none")]
1907 pub is_package: Option<bool>,
1908 #[serde(default, skip_serializing_if = "Option::is_none")]
1909 pub expiring_embed_link: Option<FileFullExpiringEmbedLink>,
1910 #[serde(default, skip_serializing_if = "Option::is_none")]
1911 pub watermark_info: Option<FileFullWatermarkInfo>,
1912 #[serde(default, skip_serializing_if = "Option::is_none")]
1913 pub is_accessible_via_shared_link: Option<bool>,
1914 #[serde(default, skip_serializing_if = "Option::is_none")]
1915 pub allowed_invitee_roles: Option<Vec<FileFullAllowedInviteeRoles>>,
1916 #[serde(default, skip_serializing_if = "Option::is_none")]
1917 pub is_externally_owned: Option<bool>,
1918 #[serde(default, skip_serializing_if = "Option::is_none")]
1919 pub has_collaborations: Option<bool>,
1920 #[serde(default, skip_serializing_if = "Option::is_none")]
1921 pub metadata:
1922 Option<std::collections::HashMap<String, std::collections::HashMap<String, MetadataFull>>>,
1923 #[serde(
1924 default,
1925 skip_serializing_if = "Option::is_none",
1926 deserialize_with = "double_option"
1927 )]
1928 pub expires_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1929 #[serde(default, skip_serializing_if = "Option::is_none")]
1930 pub representations: Option<FileFullRepresentations>,
1931 #[serde(
1932 default,
1933 skip_serializing_if = "Option::is_none",
1934 deserialize_with = "double_option"
1935 )]
1936 pub classification: Option<Option<FileFullClassification>>,
1937 #[serde(default, skip_serializing_if = "Option::is_none")]
1938 pub uploader_display_name: Option<String>,
1939 #[serde(
1940 default,
1941 skip_serializing_if = "Option::is_none",
1942 deserialize_with = "double_option"
1943 )]
1944 pub disposition_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1945 #[serde(
1946 default,
1947 skip_serializing_if = "Option::is_none",
1948 deserialize_with = "double_option"
1949 )]
1950 pub shared_link_permission_options: Option<Option<Vec<FileFullSharedLinkPermissionOptions>>>,
1951 #[serde(default, skip_serializing_if = "Option::is_none")]
1952 pub is_associated_with_app_item: Option<bool>,
1953}
1954
1955#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1956pub struct FileMini {
1957 pub id: String,
1958 #[serde(
1959 default,
1960 skip_serializing_if = "Option::is_none",
1961 deserialize_with = "double_option"
1962 )]
1963 pub etag: Option<Option<String>>,
1964 pub r#type: AiCitationType,
1965 #[serde(default, skip_serializing_if = "Option::is_none")]
1966 pub sequence_id: Option<String>,
1967 #[serde(default, skip_serializing_if = "Option::is_none")]
1968 pub name: Option<String>,
1969 #[serde(default, skip_serializing_if = "Option::is_none")]
1970 pub sha1: Option<String>,
1971 #[serde(default, skip_serializing_if = "Option::is_none")]
1972 pub file_version: Option<FileVersionMini>,
1973}
1974
1975#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1976pub struct FileConflict {
1977 pub id: String,
1978 #[serde(
1979 default,
1980 skip_serializing_if = "Option::is_none",
1981 deserialize_with = "double_option"
1982 )]
1983 pub etag: Option<Option<String>>,
1984 pub r#type: AiCitationType,
1985 #[serde(default, skip_serializing_if = "Option::is_none")]
1986 pub sequence_id: Option<String>,
1987 #[serde(default, skip_serializing_if = "Option::is_none")]
1988 pub name: Option<String>,
1989 #[serde(default, skip_serializing_if = "Option::is_none")]
1990 pub sha1: Option<String>,
1991 #[serde(default, skip_serializing_if = "Option::is_none")]
1992 pub file_version: Option<FileVersionMini>,
1993}
1994
1995#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
1996pub struct FileRequest {
1997 pub id: String,
1998 pub r#type: FileRequestType,
1999 #[serde(default, skip_serializing_if = "Option::is_none")]
2000 pub title: Option<String>,
2001 #[serde(
2002 default,
2003 skip_serializing_if = "Option::is_none",
2004 deserialize_with = "double_option"
2005 )]
2006 pub description: Option<Option<String>>,
2007 #[serde(default, skip_serializing_if = "Option::is_none")]
2008 pub status: Option<FileRequestStatus>,
2009 #[serde(default, skip_serializing_if = "Option::is_none")]
2010 pub is_email_required: Option<bool>,
2011 #[serde(default, skip_serializing_if = "Option::is_none")]
2012 pub is_description_required: Option<bool>,
2013 #[serde(default, skip_serializing_if = "Option::is_none")]
2014 pub expires_at: Option<chrono::DateTime<chrono::Utc>>,
2015 pub folder: FolderMini,
2016 #[serde(default, skip_serializing_if = "Option::is_none")]
2017 pub url: Option<String>,
2018 #[serde(
2019 default,
2020 skip_serializing_if = "Option::is_none",
2021 deserialize_with = "double_option"
2022 )]
2023 pub etag: Option<Option<String>>,
2024 #[serde(default, skip_serializing_if = "Option::is_none")]
2025 pub created_by: Option<UserMini>,
2026 pub created_at: chrono::DateTime<chrono::Utc>,
2027 #[serde(default, skip_serializing_if = "Option::is_none")]
2028 pub updated_by: Option<UserMini>,
2029 pub updated_at: chrono::DateTime<chrono::Utc>,
2030}
2031
2032#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2033pub struct FileRequestCopyRequest {
2034 #[serde(default, skip_serializing_if = "Option::is_none")]
2035 pub title: Option<String>,
2036 #[serde(default, skip_serializing_if = "Option::is_none")]
2037 pub description: Option<String>,
2038 #[serde(default, skip_serializing_if = "Option::is_none")]
2039 pub status: Option<FileRequestStatus>,
2040 #[serde(default, skip_serializing_if = "Option::is_none")]
2041 pub is_email_required: Option<bool>,
2042 #[serde(default, skip_serializing_if = "Option::is_none")]
2043 pub is_description_required: Option<bool>,
2044 #[serde(default, skip_serializing_if = "Option::is_none")]
2045 pub expires_at: Option<chrono::DateTime<chrono::Utc>>,
2046 pub folder: FileRequestCopyRequestFolder,
2047}
2048
2049#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2050pub struct FileRequestUpdateRequest {
2051 #[serde(default, skip_serializing_if = "Option::is_none")]
2052 pub title: Option<String>,
2053 #[serde(default, skip_serializing_if = "Option::is_none")]
2054 pub description: Option<String>,
2055 #[serde(default, skip_serializing_if = "Option::is_none")]
2056 pub status: Option<FileRequestStatus>,
2057 #[serde(default, skip_serializing_if = "Option::is_none")]
2058 pub is_email_required: Option<bool>,
2059 #[serde(default, skip_serializing_if = "Option::is_none")]
2060 pub is_description_required: Option<bool>,
2061 #[serde(default, skip_serializing_if = "Option::is_none")]
2062 pub expires_at: Option<chrono::DateTime<chrono::Utc>>,
2063}
2064
2065#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2066pub struct Files {
2067 #[serde(default, skip_serializing_if = "Option::is_none")]
2068 pub total_count: Option<i64>,
2069 #[serde(default, skip_serializing_if = "Option::is_none")]
2070 pub entries: Option<Vec<FileFull>>,
2071}
2072
2073#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2074pub struct FilesOnHold {
2075 #[serde(default, skip_serializing_if = "Option::is_none")]
2076 pub limit: Option<i64>,
2077 #[serde(
2078 default,
2079 skip_serializing_if = "Option::is_none",
2080 deserialize_with = "double_option"
2081 )]
2082 pub next_marker: Option<Option<String>>,
2083 #[serde(
2084 default,
2085 skip_serializing_if = "Option::is_none",
2086 deserialize_with = "double_option"
2087 )]
2088 pub prev_marker: Option<Option<String>>,
2089 #[serde(default, skip_serializing_if = "Option::is_none")]
2090 pub entries: Option<Vec<FileMini>>,
2091}
2092
2093#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2094pub struct FilesUnderRetention {
2095 #[serde(default, skip_serializing_if = "Option::is_none")]
2096 pub limit: Option<i64>,
2097 #[serde(
2098 default,
2099 skip_serializing_if = "Option::is_none",
2100 deserialize_with = "double_option"
2101 )]
2102 pub next_marker: Option<Option<String>>,
2103 #[serde(
2104 default,
2105 skip_serializing_if = "Option::is_none",
2106 deserialize_with = "double_option"
2107 )]
2108 pub prev_marker: Option<Option<String>>,
2109 #[serde(default, skip_serializing_if = "Option::is_none")]
2110 pub entries: Option<Vec<FileMini>>,
2111}
2112
2113#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2114pub struct FileVersion {
2115 pub id: String,
2116 pub r#type: FileVersionType,
2117 #[serde(default, skip_serializing_if = "Option::is_none")]
2118 pub sha1: Option<String>,
2119 #[serde(default, skip_serializing_if = "Option::is_none")]
2120 pub name: Option<String>,
2121 #[serde(default, skip_serializing_if = "Option::is_none")]
2122 pub size: Option<i64>,
2123 #[serde(default, skip_serializing_if = "Option::is_none")]
2124 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2125 #[serde(default, skip_serializing_if = "Option::is_none")]
2126 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
2127 #[serde(default, skip_serializing_if = "Option::is_none")]
2128 pub modified_by: Option<UserMini>,
2129 #[serde(
2130 default,
2131 skip_serializing_if = "Option::is_none",
2132 deserialize_with = "double_option"
2133 )]
2134 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2135 #[serde(default, skip_serializing_if = "Option::is_none")]
2136 pub trashed_by: Option<UserMini>,
2137 #[serde(
2138 default,
2139 skip_serializing_if = "Option::is_none",
2140 deserialize_with = "double_option"
2141 )]
2142 pub restored_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2143 #[serde(default, skip_serializing_if = "Option::is_none")]
2144 pub restored_by: Option<UserMini>,
2145 #[serde(
2146 default,
2147 skip_serializing_if = "Option::is_none",
2148 deserialize_with = "double_option"
2149 )]
2150 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2151 #[serde(default, skip_serializing_if = "Option::is_none")]
2152 pub uploader_display_name: Option<String>,
2153}
2154
2155#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2156pub struct FileVersionBase {
2157 pub id: String,
2158 pub r#type: FileVersionType,
2159}
2160
2161#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2162pub struct FileVersionFull {
2163 pub id: String,
2164 pub r#type: FileVersionType,
2165 #[serde(default, skip_serializing_if = "Option::is_none")]
2166 pub sha1: Option<String>,
2167 #[serde(default, skip_serializing_if = "Option::is_none")]
2168 pub name: Option<String>,
2169 #[serde(default, skip_serializing_if = "Option::is_none")]
2170 pub size: Option<i64>,
2171 #[serde(default, skip_serializing_if = "Option::is_none")]
2172 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2173 #[serde(default, skip_serializing_if = "Option::is_none")]
2174 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
2175 #[serde(default, skip_serializing_if = "Option::is_none")]
2176 pub modified_by: Option<UserMini>,
2177 #[serde(
2178 default,
2179 skip_serializing_if = "Option::is_none",
2180 deserialize_with = "double_option"
2181 )]
2182 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2183 #[serde(default, skip_serializing_if = "Option::is_none")]
2184 pub trashed_by: Option<UserMini>,
2185 #[serde(
2186 default,
2187 skip_serializing_if = "Option::is_none",
2188 deserialize_with = "double_option"
2189 )]
2190 pub restored_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2191 #[serde(default, skip_serializing_if = "Option::is_none")]
2192 pub restored_by: Option<UserMini>,
2193 #[serde(
2194 default,
2195 skip_serializing_if = "Option::is_none",
2196 deserialize_with = "double_option"
2197 )]
2198 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2199 #[serde(default, skip_serializing_if = "Option::is_none")]
2200 pub uploader_display_name: Option<String>,
2201 #[serde(default, skip_serializing_if = "Option::is_none")]
2202 pub version_number: Option<String>,
2203}
2204
2205#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2206pub struct FileVersionMini {
2207 pub id: String,
2208 pub r#type: FileVersionType,
2209 #[serde(default, skip_serializing_if = "Option::is_none")]
2210 pub sha1: Option<String>,
2211}
2212
2213#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2214pub struct FileVersionLegalHold {
2215 #[serde(default, skip_serializing_if = "Option::is_none")]
2216 pub id: Option<String>,
2217 #[serde(default, skip_serializing_if = "Option::is_none")]
2218 pub r#type: Option<FileVersionLegalHoldType>,
2219 #[serde(default, skip_serializing_if = "Option::is_none")]
2220 pub file_version: Option<FileVersionMini>,
2221 #[serde(default, skip_serializing_if = "Option::is_none")]
2222 pub file: Option<FileMini>,
2223 #[serde(default, skip_serializing_if = "Option::is_none")]
2224 pub legal_hold_policy_assignments: Option<Vec<LegalHoldPolicyAssignment>>,
2225 #[serde(default, skip_serializing_if = "Option::is_none")]
2226 pub deleted_at: Option<chrono::DateTime<chrono::Utc>>,
2227}
2228
2229#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2230pub struct FileVersionLegalHolds {
2231 #[serde(default, skip_serializing_if = "Option::is_none")]
2232 pub limit: Option<i64>,
2233 #[serde(
2234 default,
2235 skip_serializing_if = "Option::is_none",
2236 deserialize_with = "double_option"
2237 )]
2238 pub next_marker: Option<Option<String>>,
2239 #[serde(
2240 default,
2241 skip_serializing_if = "Option::is_none",
2242 deserialize_with = "double_option"
2243 )]
2244 pub prev_marker: Option<Option<String>>,
2245 #[serde(default, skip_serializing_if = "Option::is_none")]
2246 pub entries: Option<Vec<FileVersionLegalHold>>,
2247}
2248
2249#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2250pub struct FileVersionRetention {
2251 #[serde(default, skip_serializing_if = "Option::is_none")]
2252 pub id: Option<String>,
2253 #[serde(default, skip_serializing_if = "Option::is_none")]
2254 pub r#type: Option<FileVersionRetentionType>,
2255 #[serde(default, skip_serializing_if = "Option::is_none")]
2256 pub file_version: Option<FileVersionMini>,
2257 #[serde(default, skip_serializing_if = "Option::is_none")]
2258 pub file: Option<FileMini>,
2259 #[serde(default, skip_serializing_if = "Option::is_none")]
2260 pub applied_at: Option<chrono::DateTime<chrono::Utc>>,
2261 #[serde(default, skip_serializing_if = "Option::is_none")]
2262 pub disposition_at: Option<chrono::DateTime<chrono::Utc>>,
2263 #[serde(default, skip_serializing_if = "Option::is_none")]
2264 pub winning_retention_policy: Option<RetentionPolicyMini>,
2265}
2266
2267#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2268pub struct FileVersionRetentions {
2269 #[serde(default, skip_serializing_if = "Option::is_none")]
2270 pub limit: Option<i64>,
2271 #[serde(
2272 default,
2273 skip_serializing_if = "Option::is_none",
2274 deserialize_with = "double_option"
2275 )]
2276 pub next_marker: Option<Option<String>>,
2277 #[serde(
2278 default,
2279 skip_serializing_if = "Option::is_none",
2280 deserialize_with = "double_option"
2281 )]
2282 pub prev_marker: Option<Option<String>>,
2283 #[serde(default, skip_serializing_if = "Option::is_none")]
2284 pub entries: Option<Vec<FileVersionRetention>>,
2285}
2286
2287#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2288pub struct FileVersions {
2289 #[serde(default, skip_serializing_if = "Option::is_none")]
2290 pub total_count: Option<i64>,
2291 #[serde(default, skip_serializing_if = "Option::is_none")]
2292 pub limit: Option<i64>,
2293 #[serde(default, skip_serializing_if = "Option::is_none")]
2294 pub offset: Option<i64>,
2295 #[serde(default, skip_serializing_if = "Option::is_none")]
2296 pub order: Option<Vec<CollectionsOrder>>,
2297 #[serde(default, skip_serializing_if = "Option::is_none")]
2298 pub entries: Option<Vec<FileVersionFull>>,
2299}
2300
2301#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2302pub struct FileVersionsOnHold {
2303 #[serde(default, skip_serializing_if = "Option::is_none")]
2304 pub limit: Option<i64>,
2305 #[serde(
2306 default,
2307 skip_serializing_if = "Option::is_none",
2308 deserialize_with = "double_option"
2309 )]
2310 pub next_marker: Option<Option<String>>,
2311 #[serde(
2312 default,
2313 skip_serializing_if = "Option::is_none",
2314 deserialize_with = "double_option"
2315 )]
2316 pub prev_marker: Option<Option<String>>,
2317 #[serde(default, skip_serializing_if = "Option::is_none")]
2318 pub entries: Option<Vec<FileVersion>>,
2319}
2320
2321#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2322pub struct Folder {
2323 pub id: String,
2324 #[serde(
2325 default,
2326 skip_serializing_if = "Option::is_none",
2327 deserialize_with = "double_option"
2328 )]
2329 pub etag: Option<Option<String>>,
2330 pub r#type: FolderType,
2331 #[serde(default, skip_serializing_if = "Option::is_none")]
2332 pub sequence_id: Option<String>,
2333 #[serde(default, skip_serializing_if = "Option::is_none")]
2334 pub name: Option<String>,
2335 #[serde(
2336 default,
2337 skip_serializing_if = "Option::is_none",
2338 deserialize_with = "double_option"
2339 )]
2340 pub created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2341 #[serde(
2342 default,
2343 skip_serializing_if = "Option::is_none",
2344 deserialize_with = "double_option"
2345 )]
2346 pub modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2347 #[serde(default, skip_serializing_if = "Option::is_none")]
2348 pub description: Option<String>,
2349 #[serde(default, skip_serializing_if = "Option::is_none")]
2350 pub size: Option<i64>,
2351 #[serde(default, skip_serializing_if = "Option::is_none")]
2352 pub path_collection: Option<FilePathCollection>,
2353 #[serde(default, skip_serializing_if = "Option::is_none")]
2354 pub created_by: Option<UserMini>,
2355 #[serde(default, skip_serializing_if = "Option::is_none")]
2356 pub modified_by: Option<UserMini>,
2357 #[serde(
2358 default,
2359 skip_serializing_if = "Option::is_none",
2360 deserialize_with = "double_option"
2361 )]
2362 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2363 #[serde(
2364 default,
2365 skip_serializing_if = "Option::is_none",
2366 deserialize_with = "double_option"
2367 )]
2368 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2369 #[serde(
2370 default,
2371 skip_serializing_if = "Option::is_none",
2372 deserialize_with = "double_option"
2373 )]
2374 pub content_created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2375 #[serde(
2376 default,
2377 skip_serializing_if = "Option::is_none",
2378 deserialize_with = "double_option"
2379 )]
2380 pub content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2381 #[serde(default, skip_serializing_if = "Option::is_none")]
2382 pub owned_by: Option<UserMini>,
2383 #[serde(
2384 default,
2385 skip_serializing_if = "Option::is_none",
2386 deserialize_with = "double_option"
2387 )]
2388 pub shared_link: Option<Option<FileSharedLink>>,
2389 #[serde(
2390 default,
2391 skip_serializing_if = "Option::is_none",
2392 deserialize_with = "double_option"
2393 )]
2394 pub folder_upload_email: Option<Option<FolderFolderUploadEmail>>,
2395 #[serde(
2396 default,
2397 skip_serializing_if = "Option::is_none",
2398 deserialize_with = "double_option"
2399 )]
2400 pub parent: Option<Option<FolderMini>>,
2401 #[serde(default, skip_serializing_if = "Option::is_none")]
2402 pub item_status: Option<FileItemStatus>,
2403 #[serde(default, skip_serializing_if = "Option::is_none")]
2404 pub item_collection: Option<Items>,
2405}
2406
2407#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2408pub struct FolderBase {
2409 pub id: String,
2410 #[serde(
2411 default,
2412 skip_serializing_if = "Option::is_none",
2413 deserialize_with = "double_option"
2414 )]
2415 pub etag: Option<Option<String>>,
2416 pub r#type: FolderType,
2417}
2418
2419#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2420pub struct FolderFull {
2421 pub id: String,
2422 #[serde(
2423 default,
2424 skip_serializing_if = "Option::is_none",
2425 deserialize_with = "double_option"
2426 )]
2427 pub etag: Option<Option<String>>,
2428 pub r#type: FolderType,
2429 #[serde(default, skip_serializing_if = "Option::is_none")]
2430 pub sequence_id: Option<String>,
2431 #[serde(default, skip_serializing_if = "Option::is_none")]
2432 pub name: Option<String>,
2433 #[serde(
2434 default,
2435 skip_serializing_if = "Option::is_none",
2436 deserialize_with = "double_option"
2437 )]
2438 pub created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2439 #[serde(
2440 default,
2441 skip_serializing_if = "Option::is_none",
2442 deserialize_with = "double_option"
2443 )]
2444 pub modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2445 #[serde(default, skip_serializing_if = "Option::is_none")]
2446 pub description: Option<String>,
2447 #[serde(default, skip_serializing_if = "Option::is_none")]
2448 pub size: Option<i64>,
2449 #[serde(default, skip_serializing_if = "Option::is_none")]
2450 pub path_collection: Option<FilePathCollection>,
2451 #[serde(default, skip_serializing_if = "Option::is_none")]
2452 pub created_by: Option<UserMini>,
2453 #[serde(default, skip_serializing_if = "Option::is_none")]
2454 pub modified_by: Option<UserMini>,
2455 #[serde(
2456 default,
2457 skip_serializing_if = "Option::is_none",
2458 deserialize_with = "double_option"
2459 )]
2460 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2461 #[serde(
2462 default,
2463 skip_serializing_if = "Option::is_none",
2464 deserialize_with = "double_option"
2465 )]
2466 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2467 #[serde(
2468 default,
2469 skip_serializing_if = "Option::is_none",
2470 deserialize_with = "double_option"
2471 )]
2472 pub content_created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2473 #[serde(
2474 default,
2475 skip_serializing_if = "Option::is_none",
2476 deserialize_with = "double_option"
2477 )]
2478 pub content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2479 #[serde(default, skip_serializing_if = "Option::is_none")]
2480 pub owned_by: Option<UserMini>,
2481 #[serde(
2482 default,
2483 skip_serializing_if = "Option::is_none",
2484 deserialize_with = "double_option"
2485 )]
2486 pub shared_link: Option<Option<FileSharedLink>>,
2487 #[serde(
2488 default,
2489 skip_serializing_if = "Option::is_none",
2490 deserialize_with = "double_option"
2491 )]
2492 pub folder_upload_email: Option<Option<FolderFolderUploadEmail>>,
2493 #[serde(
2494 default,
2495 skip_serializing_if = "Option::is_none",
2496 deserialize_with = "double_option"
2497 )]
2498 pub parent: Option<Option<FolderMini>>,
2499 #[serde(default, skip_serializing_if = "Option::is_none")]
2500 pub item_status: Option<FileItemStatus>,
2501 #[serde(default, skip_serializing_if = "Option::is_none")]
2502 pub item_collection: Option<Items>,
2503 #[serde(default, skip_serializing_if = "Option::is_none")]
2504 pub sync_state: Option<FolderFullSyncState>,
2505 #[serde(default, skip_serializing_if = "Option::is_none")]
2506 pub has_collaborations: Option<bool>,
2507 #[serde(default, skip_serializing_if = "Option::is_none")]
2508 pub permissions: Option<FolderFullPermissions>,
2509 #[serde(default, skip_serializing_if = "Option::is_none")]
2510 pub tags: Option<Vec<String>>,
2511 #[serde(default, skip_serializing_if = "Option::is_none")]
2512 pub can_non_owners_invite: Option<bool>,
2513 #[serde(default, skip_serializing_if = "Option::is_none")]
2514 pub is_externally_owned: Option<bool>,
2515 #[serde(default, skip_serializing_if = "Option::is_none")]
2516 pub metadata:
2517 Option<std::collections::HashMap<String, std::collections::HashMap<String, MetadataFull>>>,
2518 #[serde(default, skip_serializing_if = "Option::is_none")]
2519 pub is_collaboration_restricted_to_enterprise: Option<bool>,
2520 #[serde(default, skip_serializing_if = "Option::is_none")]
2521 pub allowed_shared_link_access_levels: Option<Vec<SharedLinkAccess>>,
2522 #[serde(default, skip_serializing_if = "Option::is_none")]
2523 pub allowed_invitee_roles: Option<Vec<FileFullAllowedInviteeRoles>>,
2524 #[serde(default, skip_serializing_if = "Option::is_none")]
2525 pub watermark_info: Option<FileFullWatermarkInfo>,
2526 #[serde(default, skip_serializing_if = "Option::is_none")]
2527 pub is_accessible_via_shared_link: Option<bool>,
2528 #[serde(default, skip_serializing_if = "Option::is_none")]
2529 pub can_non_owners_view_collaborators: Option<bool>,
2530 #[serde(
2531 default,
2532 skip_serializing_if = "Option::is_none",
2533 deserialize_with = "double_option"
2534 )]
2535 pub classification: Option<Option<FileFullClassification>>,
2536 #[serde(default, skip_serializing_if = "Option::is_none")]
2537 pub is_associated_with_app_item: Option<bool>,
2538}
2539
2540#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2541pub struct FolderMini {
2542 pub id: String,
2543 #[serde(
2544 default,
2545 skip_serializing_if = "Option::is_none",
2546 deserialize_with = "double_option"
2547 )]
2548 pub etag: Option<Option<String>>,
2549 pub r#type: FolderType,
2550 #[serde(default, skip_serializing_if = "Option::is_none")]
2551 pub sequence_id: Option<String>,
2552 #[serde(default, skip_serializing_if = "Option::is_none")]
2553 pub name: Option<String>,
2554}
2555
2556#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2557pub struct FolderLock {
2558 #[serde(default, skip_serializing_if = "Option::is_none")]
2559 pub folder: Option<FolderMini>,
2560 #[serde(default, skip_serializing_if = "Option::is_none")]
2561 pub id: Option<String>,
2562 #[serde(default, skip_serializing_if = "Option::is_none")]
2563 pub r#type: Option<String>,
2564 #[serde(default, skip_serializing_if = "Option::is_none")]
2565 pub created_by: Option<UserBase>,
2566 #[serde(default, skip_serializing_if = "Option::is_none")]
2567 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2568 #[serde(default, skip_serializing_if = "Option::is_none")]
2569 pub locked_operations: Option<FolderLockLockedOperations>,
2570 #[serde(default, skip_serializing_if = "Option::is_none")]
2571 pub lock_type: Option<String>,
2572}
2573
2574#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2575pub struct FolderLocks {
2576 #[serde(default, skip_serializing_if = "Option::is_none")]
2577 pub entries: Option<Vec<FolderLock>>,
2578 #[serde(default, skip_serializing_if = "Option::is_none")]
2579 pub limit: Option<String>,
2580 #[serde(
2581 default,
2582 skip_serializing_if = "Option::is_none",
2583 deserialize_with = "double_option"
2584 )]
2585 pub next_marker: Option<Option<String>>,
2586}
2587
2588#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2589pub struct FolderReference {
2590 pub r#type: FolderType,
2591 pub id: String,
2592}
2593
2594#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2595pub struct GenericSource {}
2596
2597#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2598pub struct Group {
2599 pub id: String,
2600 pub r#type: GroupType,
2601 #[serde(default, skip_serializing_if = "Option::is_none")]
2602 pub name: Option<String>,
2603 #[serde(default, skip_serializing_if = "Option::is_none")]
2604 pub group_type: Option<GroupGroupType>,
2605 #[serde(default, skip_serializing_if = "Option::is_none")]
2606 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2607 #[serde(default, skip_serializing_if = "Option::is_none")]
2608 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
2609}
2610
2611#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2612pub struct GroupBase {
2613 pub id: String,
2614 pub r#type: GroupType,
2615}
2616
2617#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2618pub struct GroupFull {
2619 pub id: String,
2620 pub r#type: GroupType,
2621 #[serde(default, skip_serializing_if = "Option::is_none")]
2622 pub name: Option<String>,
2623 #[serde(default, skip_serializing_if = "Option::is_none")]
2624 pub group_type: Option<GroupGroupType>,
2625 #[serde(default, skip_serializing_if = "Option::is_none")]
2626 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2627 #[serde(default, skip_serializing_if = "Option::is_none")]
2628 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
2629 #[serde(default, skip_serializing_if = "Option::is_none")]
2630 pub provenance: Option<String>,
2631 #[serde(default, skip_serializing_if = "Option::is_none")]
2632 pub external_sync_identifier: Option<String>,
2633 #[serde(default, skip_serializing_if = "Option::is_none")]
2634 pub description: Option<String>,
2635 #[serde(default, skip_serializing_if = "Option::is_none")]
2636 pub invitability_level: Option<GroupFullInvitabilityLevel>,
2637 #[serde(default, skip_serializing_if = "Option::is_none")]
2638 pub member_viewability_level: Option<GroupFullInvitabilityLevel>,
2639 #[serde(default, skip_serializing_if = "Option::is_none")]
2640 pub permissions: Option<GroupFullPermissions>,
2641}
2642
2643#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2644pub struct GroupMini {
2645 pub id: String,
2646 pub r#type: GroupType,
2647 #[serde(default, skip_serializing_if = "Option::is_none")]
2648 pub name: Option<String>,
2649 #[serde(default, skip_serializing_if = "Option::is_none")]
2650 pub group_type: Option<GroupGroupType>,
2651}
2652
2653#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2654pub struct GroupMembership {
2655 #[serde(default, skip_serializing_if = "Option::is_none")]
2656 pub id: Option<String>,
2657 #[serde(default, skip_serializing_if = "Option::is_none")]
2658 pub r#type: Option<GroupMembershipType>,
2659 #[serde(default, skip_serializing_if = "Option::is_none")]
2660 pub user: Option<UserMini>,
2661 #[serde(default, skip_serializing_if = "Option::is_none")]
2662 pub group: Option<GroupMini>,
2663 #[serde(default, skip_serializing_if = "Option::is_none")]
2664 pub role: Option<GroupMembershipRole>,
2665 #[serde(default, skip_serializing_if = "Option::is_none")]
2666 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2667 #[serde(default, skip_serializing_if = "Option::is_none")]
2668 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
2669}
2670
2671#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2672pub struct GroupMemberships {
2673 #[serde(default, skip_serializing_if = "Option::is_none")]
2674 pub total_count: Option<i64>,
2675 #[serde(default, skip_serializing_if = "Option::is_none")]
2676 pub limit: Option<i64>,
2677 #[serde(default, skip_serializing_if = "Option::is_none")]
2678 pub offset: Option<i64>,
2679 #[serde(default, skip_serializing_if = "Option::is_none")]
2680 pub order: Option<Vec<CollectionsOrder>>,
2681 #[serde(default, skip_serializing_if = "Option::is_none")]
2682 pub entries: Option<Vec<GroupMembership>>,
2683}
2684
2685#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2686pub struct Groups {
2687 #[serde(default, skip_serializing_if = "Option::is_none")]
2688 pub total_count: Option<i64>,
2689 #[serde(default, skip_serializing_if = "Option::is_none")]
2690 pub limit: Option<i64>,
2691 #[serde(default, skip_serializing_if = "Option::is_none")]
2692 pub offset: Option<i64>,
2693 #[serde(default, skip_serializing_if = "Option::is_none")]
2694 pub order: Option<Vec<CollectionsOrder>>,
2695 #[serde(default, skip_serializing_if = "Option::is_none")]
2696 pub entries: Option<Vec<GroupFull>>,
2697}
2698
2699#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2700pub struct IntegrationMapping {
2701 pub id: String,
2702 pub r#type: IntegrationMappingType,
2703 #[serde(default, skip_serializing_if = "Option::is_none")]
2704 pub integration_type: Option<IntegrationMappingIntegrationType>,
2705 #[serde(default, skip_serializing_if = "Option::is_none")]
2706 pub is_manually_created: Option<bool>,
2707 #[serde(default, skip_serializing_if = "Option::is_none")]
2708 pub options: Option<IntegrationMappingSlackOptions>,
2709 #[serde(default, skip_serializing_if = "Option::is_none")]
2710 pub created_by: Option<UserIntegrationMappings>,
2711 #[serde(default, skip_serializing_if = "Option::is_none")]
2712 pub modified_by: Option<UserIntegrationMappings>,
2713 pub partner_item: IntegrationMappingPartnerItemSlack,
2714 pub box_item: FolderMini,
2715 #[serde(default, skip_serializing_if = "Option::is_none")]
2716 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2717 #[serde(default, skip_serializing_if = "Option::is_none")]
2718 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
2719}
2720
2721#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2722pub struct IntegrationMappingBase {
2723 pub id: String,
2724 pub r#type: IntegrationMappingType,
2725}
2726
2727#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2728pub struct IntegrationMappingBoxItemSlack {
2729 pub r#type: FolderType,
2730 pub id: String,
2731}
2732
2733#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2734pub struct IntegrationMappingPartnerItemSlack {
2735 pub r#type: IntegrationMappingPartnerItemSlackType,
2736 pub id: String,
2737 #[serde(
2738 default,
2739 skip_serializing_if = "Option::is_none",
2740 deserialize_with = "double_option"
2741 )]
2742 pub slack_workspace_id: Option<Option<String>>,
2743 #[serde(
2744 default,
2745 skip_serializing_if = "Option::is_none",
2746 deserialize_with = "double_option"
2747 )]
2748 pub slack_org_id: Option<Option<String>>,
2749}
2750
2751#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2752pub struct IntegrationMappingPartnerItemTeams {
2753 pub r#type: IntegrationMappingPartnerItemTeamsType,
2754 pub id: String,
2755 pub tenant_id: String,
2756}
2757
2758#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2759pub struct IntegrationMappingPartnerItemTeamsCreateRequest {
2760 pub r#type: IntegrationMappingPartnerItemTeamsType,
2761 pub id: String,
2762 pub tenant_id: String,
2763 pub team_id: String,
2764}
2765
2766#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2767pub struct IntegrationMappings {
2768 #[serde(default, skip_serializing_if = "Option::is_none")]
2769 pub limit: Option<i64>,
2770 #[serde(
2771 default,
2772 skip_serializing_if = "Option::is_none",
2773 deserialize_with = "double_option"
2774 )]
2775 pub next_marker: Option<Option<String>>,
2776 #[serde(default, skip_serializing_if = "Option::is_none")]
2777 pub entries: Option<Vec<IntegrationMapping>>,
2778}
2779
2780#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2781pub struct IntegrationMappingSlackCreateRequest {
2782 pub partner_item: IntegrationMappingPartnerItemSlack,
2783 pub box_item: IntegrationMappingBoxItemSlack,
2784 #[serde(default, skip_serializing_if = "Option::is_none")]
2785 pub options: Option<IntegrationMappingSlackOptions>,
2786}
2787
2788#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2789pub struct IntegrationMappingSlackOptions {
2790 #[serde(default, skip_serializing_if = "Option::is_none")]
2791 pub is_access_management_disabled: Option<bool>,
2792}
2793
2794#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2795pub struct IntegrationMappingsTeams {
2796 #[serde(default, skip_serializing_if = "Option::is_none")]
2797 pub entries: Option<Vec<IntegrationMappingTeams>>,
2798}
2799
2800#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2801pub struct IntegrationMappingTeams {
2802 pub id: String,
2803 pub r#type: IntegrationMappingType,
2804 #[serde(default, skip_serializing_if = "Option::is_none")]
2805 pub integration_type: Option<IntegrationMappingTeamsIntegrationType>,
2806 #[serde(default, skip_serializing_if = "Option::is_none")]
2807 pub is_overridden_by_manual_mapping: Option<bool>,
2808 pub partner_item: IntegrationMappingPartnerItemTeams,
2809 pub box_item: FolderReference,
2810 #[serde(default, skip_serializing_if = "Option::is_none")]
2811 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2812 #[serde(default, skip_serializing_if = "Option::is_none")]
2813 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
2814}
2815
2816#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2817pub struct IntegrationMappingTeamsCreateRequest {
2818 pub partner_item: IntegrationMappingPartnerItemTeamsCreateRequest,
2819 pub box_item: FolderReference,
2820}
2821
2822#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2823pub struct Invite {
2824 pub id: String,
2825 pub r#type: InviteType,
2826 #[serde(default, skip_serializing_if = "Option::is_none")]
2827 pub invited_to: Option<CollaborationAllowlistEntryEnterprise>,
2828 #[serde(default, skip_serializing_if = "Option::is_none")]
2829 pub actionable_by: Option<UserMini>,
2830 #[serde(default, skip_serializing_if = "Option::is_none")]
2831 pub invited_by: Option<UserMini>,
2832 #[serde(default, skip_serializing_if = "Option::is_none")]
2833 pub status: Option<String>,
2834 #[serde(default, skip_serializing_if = "Option::is_none")]
2835 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2836 #[serde(default, skip_serializing_if = "Option::is_none")]
2837 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
2838}
2839
2840#[derive(Clone, Debug, PartialEq)]
2841pub enum Item {
2842 File(FileFull),
2843 Folder(FolderMini),
2844 WebLink(WebLink),
2845 Unknown(serde_json::Value),
2847}
2848
2849impl serde::Serialize for Item {
2850 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
2851 match self {
2852 Self::File(inner) => inner.serialize(serializer),
2853 Self::Folder(inner) => inner.serialize(serializer),
2854 Self::WebLink(inner) => inner.serialize(serializer),
2855 Self::Unknown(inner) => inner.serialize(serializer),
2856 }
2857 }
2858}
2859
2860impl<'de> serde::Deserialize<'de> for Item {
2861 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2862 let value = serde_json::Value::deserialize(deserializer)?;
2863 let tag = value
2864 .get("type")
2865 .and_then(serde_json::Value::as_str)
2866 .map(str::to_owned);
2867 match tag.as_deref() {
2868 Some("file") => Ok(Self::File(
2869 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
2870 )),
2871 Some("folder") => Ok(Self::Folder(
2872 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
2873 )),
2874 Some("web_link") => Ok(Self::WebLink(
2875 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
2876 )),
2877 _ => Ok(Self::Unknown(value)),
2878 }
2879 }
2880}
2881
2882#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2883pub struct Items {
2884 #[serde(default, skip_serializing_if = "Option::is_none")]
2885 pub limit: Option<i64>,
2886 #[serde(
2887 default,
2888 skip_serializing_if = "Option::is_none",
2889 deserialize_with = "double_option"
2890 )]
2891 pub next_marker: Option<Option<String>>,
2892 #[serde(
2893 default,
2894 skip_serializing_if = "Option::is_none",
2895 deserialize_with = "double_option"
2896 )]
2897 pub prev_marker: Option<Option<String>>,
2898 #[serde(default, skip_serializing_if = "Option::is_none")]
2899 pub total_count: Option<i64>,
2900 #[serde(default, skip_serializing_if = "Option::is_none")]
2901 pub offset: Option<i64>,
2902 #[serde(default, skip_serializing_if = "Option::is_none")]
2903 pub order: Option<Vec<CollectionsOrder>>,
2904 #[serde(default, skip_serializing_if = "Option::is_none")]
2905 pub entries: Option<Vec<Item>>,
2906}
2907
2908#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2909pub struct ItemsOffsetPaginated {
2910 #[serde(default, skip_serializing_if = "Option::is_none")]
2911 pub total_count: Option<i64>,
2912 #[serde(default, skip_serializing_if = "Option::is_none")]
2913 pub limit: Option<i64>,
2914 #[serde(default, skip_serializing_if = "Option::is_none")]
2915 pub offset: Option<i64>,
2916 #[serde(default, skip_serializing_if = "Option::is_none")]
2917 pub order: Option<Vec<CollectionsOrder>>,
2918 #[serde(default, skip_serializing_if = "Option::is_none")]
2919 pub entries: Option<Vec<Item>>,
2920}
2921
2922#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2923pub struct KeywordSkillCard {
2924 #[serde(default, skip_serializing_if = "Option::is_none")]
2925 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2926 pub r#type: KeywordSkillCardType,
2927 pub skill_card_type: KeywordSkillCardSkillCardType,
2928 #[serde(default, skip_serializing_if = "Option::is_none")]
2929 pub skill_card_title: Option<KeywordSkillCardSkillCardTitle>,
2930 pub skill: KeywordSkillCardSkill,
2931 pub invocation: KeywordSkillCardInvocation,
2932 pub entries: Vec<KeywordSkillCardEntries>,
2933}
2934
2935#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2936pub struct LegalHoldPolicies {
2937 #[serde(default, skip_serializing_if = "Option::is_none")]
2938 pub limit: Option<i64>,
2939 #[serde(
2940 default,
2941 skip_serializing_if = "Option::is_none",
2942 deserialize_with = "double_option"
2943 )]
2944 pub next_marker: Option<Option<String>>,
2945 #[serde(
2946 default,
2947 skip_serializing_if = "Option::is_none",
2948 deserialize_with = "double_option"
2949 )]
2950 pub prev_marker: Option<Option<String>>,
2951 #[serde(default, skip_serializing_if = "Option::is_none")]
2952 pub entries: Option<Vec<LegalHoldPolicy>>,
2953}
2954
2955#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2956pub struct LegalHoldPolicy {
2957 pub id: String,
2958 pub r#type: LegalHoldPolicyType,
2959 #[serde(default, skip_serializing_if = "Option::is_none")]
2960 pub policy_name: Option<String>,
2961 #[serde(default, skip_serializing_if = "Option::is_none")]
2962 pub description: Option<String>,
2963 #[serde(default, skip_serializing_if = "Option::is_none")]
2964 pub status: Option<LegalHoldPolicyStatus>,
2965 #[serde(default, skip_serializing_if = "Option::is_none")]
2966 pub assignment_counts: Option<LegalHoldPolicyAssignmentCounts>,
2967 #[serde(default, skip_serializing_if = "Option::is_none")]
2968 pub created_by: Option<UserMini>,
2969 #[serde(default, skip_serializing_if = "Option::is_none")]
2970 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2971 #[serde(default, skip_serializing_if = "Option::is_none")]
2972 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
2973 #[serde(default, skip_serializing_if = "Option::is_none")]
2974 pub deleted_at: Option<chrono::DateTime<chrono::Utc>>,
2975 #[serde(default, skip_serializing_if = "Option::is_none")]
2976 pub filter_started_at: Option<chrono::DateTime<chrono::Utc>>,
2977 #[serde(default, skip_serializing_if = "Option::is_none")]
2978 pub filter_ended_at: Option<chrono::DateTime<chrono::Utc>>,
2979 #[serde(default, skip_serializing_if = "Option::is_none")]
2980 pub release_notes: Option<String>,
2981}
2982
2983#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2984pub struct LegalHoldPolicyMini {
2985 pub id: String,
2986 pub r#type: LegalHoldPolicyType,
2987}
2988
2989#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2990pub struct LegalHoldPolicyAssignedItem {
2991 pub r#type: LegalHoldPolicyAssignedItemType,
2992 pub id: String,
2993}
2994
2995#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
2996pub struct LegalHoldPolicyAssignment {
2997 #[serde(default, skip_serializing_if = "Option::is_none")]
2998 pub id: Option<String>,
2999 #[serde(default, skip_serializing_if = "Option::is_none")]
3000 pub r#type: Option<LegalHoldPolicyAssignmentType>,
3001 #[serde(default, skip_serializing_if = "Option::is_none")]
3002 pub legal_hold_policy: Option<LegalHoldPolicyMini>,
3003 #[serde(default, skip_serializing_if = "Option::is_none")]
3004 pub assigned_to: Option<LegalHoldPolicyAssignedItem>,
3005 #[serde(default, skip_serializing_if = "Option::is_none")]
3006 pub assigned_by: Option<UserMini>,
3007 #[serde(default, skip_serializing_if = "Option::is_none")]
3008 pub assigned_at: Option<chrono::DateTime<chrono::Utc>>,
3009 #[serde(default, skip_serializing_if = "Option::is_none")]
3010 pub deleted_at: Option<chrono::DateTime<chrono::Utc>>,
3011}
3012
3013#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3014pub struct LegalHoldPolicyAssignmentBase {
3015 #[serde(default, skip_serializing_if = "Option::is_none")]
3016 pub id: Option<String>,
3017 #[serde(default, skip_serializing_if = "Option::is_none")]
3018 pub r#type: Option<LegalHoldPolicyAssignmentType>,
3019}
3020
3021#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3022pub struct LegalHoldPolicyAssignments {
3023 #[serde(default, skip_serializing_if = "Option::is_none")]
3024 pub limit: Option<i64>,
3025 #[serde(
3026 default,
3027 skip_serializing_if = "Option::is_none",
3028 deserialize_with = "double_option"
3029 )]
3030 pub next_marker: Option<Option<String>>,
3031 #[serde(
3032 default,
3033 skip_serializing_if = "Option::is_none",
3034 deserialize_with = "double_option"
3035 )]
3036 pub prev_marker: Option<Option<String>>,
3037 #[serde(default, skip_serializing_if = "Option::is_none")]
3038 pub entries: Option<Vec<LegalHoldPolicyAssignment>>,
3039}
3040
3041pub type Metadata = MetadataBase;
3042
3043#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3044pub struct MetadataBase {
3045 #[serde(rename = "$parent", default, skip_serializing_if = "Option::is_none")]
3046 pub parent: Option<String>,
3047 #[serde(rename = "$template", default, skip_serializing_if = "Option::is_none")]
3048 pub template: Option<String>,
3049 #[serde(rename = "$scope", default, skip_serializing_if = "Option::is_none")]
3050 pub scope: Option<String>,
3051 #[serde(rename = "$version", default, skip_serializing_if = "Option::is_none")]
3052 pub version: Option<i64>,
3053}
3054
3055#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3056pub struct MetadataFull {
3057 #[serde(rename = "$parent", default, skip_serializing_if = "Option::is_none")]
3058 pub parent: Option<String>,
3059 #[serde(rename = "$template", default, skip_serializing_if = "Option::is_none")]
3060 pub template: Option<String>,
3061 #[serde(rename = "$scope", default, skip_serializing_if = "Option::is_none")]
3062 pub scope: Option<String>,
3063 #[serde(rename = "$version", default, skip_serializing_if = "Option::is_none")]
3064 pub version: Option<i64>,
3065 #[serde(rename = "$canEdit", default, skip_serializing_if = "Option::is_none")]
3066 pub can_edit: Option<bool>,
3067 #[serde(rename = "$id", default, skip_serializing_if = "Option::is_none")]
3068 pub id: Option<String>,
3069 #[serde(rename = "$type", default, skip_serializing_if = "Option::is_none")]
3070 pub r#type: Option<String>,
3071 #[serde(
3072 rename = "$typeVersion",
3073 default,
3074 skip_serializing_if = "Option::is_none"
3075 )]
3076 pub type_version: Option<i64>,
3077}
3078
3079#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3080pub struct MetadataCascadePolicies {
3081 #[serde(default, skip_serializing_if = "Option::is_none")]
3082 pub limit: Option<i64>,
3083 #[serde(
3084 default,
3085 skip_serializing_if = "Option::is_none",
3086 deserialize_with = "double_option"
3087 )]
3088 pub next_marker: Option<Option<String>>,
3089 #[serde(
3090 default,
3091 skip_serializing_if = "Option::is_none",
3092 deserialize_with = "double_option"
3093 )]
3094 pub prev_marker: Option<Option<String>>,
3095 #[serde(default, skip_serializing_if = "Option::is_none")]
3096 pub entries: Option<Vec<MetadataCascadePolicy>>,
3097}
3098
3099#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3100pub struct MetadataCascadePolicy {
3101 pub id: String,
3102 pub r#type: MetadataCascadePolicyType,
3103 #[serde(default, skip_serializing_if = "Option::is_none")]
3104 pub owner_enterprise: Option<MetadataCascadePolicyOwnerEnterprise>,
3105 #[serde(default, skip_serializing_if = "Option::is_none")]
3106 pub parent: Option<MetadataCascadePolicyParent>,
3107 #[serde(default, skip_serializing_if = "Option::is_none")]
3108 pub scope: Option<String>,
3109 #[serde(
3110 rename = "templateKey",
3111 default,
3112 skip_serializing_if = "Option::is_none"
3113 )]
3114 pub template_key: Option<String>,
3115}
3116
3117#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3118pub struct MetadataError {
3119 #[serde(default, skip_serializing_if = "Option::is_none")]
3120 pub code: Option<String>,
3121 #[serde(default, skip_serializing_if = "Option::is_none")]
3122 pub message: Option<String>,
3123 #[serde(default, skip_serializing_if = "Option::is_none")]
3124 pub request_id: Option<String>,
3125}
3126
3127#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3128pub struct MetadataFieldFilterDateRange {
3129 #[serde(default, skip_serializing_if = "Option::is_none")]
3130 pub lt: Option<chrono::DateTime<chrono::Utc>>,
3131 #[serde(default, skip_serializing_if = "Option::is_none")]
3132 pub gt: Option<chrono::DateTime<chrono::Utc>>,
3133}
3134
3135#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3136pub struct MetadataFieldFilterFloatRange {
3137 #[serde(default, skip_serializing_if = "Option::is_none")]
3138 pub lt: Option<f64>,
3139 #[serde(default, skip_serializing_if = "Option::is_none")]
3140 pub gt: Option<f64>,
3141}
3142
3143#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3144pub struct MetadataFilter {
3145 #[serde(default, skip_serializing_if = "Option::is_none")]
3146 pub scope: Option<MetadataFilterScope>,
3147 #[serde(
3148 rename = "templateKey",
3149 default,
3150 skip_serializing_if = "Option::is_none"
3151 )]
3152 pub template_key: Option<String>,
3153 #[serde(default, skip_serializing_if = "Option::is_none")]
3154 pub filters: Option<std::collections::HashMap<String, MetadataFilterValue>>,
3155}
3156
3157#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3158#[serde(transparent)]
3159pub struct MetadataFilterValue(pub serde_json::Value);
3160
3161#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3162#[serde(transparent)]
3163pub struct MetadataInstanceValue(pub serde_json::Value);
3164
3165#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3166pub struct MetadataQuery {
3167 pub from: String,
3168 #[serde(default, skip_serializing_if = "Option::is_none")]
3169 pub query: Option<String>,
3170 #[serde(default, skip_serializing_if = "Option::is_none")]
3171 pub query_params: Option<std::collections::HashMap<String, serde_json::Value>>,
3172 pub ancestor_folder_id: String,
3173 #[serde(default, skip_serializing_if = "Option::is_none")]
3174 pub order_by: Option<Vec<MetadataQueryOrderBy>>,
3175 #[serde(default, skip_serializing_if = "Option::is_none")]
3176 pub limit: Option<i64>,
3177 #[serde(default, skip_serializing_if = "Option::is_none")]
3178 pub marker: Option<String>,
3179 #[serde(default, skip_serializing_if = "Option::is_none")]
3180 pub fields: Option<Vec<String>>,
3181}
3182
3183#[derive(Clone, Debug, PartialEq)]
3184pub enum MetadataQueryResultItem {
3185 File(FileFull),
3186 Folder(FolderFull),
3187 Unknown(serde_json::Value),
3189}
3190
3191impl serde::Serialize for MetadataQueryResultItem {
3192 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3193 match self {
3194 Self::File(inner) => inner.serialize(serializer),
3195 Self::Folder(inner) => inner.serialize(serializer),
3196 Self::Unknown(inner) => inner.serialize(serializer),
3197 }
3198 }
3199}
3200
3201impl<'de> serde::Deserialize<'de> for MetadataQueryResultItem {
3202 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3203 let value = serde_json::Value::deserialize(deserializer)?;
3204 let tag = value
3205 .get("type")
3206 .and_then(serde_json::Value::as_str)
3207 .map(str::to_owned);
3208 match tag.as_deref() {
3209 Some("file") => Ok(Self::File(
3210 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3211 )),
3212 Some("folder") => Ok(Self::Folder(
3213 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3214 )),
3215 _ => Ok(Self::Unknown(value)),
3216 }
3217 }
3218}
3219
3220#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3221pub struct MetadataQueryResults {
3222 #[serde(default, skip_serializing_if = "Option::is_none")]
3223 pub entries: Option<Vec<MetadataQueryResultItem>>,
3224 #[serde(default, skip_serializing_if = "Option::is_none")]
3225 pub limit: Option<i64>,
3226 #[serde(default, skip_serializing_if = "Option::is_none")]
3227 pub next_marker: Option<String>,
3228}
3229
3230#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3231pub struct Metadatas {
3232 #[serde(default, skip_serializing_if = "Option::is_none")]
3233 pub entries: Option<Vec<Metadata>>,
3234 #[serde(default, skip_serializing_if = "Option::is_none")]
3235 pub limit: Option<i64>,
3236}
3237
3238#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3239pub struct MetadataTaxonomies {
3240 #[serde(default, skip_serializing_if = "Option::is_none")]
3241 pub limit: Option<i64>,
3242 #[serde(
3243 default,
3244 skip_serializing_if = "Option::is_none",
3245 deserialize_with = "double_option"
3246 )]
3247 pub next_marker: Option<Option<String>>,
3248 #[serde(
3249 default,
3250 skip_serializing_if = "Option::is_none",
3251 deserialize_with = "double_option"
3252 )]
3253 pub prev_marker: Option<Option<String>>,
3254 #[serde(default, skip_serializing_if = "Option::is_none")]
3255 pub entries: Option<Vec<MetadataTaxonomy>>,
3256}
3257
3258#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3259pub struct MetadataTaxonomy {
3260 pub id: String,
3261 #[serde(default, skip_serializing_if = "Option::is_none")]
3262 pub key: Option<String>,
3263 #[serde(rename = "displayName")]
3264 pub display_name: String,
3265 pub namespace: String,
3266 #[serde(default, skip_serializing_if = "Option::is_none")]
3267 pub levels: Option<Vec<MetadataTaxonomyLevel>>,
3268}
3269
3270#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3271pub struct MetadataTaxonomyAncestor {
3272 #[serde(default, skip_serializing_if = "Option::is_none")]
3273 pub id: Option<String>,
3274 #[serde(
3275 rename = "displayName",
3276 default,
3277 skip_serializing_if = "Option::is_none"
3278 )]
3279 pub display_name: Option<String>,
3280 #[serde(default, skip_serializing_if = "Option::is_none")]
3281 pub level: Option<i64>,
3282}
3283
3284#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3285pub struct MetadataTaxonomyLevel {
3286 #[serde(
3287 rename = "displayName",
3288 default,
3289 skip_serializing_if = "Option::is_none"
3290 )]
3291 pub display_name: Option<String>,
3292 #[serde(default, skip_serializing_if = "Option::is_none")]
3293 pub description: Option<String>,
3294 #[serde(default, skip_serializing_if = "Option::is_none")]
3295 pub level: Option<i64>,
3296}
3297
3298#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3299pub struct MetadataTaxonomyLevels {
3300 #[serde(default, skip_serializing_if = "Option::is_none")]
3301 pub entries: Option<Vec<MetadataTaxonomyLevel>>,
3302}
3303
3304#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3305pub struct MetadataTaxonomyNode {
3306 pub id: String,
3307 #[serde(rename = "displayName")]
3308 pub display_name: String,
3309 pub level: i64,
3310 #[serde(rename = "parentId", default, skip_serializing_if = "Option::is_none")]
3311 pub parent_id: Option<String>,
3312 #[serde(rename = "nodePath", default, skip_serializing_if = "Option::is_none")]
3313 pub node_path: Option<Vec<String>>,
3314 #[serde(default, skip_serializing_if = "Option::is_none")]
3315 pub ancestors: Option<Vec<MetadataTaxonomyAncestor>>,
3316}
3317
3318#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3319pub struct MetadataTaxonomyNodes {
3320 #[serde(default, skip_serializing_if = "Option::is_none")]
3321 pub limit: Option<i64>,
3322 #[serde(
3323 default,
3324 skip_serializing_if = "Option::is_none",
3325 deserialize_with = "double_option"
3326 )]
3327 pub next_marker: Option<Option<String>>,
3328 #[serde(
3329 default,
3330 skip_serializing_if = "Option::is_none",
3331 deserialize_with = "double_option"
3332 )]
3333 pub prev_marker: Option<Option<String>>,
3334 #[serde(default, skip_serializing_if = "Option::is_none")]
3335 pub entries: Option<Vec<MetadataTaxonomyNode>>,
3336}
3337
3338#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3339pub struct MetadataTemplate {
3340 pub id: String,
3341 pub r#type: MetadataTemplateType,
3342 #[serde(default, skip_serializing_if = "Option::is_none")]
3343 pub scope: Option<String>,
3344 #[serde(
3345 rename = "templateKey",
3346 default,
3347 skip_serializing_if = "Option::is_none"
3348 )]
3349 pub template_key: Option<String>,
3350 #[serde(
3351 rename = "displayName",
3352 default,
3353 skip_serializing_if = "Option::is_none"
3354 )]
3355 pub display_name: Option<String>,
3356 #[serde(default, skip_serializing_if = "Option::is_none")]
3357 pub hidden: Option<bool>,
3358 #[serde(default, skip_serializing_if = "Option::is_none")]
3359 pub fields: Option<Vec<MetadataTemplateFields>>,
3360 #[serde(
3361 rename = "copyInstanceOnItemCopy",
3362 default,
3363 skip_serializing_if = "Option::is_none"
3364 )]
3365 pub copy_instance_on_item_copy: Option<bool>,
3366}
3367
3368#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3369pub struct MetadataTemplates {
3370 #[serde(default, skip_serializing_if = "Option::is_none")]
3371 pub limit: Option<i64>,
3372 #[serde(
3373 default,
3374 skip_serializing_if = "Option::is_none",
3375 deserialize_with = "double_option"
3376 )]
3377 pub next_marker: Option<Option<String>>,
3378 #[serde(
3379 default,
3380 skip_serializing_if = "Option::is_none",
3381 deserialize_with = "double_option"
3382 )]
3383 pub prev_marker: Option<Option<String>>,
3384 #[serde(default, skip_serializing_if = "Option::is_none")]
3385 pub entries: Option<Vec<MetadataTemplate>>,
3386}
3387
3388#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3389pub struct OAuth2Error {
3390 #[serde(default, skip_serializing_if = "Option::is_none")]
3391 pub error: Option<String>,
3392 #[serde(default, skip_serializing_if = "Option::is_none")]
3393 pub error_description: Option<String>,
3394}
3395
3396#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3397pub struct Outcome {
3398 pub id: String,
3399 #[serde(default, skip_serializing_if = "Option::is_none")]
3400 pub collaborators: Option<CollaboratorVariable>,
3401 #[serde(default, skip_serializing_if = "Option::is_none")]
3402 pub completion_rule: Option<CompletionRuleVariable>,
3403 #[serde(default, skip_serializing_if = "Option::is_none")]
3404 pub file_collaborator_role: Option<RoleVariable>,
3405 #[serde(default, skip_serializing_if = "Option::is_none")]
3406 pub task_collaborators: Option<CollaboratorVariable>,
3407 #[serde(default, skip_serializing_if = "Option::is_none")]
3408 pub role: Option<RoleVariable>,
3409}
3410
3411#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3412pub struct PostOAuth2Revoke {
3413 #[serde(default, skip_serializing_if = "Option::is_none")]
3414 pub client_id: Option<String>,
3415 #[serde(default, skip_serializing_if = "Option::is_none")]
3416 pub client_secret: Option<String>,
3417 #[serde(default, skip_serializing_if = "Option::is_none")]
3418 pub token: Option<String>,
3419}
3420
3421#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3422pub struct PostOAuth2Token {
3423 pub grant_type: PostOAuth2TokenGrantType,
3424 #[serde(default, skip_serializing_if = "Option::is_none")]
3425 pub client_id: Option<String>,
3426 #[serde(default, skip_serializing_if = "Option::is_none")]
3427 pub client_secret: Option<String>,
3428 #[serde(default, skip_serializing_if = "Option::is_none")]
3429 pub code: Option<String>,
3430 #[serde(default, skip_serializing_if = "Option::is_none")]
3431 pub refresh_token: Option<String>,
3432 #[serde(default, skip_serializing_if = "Option::is_none")]
3433 pub assertion: Option<String>,
3434 #[serde(default, skip_serializing_if = "Option::is_none")]
3435 pub subject_token: Option<String>,
3436 #[serde(default, skip_serializing_if = "Option::is_none")]
3437 pub subject_token_type: Option<AccessTokenIssuedTokenType>,
3438 #[serde(default, skip_serializing_if = "Option::is_none")]
3439 pub actor_token: Option<String>,
3440 #[serde(default, skip_serializing_if = "Option::is_none")]
3441 pub actor_token_type: Option<PostOAuth2TokenActorTokenType>,
3442 #[serde(default, skip_serializing_if = "Option::is_none")]
3443 pub scope: Option<String>,
3444 #[serde(default, skip_serializing_if = "Option::is_none")]
3445 pub resource: Option<String>,
3446 #[serde(default, skip_serializing_if = "Option::is_none")]
3447 pub box_subject_type: Option<PostOAuth2TokenBoxSubjectType>,
3448 #[serde(default, skip_serializing_if = "Option::is_none")]
3449 pub box_subject_id: Option<String>,
3450 #[serde(default, skip_serializing_if = "Option::is_none")]
3451 pub box_shared_link: Option<String>,
3452}
3453
3454#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3455pub struct PostOAuth2TokenRefreshAccessToken {
3456 pub grant_type: PostOAuth2TokenRefreshAccessTokenGrantType,
3457 pub client_id: String,
3458 pub client_secret: String,
3459 pub refresh_token: String,
3460}
3461
3462#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3463pub struct RealtimeServer {
3464 #[serde(default, skip_serializing_if = "Option::is_none")]
3465 pub r#type: Option<String>,
3466 #[serde(default, skip_serializing_if = "Option::is_none")]
3467 pub url: Option<String>,
3468 #[serde(default, skip_serializing_if = "Option::is_none")]
3469 pub ttl: Option<String>,
3470 #[serde(default, skip_serializing_if = "Option::is_none")]
3471 pub max_retries: Option<String>,
3472 #[serde(default, skip_serializing_if = "Option::is_none")]
3473 pub retry_timeout: Option<i64>,
3474}
3475
3476#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3477pub struct RealtimeServers {
3478 #[serde(default, skip_serializing_if = "Option::is_none")]
3479 pub chunk_size: Option<i64>,
3480 #[serde(default, skip_serializing_if = "Option::is_none")]
3481 pub entries: Option<Vec<RealtimeServer>>,
3482}
3483
3484#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3485pub struct RecentItem {
3486 #[serde(default, skip_serializing_if = "Option::is_none")]
3487 pub r#type: Option<String>,
3488 #[serde(default, skip_serializing_if = "Option::is_none")]
3489 pub item: Option<RecentItemResource>,
3490 #[serde(default, skip_serializing_if = "Option::is_none")]
3491 pub interaction_type: Option<RecentItemInteractionType>,
3492 #[serde(default, skip_serializing_if = "Option::is_none")]
3493 pub interacted_at: Option<chrono::DateTime<chrono::Utc>>,
3494 #[serde(default, skip_serializing_if = "Option::is_none")]
3495 pub interaction_shared_link: Option<String>,
3496}
3497
3498#[derive(Clone, Debug, PartialEq)]
3499pub enum RecentItemResource {
3500 File(FileFull),
3501 Folder(FolderFull),
3502 WebLink(WebLink),
3503 Unknown(serde_json::Value),
3505}
3506
3507impl serde::Serialize for RecentItemResource {
3508 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3509 match self {
3510 Self::File(inner) => inner.serialize(serializer),
3511 Self::Folder(inner) => inner.serialize(serializer),
3512 Self::WebLink(inner) => inner.serialize(serializer),
3513 Self::Unknown(inner) => inner.serialize(serializer),
3514 }
3515 }
3516}
3517
3518impl<'de> serde::Deserialize<'de> for RecentItemResource {
3519 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3520 let value = serde_json::Value::deserialize(deserializer)?;
3521 let tag = value
3522 .get("type")
3523 .and_then(serde_json::Value::as_str)
3524 .map(str::to_owned);
3525 match tag.as_deref() {
3526 Some("file") => Ok(Self::File(
3527 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3528 )),
3529 Some("folder") => Ok(Self::Folder(
3530 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3531 )),
3532 Some("web_link") => Ok(Self::WebLink(
3533 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3534 )),
3535 _ => Ok(Self::Unknown(value)),
3536 }
3537 }
3538}
3539
3540#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3541pub struct RecentItems {
3542 #[serde(default, skip_serializing_if = "Option::is_none")]
3543 pub limit: Option<i64>,
3544 #[serde(
3545 default,
3546 skip_serializing_if = "Option::is_none",
3547 deserialize_with = "double_option"
3548 )]
3549 pub next_marker: Option<Option<String>>,
3550 #[serde(
3551 default,
3552 skip_serializing_if = "Option::is_none",
3553 deserialize_with = "double_option"
3554 )]
3555 pub prev_marker: Option<Option<String>>,
3556 #[serde(default, skip_serializing_if = "Option::is_none")]
3557 pub entries: Option<Vec<RecentItem>>,
3558}
3559
3560#[derive(Clone, Debug, PartialEq)]
3561pub enum Resource {
3562 Folder(FolderMini),
3563 File(FileMini),
3564 Unknown(serde_json::Value),
3566}
3567
3568impl serde::Serialize for Resource {
3569 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3570 match self {
3571 Self::Folder(inner) => inner.serialize(serializer),
3572 Self::File(inner) => inner.serialize(serializer),
3573 Self::Unknown(inner) => inner.serialize(serializer),
3574 }
3575 }
3576}
3577
3578impl<'de> serde::Deserialize<'de> for Resource {
3579 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3580 let value = serde_json::Value::deserialize(deserializer)?;
3581 let tag = value
3582 .get("type")
3583 .and_then(serde_json::Value::as_str)
3584 .map(str::to_owned);
3585 match tag.as_deref() {
3586 Some("folder") => Ok(Self::Folder(
3587 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3588 )),
3589 Some("file") => Ok(Self::File(
3590 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3591 )),
3592 _ => Ok(Self::Unknown(value)),
3593 }
3594 }
3595}
3596
3597#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3598pub struct ResourceScope {
3599 #[serde(default, skip_serializing_if = "Option::is_none")]
3600 pub scope: Option<ResourceScopeScope>,
3601 #[serde(default, skip_serializing_if = "Option::is_none")]
3602 pub object: Option<Resource>,
3603}
3604
3605#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3606pub struct RetentionPolicies {
3607 #[serde(default, skip_serializing_if = "Option::is_none")]
3608 pub entries: Option<Vec<RetentionPolicy>>,
3609 #[serde(default, skip_serializing_if = "Option::is_none")]
3610 pub limit: Option<i64>,
3611 #[serde(
3612 default,
3613 skip_serializing_if = "Option::is_none",
3614 deserialize_with = "double_option"
3615 )]
3616 pub next_marker: Option<Option<String>>,
3617}
3618
3619#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3620pub struct RetentionPolicy {
3621 pub id: String,
3622 pub r#type: RetentionPolicyType,
3623 #[serde(default, skip_serializing_if = "Option::is_none")]
3624 pub policy_name: Option<String>,
3625 #[serde(default, skip_serializing_if = "Option::is_none")]
3626 pub retention_length: Option<String>,
3627 #[serde(default, skip_serializing_if = "Option::is_none")]
3628 pub disposition_action: Option<RetentionPolicyDispositionAction>,
3629 #[serde(default, skip_serializing_if = "Option::is_none")]
3630 pub max_extension_length: Option<RetentionPolicyMaxExtensionLengthResponse>,
3631 #[serde(default, skip_serializing_if = "Option::is_none")]
3632 pub description: Option<String>,
3633 #[serde(default, skip_serializing_if = "Option::is_none")]
3634 pub policy_type: Option<RetentionPolicyPolicyType>,
3635 #[serde(default, skip_serializing_if = "Option::is_none")]
3636 pub retention_type: Option<RetentionPolicyRetentionType>,
3637 #[serde(default, skip_serializing_if = "Option::is_none")]
3638 pub status: Option<RetentionPolicyStatus>,
3639 #[serde(default, skip_serializing_if = "Option::is_none")]
3640 pub created_by: Option<UserMini>,
3641 #[serde(default, skip_serializing_if = "Option::is_none")]
3642 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
3643 #[serde(default, skip_serializing_if = "Option::is_none")]
3644 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
3645 #[serde(default, skip_serializing_if = "Option::is_none")]
3646 pub can_owner_extend_retention: Option<bool>,
3647 #[serde(default, skip_serializing_if = "Option::is_none")]
3648 pub are_owners_notified: Option<bool>,
3649 #[serde(default, skip_serializing_if = "Option::is_none")]
3650 pub custom_notification_recipients: Option<Vec<UserMini>>,
3651 #[serde(default, skip_serializing_if = "Option::is_none")]
3652 pub assignment_counts: Option<RetentionPolicyAssignmentCounts>,
3653}
3654
3655#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3656pub struct RetentionPolicyBase {
3657 pub id: String,
3658 pub r#type: RetentionPolicyType,
3659}
3660
3661#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3662pub struct RetentionPolicyMini {
3663 pub id: String,
3664 pub r#type: RetentionPolicyType,
3665 #[serde(default, skip_serializing_if = "Option::is_none")]
3666 pub policy_name: Option<String>,
3667 #[serde(default, skip_serializing_if = "Option::is_none")]
3668 pub retention_length: Option<String>,
3669 #[serde(default, skip_serializing_if = "Option::is_none")]
3670 pub disposition_action: Option<RetentionPolicyDispositionAction>,
3671 #[serde(default, skip_serializing_if = "Option::is_none")]
3672 pub max_extension_length: Option<RetentionPolicyMaxExtensionLengthResponse>,
3673}
3674
3675#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3676pub struct RetentionPolicyAssignment {
3677 pub id: String,
3678 pub r#type: RetentionPolicyAssignmentType,
3679 #[serde(default, skip_serializing_if = "Option::is_none")]
3680 pub retention_policy: Option<RetentionPolicyMini>,
3681 #[serde(default, skip_serializing_if = "Option::is_none")]
3682 pub assigned_to: Option<RetentionPolicyAssignmentAssignedTo>,
3683 #[serde(
3684 default,
3685 skip_serializing_if = "Option::is_none",
3686 deserialize_with = "double_option"
3687 )]
3688 pub filter_fields: Option<Option<Vec<RetentionPolicyAssignmentFilterFields>>>,
3689 #[serde(default, skip_serializing_if = "Option::is_none")]
3690 pub assigned_by: Option<UserMini>,
3691 #[serde(default, skip_serializing_if = "Option::is_none")]
3692 pub assigned_at: Option<chrono::DateTime<chrono::Utc>>,
3693 #[serde(default, skip_serializing_if = "Option::is_none")]
3694 pub start_date_field: Option<String>,
3695}
3696
3697#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3698pub struct RetentionPolicyAssignments {
3699 #[serde(default, skip_serializing_if = "Option::is_none")]
3700 pub entries: Option<Vec<RetentionPolicyAssignment>>,
3701 #[serde(default, skip_serializing_if = "Option::is_none")]
3702 pub limit: Option<i64>,
3703 #[serde(
3704 default,
3705 skip_serializing_if = "Option::is_none",
3706 deserialize_with = "double_option"
3707 )]
3708 pub next_marker: Option<Option<String>>,
3709}
3710
3711#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3712#[serde(transparent)]
3713pub struct RetentionPolicyMaxExtensionLengthRequest(pub serde_json::Value);
3714
3715#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3716#[serde(transparent)]
3717pub struct RetentionPolicyMaxExtensionLengthResponse(pub serde_json::Value);
3718
3719#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3720pub struct RoleVariable {
3721 pub r#type: CollaboratorVariableType,
3722 pub variable_type: RoleVariableVariableType,
3723 pub variable_value: FileFullAllowedInviteeRoles,
3724}
3725
3726#[derive(Clone, Debug, PartialEq)]
3727pub enum SearchResultItem {
3728 File(FileFull),
3729 Folder(FolderFull),
3730 WebLink(WebLink),
3731 Unknown(serde_json::Value),
3733}
3734
3735impl serde::Serialize for SearchResultItem {
3736 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3737 match self {
3738 Self::File(inner) => inner.serialize(serializer),
3739 Self::Folder(inner) => inner.serialize(serializer),
3740 Self::WebLink(inner) => inner.serialize(serializer),
3741 Self::Unknown(inner) => inner.serialize(serializer),
3742 }
3743 }
3744}
3745
3746impl<'de> serde::Deserialize<'de> for SearchResultItem {
3747 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3748 let value = serde_json::Value::deserialize(deserializer)?;
3749 let tag = value
3750 .get("type")
3751 .and_then(serde_json::Value::as_str)
3752 .map(str::to_owned);
3753 match tag.as_deref() {
3754 Some("file") => Ok(Self::File(
3755 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3756 )),
3757 Some("folder") => Ok(Self::Folder(
3758 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3759 )),
3760 Some("web_link") => Ok(Self::WebLink(
3761 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3762 )),
3763 _ => Ok(Self::Unknown(value)),
3764 }
3765 }
3766}
3767
3768#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3769pub struct SearchResults {
3770 #[serde(default, skip_serializing_if = "Option::is_none")]
3771 pub total_count: Option<i64>,
3772 #[serde(default, skip_serializing_if = "Option::is_none")]
3773 pub limit: Option<i64>,
3774 #[serde(default, skip_serializing_if = "Option::is_none")]
3775 pub offset: Option<i64>,
3776 pub r#type: SearchResultsType,
3777 #[serde(default, skip_serializing_if = "Option::is_none")]
3778 pub entries: Option<Vec<SearchResultItem>>,
3779}
3780
3781#[derive(Clone, Debug, PartialEq)]
3782pub enum SearchResultsResponse {
3783 SearchResultsItems(SearchResults),
3784 SearchResultsWithSharedLinks(SearchResultsWithSharedLinks),
3785 Unknown(serde_json::Value),
3787}
3788
3789impl serde::Serialize for SearchResultsResponse {
3790 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3791 match self {
3792 Self::SearchResultsItems(inner) => inner.serialize(serializer),
3793 Self::SearchResultsWithSharedLinks(inner) => inner.serialize(serializer),
3794 Self::Unknown(inner) => inner.serialize(serializer),
3795 }
3796 }
3797}
3798
3799impl<'de> serde::Deserialize<'de> for SearchResultsResponse {
3800 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3801 let value = serde_json::Value::deserialize(deserializer)?;
3802 let tag = value
3803 .get("type")
3804 .and_then(serde_json::Value::as_str)
3805 .map(str::to_owned);
3806 match tag.as_deref() {
3807 Some("search_results_items") => Ok(Self::SearchResultsItems(
3808 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3809 )),
3810 Some("search_results_with_shared_links") => Ok(Self::SearchResultsWithSharedLinks(
3811 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3812 )),
3813 _ => Ok(Self::Unknown(value)),
3814 }
3815 }
3816}
3817
3818#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3819pub struct SearchResultsWithSharedLinks {
3820 #[serde(default, skip_serializing_if = "Option::is_none")]
3821 pub total_count: Option<i64>,
3822 #[serde(default, skip_serializing_if = "Option::is_none")]
3823 pub limit: Option<i64>,
3824 #[serde(default, skip_serializing_if = "Option::is_none")]
3825 pub offset: Option<i64>,
3826 pub r#type: SearchResultsWithSharedLinksType,
3827 #[serde(default, skip_serializing_if = "Option::is_none")]
3828 pub entries: Option<Vec<SearchResultWithSharedLink>>,
3829}
3830
3831#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3832pub struct SearchResultWithSharedLink {
3833 #[serde(default, skip_serializing_if = "Option::is_none")]
3834 pub accessible_via_shared_link: Option<String>,
3835 #[serde(default, skip_serializing_if = "Option::is_none")]
3836 pub item: Option<SearchResultWithSharedLinkItem>,
3837 #[serde(default, skip_serializing_if = "Option::is_none")]
3838 pub r#type: Option<String>,
3839}
3840
3841#[derive(Clone, Debug, PartialEq)]
3842pub enum SearchResultWithSharedLinkItem {
3843 File(FileFull),
3844 Folder(FolderFull),
3845 WebLink(WebLink),
3846 Unknown(serde_json::Value),
3848}
3849
3850impl serde::Serialize for SearchResultWithSharedLinkItem {
3851 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3852 match self {
3853 Self::File(inner) => inner.serialize(serializer),
3854 Self::Folder(inner) => inner.serialize(serializer),
3855 Self::WebLink(inner) => inner.serialize(serializer),
3856 Self::Unknown(inner) => inner.serialize(serializer),
3857 }
3858 }
3859}
3860
3861impl<'de> serde::Deserialize<'de> for SearchResultWithSharedLinkItem {
3862 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3863 let value = serde_json::Value::deserialize(deserializer)?;
3864 let tag = value
3865 .get("type")
3866 .and_then(serde_json::Value::as_str)
3867 .map(str::to_owned);
3868 match tag.as_deref() {
3869 Some("file") => Ok(Self::File(
3870 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3871 )),
3872 Some("folder") => Ok(Self::Folder(
3873 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3874 )),
3875 Some("web_link") => Ok(Self::WebLink(
3876 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3877 )),
3878 _ => Ok(Self::Unknown(value)),
3879 }
3880 }
3881}
3882
3883#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3884pub struct SessionTerminationMessage {
3885 #[serde(default, skip_serializing_if = "Option::is_none")]
3886 pub message: Option<String>,
3887}
3888
3889#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3890pub struct ShieldInformationBarrier {
3891 #[serde(default, skip_serializing_if = "Option::is_none")]
3892 pub id: Option<String>,
3893 #[serde(default, skip_serializing_if = "Option::is_none")]
3894 pub r#type: Option<ShieldInformationBarrierType>,
3895 #[serde(default, skip_serializing_if = "Option::is_none")]
3896 pub enterprise: Option<EnterpriseBase>,
3897 #[serde(default, skip_serializing_if = "Option::is_none")]
3898 pub status: Option<ShieldInformationBarrierStatus>,
3899 #[serde(default, skip_serializing_if = "Option::is_none")]
3900 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
3901 #[serde(default, skip_serializing_if = "Option::is_none")]
3902 pub created_by: Option<UserBase>,
3903 #[serde(default, skip_serializing_if = "Option::is_none")]
3904 pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
3905 #[serde(default, skip_serializing_if = "Option::is_none")]
3906 pub updated_by: Option<UserBase>,
3907 #[serde(default, skip_serializing_if = "Option::is_none")]
3908 pub enabled_at: Option<chrono::DateTime<chrono::Utc>>,
3909 #[serde(default, skip_serializing_if = "Option::is_none")]
3910 pub enabled_by: Option<UserBase>,
3911}
3912
3913#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3914pub struct ShieldInformationBarrierBase {
3915 #[serde(default, skip_serializing_if = "Option::is_none")]
3916 pub id: Option<String>,
3917 #[serde(default, skip_serializing_if = "Option::is_none")]
3918 pub r#type: Option<ShieldInformationBarrierType>,
3919}
3920
3921#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3922pub struct ShieldInformationBarrierReference {
3923 #[serde(default, skip_serializing_if = "Option::is_none")]
3924 pub shield_information_barrier: Option<ShieldInformationBarrierBase>,
3925}
3926
3927#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3928pub struct ShieldInformationBarrierReport {
3929 #[serde(default, skip_serializing_if = "Option::is_none")]
3930 pub id: Option<String>,
3931 #[serde(default, skip_serializing_if = "Option::is_none")]
3932 pub r#type: Option<ShieldInformationBarrierReportType>,
3933 #[serde(default, skip_serializing_if = "Option::is_none")]
3934 pub shield_information_barrier: Option<ShieldInformationBarrierReference>,
3935 #[serde(default, skip_serializing_if = "Option::is_none")]
3936 pub status: Option<ShieldInformationBarrierReportStatus>,
3937 #[serde(default, skip_serializing_if = "Option::is_none")]
3938 pub details: Option<ShieldInformationBarrierReportDetails>,
3939 #[serde(default, skip_serializing_if = "Option::is_none")]
3940 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
3941 #[serde(default, skip_serializing_if = "Option::is_none")]
3942 pub created_by: Option<UserBase>,
3943 #[serde(default, skip_serializing_if = "Option::is_none")]
3944 pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
3945}
3946
3947#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3948pub struct ShieldInformationBarrierReportBase {
3949 #[serde(default, skip_serializing_if = "Option::is_none")]
3950 pub id: Option<String>,
3951 #[serde(default, skip_serializing_if = "Option::is_none")]
3952 pub r#type: Option<ShieldInformationBarrierReportType>,
3953}
3954
3955#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3956pub struct ShieldInformationBarrierReportDetails {
3957 #[serde(default, skip_serializing_if = "Option::is_none")]
3958 pub details: Option<ShieldInformationBarrierReportDetailsDetails>,
3959}
3960
3961#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3962pub struct ShieldInformationBarrierReports {
3963 #[serde(default, skip_serializing_if = "Option::is_none")]
3964 pub limit: Option<i64>,
3965 #[serde(
3966 default,
3967 skip_serializing_if = "Option::is_none",
3968 deserialize_with = "double_option"
3969 )]
3970 pub next_marker: Option<Option<String>>,
3971 #[serde(default, skip_serializing_if = "Option::is_none")]
3972 pub entries: Option<Vec<ShieldInformationBarrierReport>>,
3973}
3974
3975#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3976pub struct ShieldInformationBarriers {
3977 #[serde(default, skip_serializing_if = "Option::is_none")]
3978 pub limit: Option<i64>,
3979 #[serde(
3980 default,
3981 skip_serializing_if = "Option::is_none",
3982 deserialize_with = "double_option"
3983 )]
3984 pub next_marker: Option<Option<String>>,
3985 #[serde(default, skip_serializing_if = "Option::is_none")]
3986 pub entries: Option<Vec<ShieldInformationBarrier>>,
3987}
3988
3989#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
3990pub struct ShieldInformationBarrierSegment {
3991 #[serde(default, skip_serializing_if = "Option::is_none")]
3992 pub id: Option<String>,
3993 #[serde(default, skip_serializing_if = "Option::is_none")]
3994 pub r#type: Option<ShieldInformationBarrierSegmentType>,
3995 #[serde(default, skip_serializing_if = "Option::is_none")]
3996 pub shield_information_barrier: Option<ShieldInformationBarrierBase>,
3997 #[serde(default, skip_serializing_if = "Option::is_none")]
3998 pub name: Option<String>,
3999 #[serde(default, skip_serializing_if = "Option::is_none")]
4000 pub description: Option<String>,
4001 #[serde(default, skip_serializing_if = "Option::is_none")]
4002 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
4003 #[serde(default, skip_serializing_if = "Option::is_none")]
4004 pub created_by: Option<UserBase>,
4005 #[serde(default, skip_serializing_if = "Option::is_none")]
4006 pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
4007 #[serde(default, skip_serializing_if = "Option::is_none")]
4008 pub updated_by: Option<UserBase>,
4009}
4010
4011#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4012pub struct ShieldInformationBarrierSegmentMember {
4013 #[serde(default, skip_serializing_if = "Option::is_none")]
4014 pub id: Option<String>,
4015 #[serde(default, skip_serializing_if = "Option::is_none")]
4016 pub r#type: Option<ShieldInformationBarrierSegmentMemberType>,
4017 #[serde(default, skip_serializing_if = "Option::is_none")]
4018 pub user: Option<UserBase>,
4019 #[serde(default, skip_serializing_if = "Option::is_none")]
4020 pub shield_information_barrier: Option<ShieldInformationBarrierBase>,
4021 #[serde(default, skip_serializing_if = "Option::is_none")]
4022 pub shield_information_barrier_segment:
4023 Option<ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment>,
4024 #[serde(default, skip_serializing_if = "Option::is_none")]
4025 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
4026 #[serde(default, skip_serializing_if = "Option::is_none")]
4027 pub created_by: Option<UserBase>,
4028 #[serde(default, skip_serializing_if = "Option::is_none")]
4029 pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
4030 #[serde(default, skip_serializing_if = "Option::is_none")]
4031 pub updated_by: Option<UserBase>,
4032}
4033
4034#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4035pub struct ShieldInformationBarrierSegmentMemberBase {
4036 #[serde(default, skip_serializing_if = "Option::is_none")]
4037 pub id: Option<String>,
4038 #[serde(default, skip_serializing_if = "Option::is_none")]
4039 pub r#type: Option<ShieldInformationBarrierSegmentMemberType>,
4040}
4041
4042#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4043pub struct ShieldInformationBarrierSegmentMemberMini {
4044 #[serde(default, skip_serializing_if = "Option::is_none")]
4045 pub id: Option<String>,
4046 #[serde(default, skip_serializing_if = "Option::is_none")]
4047 pub r#type: Option<ShieldInformationBarrierSegmentMemberType>,
4048 #[serde(default, skip_serializing_if = "Option::is_none")]
4049 pub user: Option<UserBase>,
4050}
4051
4052#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4053pub struct ShieldInformationBarrierSegmentMembers {
4054 #[serde(default, skip_serializing_if = "Option::is_none")]
4055 pub limit: Option<i64>,
4056 #[serde(
4057 default,
4058 skip_serializing_if = "Option::is_none",
4059 deserialize_with = "double_option"
4060 )]
4061 pub next_marker: Option<Option<String>>,
4062 #[serde(default, skip_serializing_if = "Option::is_none")]
4063 pub entries: Option<Vec<ShieldInformationBarrierSegmentMember>>,
4064}
4065
4066#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4067pub struct ShieldInformationBarrierSegmentRestriction {
4068 #[serde(default, skip_serializing_if = "Option::is_none")]
4069 pub r#type: Option<ShieldInformationBarrierSegmentRestrictionType>,
4070 #[serde(default, skip_serializing_if = "Option::is_none")]
4071 pub id: Option<String>,
4072 pub shield_information_barrier_segment:
4073 ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment,
4074 pub restricted_segment: ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment,
4075 #[serde(default, skip_serializing_if = "Option::is_none")]
4076 pub shield_information_barrier: Option<ShieldInformationBarrierBase>,
4077 #[serde(default, skip_serializing_if = "Option::is_none")]
4078 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
4079 #[serde(default, skip_serializing_if = "Option::is_none")]
4080 pub created_by: Option<UserBase>,
4081 #[serde(default, skip_serializing_if = "Option::is_none")]
4082 pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
4083 #[serde(default, skip_serializing_if = "Option::is_none")]
4084 pub updated_by: Option<UserBase>,
4085}
4086
4087#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4088pub struct ShieldInformationBarrierSegmentRestrictionBase {
4089 #[serde(default, skip_serializing_if = "Option::is_none")]
4090 pub r#type: Option<ShieldInformationBarrierSegmentRestrictionType>,
4091 #[serde(default, skip_serializing_if = "Option::is_none")]
4092 pub id: Option<String>,
4093}
4094
4095#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4096pub struct ShieldInformationBarrierSegmentRestrictionMini {
4097 #[serde(default, skip_serializing_if = "Option::is_none")]
4098 pub r#type: Option<ShieldInformationBarrierSegmentRestrictionType>,
4099 #[serde(default, skip_serializing_if = "Option::is_none")]
4100 pub id: Option<String>,
4101 pub shield_information_barrier_segment:
4102 ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment,
4103 pub restricted_segment: ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment,
4104}
4105
4106#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4107pub struct ShieldInformationBarrierSegmentRestrictions {
4108 #[serde(default, skip_serializing_if = "Option::is_none")]
4109 pub limit: Option<i64>,
4110 #[serde(
4111 default,
4112 skip_serializing_if = "Option::is_none",
4113 deserialize_with = "double_option"
4114 )]
4115 pub next_marker: Option<Option<String>>,
4116 #[serde(default, skip_serializing_if = "Option::is_none")]
4117 pub entries: Option<Vec<ShieldInformationBarrierSegmentRestriction>>,
4118}
4119
4120#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4121pub struct ShieldInformationBarrierSegments {
4122 #[serde(default, skip_serializing_if = "Option::is_none")]
4123 pub limit: Option<i64>,
4124 #[serde(
4125 default,
4126 skip_serializing_if = "Option::is_none",
4127 deserialize_with = "double_option"
4128 )]
4129 pub next_marker: Option<Option<String>>,
4130 #[serde(default, skip_serializing_if = "Option::is_none")]
4131 pub entries: Option<Vec<ShieldInformationBarrierSegment>>,
4132}
4133
4134#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4135pub struct SignRequest {
4136 #[serde(default, skip_serializing_if = "Option::is_none")]
4137 pub is_document_preparation_needed: Option<bool>,
4138 #[serde(
4139 default,
4140 skip_serializing_if = "Option::is_none",
4141 deserialize_with = "double_option"
4142 )]
4143 pub redirect_url: Option<Option<String>>,
4144 #[serde(
4145 default,
4146 skip_serializing_if = "Option::is_none",
4147 deserialize_with = "double_option"
4148 )]
4149 pub declined_redirect_url: Option<Option<String>>,
4150 #[serde(default, skip_serializing_if = "Option::is_none")]
4151 pub are_text_signatures_enabled: Option<bool>,
4152 #[serde(
4153 default,
4154 skip_serializing_if = "Option::is_none",
4155 deserialize_with = "double_option"
4156 )]
4157 pub email_subject: Option<Option<String>>,
4158 #[serde(
4159 default,
4160 skip_serializing_if = "Option::is_none",
4161 deserialize_with = "double_option"
4162 )]
4163 pub email_message: Option<Option<String>>,
4164 #[serde(default, skip_serializing_if = "Option::is_none")]
4165 pub are_reminders_enabled: Option<bool>,
4166 #[serde(default, skip_serializing_if = "Option::is_none")]
4167 pub name: Option<String>,
4168 #[serde(default, skip_serializing_if = "Option::is_none")]
4169 pub prefill_tags: Option<Vec<SignRequestPrefillTag>>,
4170 #[serde(
4171 default,
4172 skip_serializing_if = "Option::is_none",
4173 deserialize_with = "double_option"
4174 )]
4175 pub days_valid: Option<Option<i64>>,
4176 #[serde(
4177 default,
4178 skip_serializing_if = "Option::is_none",
4179 deserialize_with = "double_option"
4180 )]
4181 pub external_id: Option<Option<String>>,
4182 #[serde(
4183 default,
4184 skip_serializing_if = "Option::is_none",
4185 deserialize_with = "double_option"
4186 )]
4187 pub template_id: Option<Option<String>>,
4188 #[serde(
4189 default,
4190 skip_serializing_if = "Option::is_none",
4191 deserialize_with = "double_option"
4192 )]
4193 pub external_system_name: Option<Option<String>>,
4194 #[serde(
4195 default,
4196 skip_serializing_if = "Option::is_none",
4197 deserialize_with = "double_option"
4198 )]
4199 pub request_flow: Option<Option<String>>,
4200 #[serde(default, skip_serializing_if = "Option::is_none")]
4201 pub r#type: Option<SignRequestType>,
4202 #[serde(default, skip_serializing_if = "Option::is_none")]
4203 pub source_files: Option<Vec<FileBase>>,
4204 #[serde(default, skip_serializing_if = "Option::is_none")]
4205 pub signers: Option<Vec<SignRequestSigner>>,
4206 #[serde(
4207 default,
4208 skip_serializing_if = "Option::is_none",
4209 deserialize_with = "double_option"
4210 )]
4211 pub signature_color: Option<Option<String>>,
4212 #[serde(default, skip_serializing_if = "Option::is_none")]
4213 pub id: Option<String>,
4214 #[serde(
4215 default,
4216 skip_serializing_if = "Option::is_none",
4217 deserialize_with = "double_option"
4218 )]
4219 pub prepare_url: Option<Option<String>>,
4220 #[serde(default, skip_serializing_if = "Option::is_none")]
4221 pub signing_log: Option<FileMini>,
4222 #[serde(default, skip_serializing_if = "Option::is_none")]
4223 pub status: Option<SignRequestStatus>,
4224 #[serde(default, skip_serializing_if = "Option::is_none")]
4225 pub sign_files: Option<SignRequestSignFiles>,
4226 #[serde(
4227 default,
4228 skip_serializing_if = "Option::is_none",
4229 deserialize_with = "double_option"
4230 )]
4231 pub auto_expire_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
4232 #[serde(default, skip_serializing_if = "Option::is_none")]
4233 pub parent_folder: Option<FolderMini>,
4234 #[serde(
4235 default,
4236 skip_serializing_if = "Option::is_none",
4237 deserialize_with = "double_option"
4238 )]
4239 pub collaborator_level: Option<Option<String>>,
4240 #[serde(default, skip_serializing_if = "Option::is_none")]
4241 pub short_id: Option<String>,
4242 #[serde(default, skip_serializing_if = "Option::is_none")]
4243 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
4244 #[serde(
4245 default,
4246 skip_serializing_if = "Option::is_none",
4247 deserialize_with = "double_option"
4248 )]
4249 pub finished_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
4250 #[serde(
4251 default,
4252 skip_serializing_if = "Option::is_none",
4253 deserialize_with = "double_option"
4254 )]
4255 pub error_code: Option<Option<String>>,
4256 #[serde(
4257 default,
4258 skip_serializing_if = "Option::is_none",
4259 deserialize_with = "double_option"
4260 )]
4261 pub sender_email: Option<Option<String>>,
4262 #[serde(
4263 default,
4264 skip_serializing_if = "Option::is_none",
4265 deserialize_with = "double_option"
4266 )]
4267 pub sender_id: Option<Option<i64>>,
4268}
4269
4270#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4271pub struct SignRequestBase {
4272 #[serde(default, skip_serializing_if = "Option::is_none")]
4273 pub is_document_preparation_needed: Option<bool>,
4274 #[serde(
4275 default,
4276 skip_serializing_if = "Option::is_none",
4277 deserialize_with = "double_option"
4278 )]
4279 pub redirect_url: Option<Option<String>>,
4280 #[serde(
4281 default,
4282 skip_serializing_if = "Option::is_none",
4283 deserialize_with = "double_option"
4284 )]
4285 pub declined_redirect_url: Option<Option<String>>,
4286 #[serde(default, skip_serializing_if = "Option::is_none")]
4287 pub are_text_signatures_enabled: Option<bool>,
4288 #[serde(
4289 default,
4290 skip_serializing_if = "Option::is_none",
4291 deserialize_with = "double_option"
4292 )]
4293 pub email_subject: Option<Option<String>>,
4294 #[serde(
4295 default,
4296 skip_serializing_if = "Option::is_none",
4297 deserialize_with = "double_option"
4298 )]
4299 pub email_message: Option<Option<String>>,
4300 #[serde(default, skip_serializing_if = "Option::is_none")]
4301 pub are_reminders_enabled: Option<bool>,
4302 #[serde(default, skip_serializing_if = "Option::is_none")]
4303 pub name: Option<String>,
4304 #[serde(default, skip_serializing_if = "Option::is_none")]
4305 pub prefill_tags: Option<Vec<SignRequestPrefillTag>>,
4306 #[serde(
4307 default,
4308 skip_serializing_if = "Option::is_none",
4309 deserialize_with = "double_option"
4310 )]
4311 pub days_valid: Option<Option<i64>>,
4312 #[serde(
4313 default,
4314 skip_serializing_if = "Option::is_none",
4315 deserialize_with = "double_option"
4316 )]
4317 pub external_id: Option<Option<String>>,
4318 #[serde(
4319 default,
4320 skip_serializing_if = "Option::is_none",
4321 deserialize_with = "double_option"
4322 )]
4323 pub template_id: Option<Option<String>>,
4324 #[serde(
4325 default,
4326 skip_serializing_if = "Option::is_none",
4327 deserialize_with = "double_option"
4328 )]
4329 pub external_system_name: Option<Option<String>>,
4330 #[serde(
4331 default,
4332 skip_serializing_if = "Option::is_none",
4333 deserialize_with = "double_option"
4334 )]
4335 pub request_flow: Option<Option<String>>,
4336}
4337
4338#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4339pub struct SignRequestCancelRequest {
4340 #[serde(default, skip_serializing_if = "Option::is_none")]
4341 pub reason: Option<String>,
4342}
4343
4344#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4345pub struct SignRequestCreateRequest {
4346 #[serde(default, skip_serializing_if = "Option::is_none")]
4347 pub is_document_preparation_needed: Option<bool>,
4348 #[serde(
4349 default,
4350 skip_serializing_if = "Option::is_none",
4351 deserialize_with = "double_option"
4352 )]
4353 pub redirect_url: Option<Option<String>>,
4354 #[serde(
4355 default,
4356 skip_serializing_if = "Option::is_none",
4357 deserialize_with = "double_option"
4358 )]
4359 pub declined_redirect_url: Option<Option<String>>,
4360 #[serde(default, skip_serializing_if = "Option::is_none")]
4361 pub are_text_signatures_enabled: Option<bool>,
4362 #[serde(
4363 default,
4364 skip_serializing_if = "Option::is_none",
4365 deserialize_with = "double_option"
4366 )]
4367 pub email_subject: Option<Option<String>>,
4368 #[serde(
4369 default,
4370 skip_serializing_if = "Option::is_none",
4371 deserialize_with = "double_option"
4372 )]
4373 pub email_message: Option<Option<String>>,
4374 #[serde(default, skip_serializing_if = "Option::is_none")]
4375 pub are_reminders_enabled: Option<bool>,
4376 #[serde(default, skip_serializing_if = "Option::is_none")]
4377 pub name: Option<String>,
4378 #[serde(default, skip_serializing_if = "Option::is_none")]
4379 pub prefill_tags: Option<Vec<SignRequestPrefillTag>>,
4380 #[serde(
4381 default,
4382 skip_serializing_if = "Option::is_none",
4383 deserialize_with = "double_option"
4384 )]
4385 pub days_valid: Option<Option<i64>>,
4386 #[serde(
4387 default,
4388 skip_serializing_if = "Option::is_none",
4389 deserialize_with = "double_option"
4390 )]
4391 pub external_id: Option<Option<String>>,
4392 #[serde(
4393 default,
4394 skip_serializing_if = "Option::is_none",
4395 deserialize_with = "double_option"
4396 )]
4397 pub template_id: Option<Option<String>>,
4398 #[serde(
4399 default,
4400 skip_serializing_if = "Option::is_none",
4401 deserialize_with = "double_option"
4402 )]
4403 pub external_system_name: Option<Option<String>>,
4404 #[serde(
4405 default,
4406 skip_serializing_if = "Option::is_none",
4407 deserialize_with = "double_option"
4408 )]
4409 pub request_flow: Option<Option<String>>,
4410 #[serde(
4411 default,
4412 skip_serializing_if = "Option::is_none",
4413 deserialize_with = "double_option"
4414 )]
4415 pub source_files: Option<Option<Vec<FileBase>>>,
4416 #[serde(
4417 default,
4418 skip_serializing_if = "Option::is_none",
4419 deserialize_with = "double_option"
4420 )]
4421 pub signature_color: Option<Option<SignRequestCreateRequestSignatureColor>>,
4422 pub signers: Vec<SignRequestCreateSigner>,
4423 #[serde(default, skip_serializing_if = "Option::is_none")]
4424 pub parent_folder: Option<FolderMini>,
4425}
4426
4427#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4428pub struct SignRequestCreateSigner {
4429 #[serde(
4430 default,
4431 skip_serializing_if = "Option::is_none",
4432 deserialize_with = "double_option"
4433 )]
4434 pub email: Option<Option<String>>,
4435 #[serde(default, skip_serializing_if = "Option::is_none")]
4436 pub role: Option<SignRequestCreateSignerRole>,
4437 #[serde(default, skip_serializing_if = "Option::is_none")]
4438 pub is_in_person: Option<bool>,
4439 #[serde(default, skip_serializing_if = "Option::is_none")]
4440 pub order: Option<i64>,
4441 #[serde(
4442 default,
4443 skip_serializing_if = "Option::is_none",
4444 deserialize_with = "double_option"
4445 )]
4446 pub embed_url_external_user_id: Option<Option<String>>,
4447 #[serde(
4448 default,
4449 skip_serializing_if = "Option::is_none",
4450 deserialize_with = "double_option"
4451 )]
4452 pub redirect_url: Option<Option<String>>,
4453 #[serde(
4454 default,
4455 skip_serializing_if = "Option::is_none",
4456 deserialize_with = "double_option"
4457 )]
4458 pub declined_redirect_url: Option<Option<String>>,
4459 #[serde(
4460 default,
4461 skip_serializing_if = "Option::is_none",
4462 deserialize_with = "double_option"
4463 )]
4464 pub login_required: Option<Option<bool>>,
4465 #[serde(
4466 default,
4467 skip_serializing_if = "Option::is_none",
4468 deserialize_with = "double_option"
4469 )]
4470 pub verification_phone_number: Option<Option<String>>,
4471 #[serde(
4472 default,
4473 skip_serializing_if = "Option::is_none",
4474 deserialize_with = "double_option"
4475 )]
4476 pub password: Option<Option<String>>,
4477 #[serde(
4478 default,
4479 skip_serializing_if = "Option::is_none",
4480 deserialize_with = "double_option"
4481 )]
4482 pub signer_group_id: Option<Option<String>>,
4483 #[serde(
4484 default,
4485 skip_serializing_if = "Option::is_none",
4486 deserialize_with = "double_option"
4487 )]
4488 pub suppress_notifications: Option<Option<bool>>,
4489 #[serde(
4490 default,
4491 skip_serializing_if = "Option::is_none",
4492 deserialize_with = "double_option"
4493 )]
4494 pub language: Option<Option<String>>,
4495}
4496
4497#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4498pub struct SignRequestPrefillTag {
4499 #[serde(
4500 default,
4501 skip_serializing_if = "Option::is_none",
4502 deserialize_with = "double_option"
4503 )]
4504 pub document_tag_id: Option<Option<String>>,
4505 #[serde(
4506 default,
4507 skip_serializing_if = "Option::is_none",
4508 deserialize_with = "double_option"
4509 )]
4510 pub text_value: Option<Option<String>>,
4511 #[serde(
4512 default,
4513 skip_serializing_if = "Option::is_none",
4514 deserialize_with = "double_option"
4515 )]
4516 pub checkbox_value: Option<Option<bool>>,
4517 #[serde(
4518 default,
4519 skip_serializing_if = "Option::is_none",
4520 deserialize_with = "double_option"
4521 )]
4522 pub date_value: Option<Option<chrono::NaiveDate>>,
4523}
4524
4525#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4526pub struct SignRequests {
4527 #[serde(default, skip_serializing_if = "Option::is_none")]
4528 pub limit: Option<i64>,
4529 #[serde(
4530 default,
4531 skip_serializing_if = "Option::is_none",
4532 deserialize_with = "double_option"
4533 )]
4534 pub next_marker: Option<Option<String>>,
4535 #[serde(default, skip_serializing_if = "Option::is_none")]
4536 pub entries: Option<Vec<SignRequest>>,
4537}
4538
4539#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4540pub struct SignRequestSigner {
4541 pub email: Option<String>,
4542 #[serde(default, skip_serializing_if = "Option::is_none")]
4543 pub role: Option<SignRequestCreateSignerRole>,
4544 #[serde(default, skip_serializing_if = "Option::is_none")]
4545 pub is_in_person: Option<bool>,
4546 #[serde(default, skip_serializing_if = "Option::is_none")]
4547 pub order: Option<i64>,
4548 #[serde(
4549 default,
4550 skip_serializing_if = "Option::is_none",
4551 deserialize_with = "double_option"
4552 )]
4553 pub embed_url_external_user_id: Option<Option<String>>,
4554 #[serde(
4555 default,
4556 skip_serializing_if = "Option::is_none",
4557 deserialize_with = "double_option"
4558 )]
4559 pub redirect_url: Option<Option<String>>,
4560 #[serde(
4561 default,
4562 skip_serializing_if = "Option::is_none",
4563 deserialize_with = "double_option"
4564 )]
4565 pub declined_redirect_url: Option<Option<String>>,
4566 #[serde(
4567 default,
4568 skip_serializing_if = "Option::is_none",
4569 deserialize_with = "double_option"
4570 )]
4571 pub login_required: Option<Option<bool>>,
4572 #[serde(
4573 default,
4574 skip_serializing_if = "Option::is_none",
4575 deserialize_with = "double_option"
4576 )]
4577 pub verification_phone_number: Option<Option<String>>,
4578 #[serde(
4579 default,
4580 skip_serializing_if = "Option::is_none",
4581 deserialize_with = "double_option"
4582 )]
4583 pub password: Option<Option<String>>,
4584 #[serde(
4585 default,
4586 skip_serializing_if = "Option::is_none",
4587 deserialize_with = "double_option"
4588 )]
4589 pub signer_group_id: Option<Option<String>>,
4590 #[serde(
4591 default,
4592 skip_serializing_if = "Option::is_none",
4593 deserialize_with = "double_option"
4594 )]
4595 pub suppress_notifications: Option<Option<bool>>,
4596 #[serde(
4597 default,
4598 skip_serializing_if = "Option::is_none",
4599 deserialize_with = "double_option"
4600 )]
4601 pub language: Option<Option<String>>,
4602 #[serde(default, skip_serializing_if = "Option::is_none")]
4603 pub has_viewed_document: Option<bool>,
4604 #[serde(
4605 default,
4606 skip_serializing_if = "Option::is_none",
4607 deserialize_with = "double_option"
4608 )]
4609 pub signer_decision: Option<Option<SignRequestSignerSignerDecision>>,
4610 #[serde(default, skip_serializing_if = "Option::is_none")]
4611 pub inputs: Option<Vec<SignRequestSignerInput>>,
4612 #[serde(
4613 default,
4614 skip_serializing_if = "Option::is_none",
4615 deserialize_with = "double_option"
4616 )]
4617 pub embed_url: Option<Option<String>>,
4618 #[serde(
4619 default,
4620 skip_serializing_if = "Option::is_none",
4621 deserialize_with = "double_option"
4622 )]
4623 pub iframeable_embed_url: Option<Option<String>>,
4624 #[serde(
4625 default,
4626 skip_serializing_if = "Option::is_none",
4627 deserialize_with = "double_option"
4628 )]
4629 pub attachments: Option<Option<Vec<SignRequestSignerAttachment>>>,
4630}
4631
4632#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4633pub struct SignRequestSignerAttachment {
4634 #[serde(
4635 default,
4636 skip_serializing_if = "Option::is_none",
4637 deserialize_with = "double_option"
4638 )]
4639 pub id: Option<Option<String>>,
4640 #[serde(
4641 default,
4642 skip_serializing_if = "Option::is_none",
4643 deserialize_with = "double_option"
4644 )]
4645 pub name: Option<Option<String>>,
4646}
4647
4648#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4649pub struct SignRequestSignerInput {
4650 #[serde(
4651 default,
4652 skip_serializing_if = "Option::is_none",
4653 deserialize_with = "double_option"
4654 )]
4655 pub document_tag_id: Option<Option<String>>,
4656 #[serde(
4657 default,
4658 skip_serializing_if = "Option::is_none",
4659 deserialize_with = "double_option"
4660 )]
4661 pub text_value: Option<Option<String>>,
4662 #[serde(
4663 default,
4664 skip_serializing_if = "Option::is_none",
4665 deserialize_with = "double_option"
4666 )]
4667 pub checkbox_value: Option<Option<bool>>,
4668 #[serde(
4669 default,
4670 skip_serializing_if = "Option::is_none",
4671 deserialize_with = "double_option"
4672 )]
4673 pub date_value: Option<Option<chrono::NaiveDate>>,
4674 #[serde(default, skip_serializing_if = "Option::is_none")]
4675 pub r#type: Option<SignRequestSignerInputType>,
4676 #[serde(default, skip_serializing_if = "Option::is_none")]
4677 pub content_type: Option<SignRequestSignerInputContentType>,
4678 pub page_index: i64,
4679 #[serde(default, skip_serializing_if = "Option::is_none")]
4680 pub read_only: Option<bool>,
4681 #[serde(default, skip_serializing_if = "Option::is_none")]
4682 pub validation: Option<SignRequestSignerInputValidation2>,
4683 #[serde(
4684 default,
4685 skip_serializing_if = "Option::is_none",
4686 deserialize_with = "double_option"
4687 )]
4688 pub reason: Option<Option<String>>,
4689 #[serde(
4690 default,
4691 skip_serializing_if = "Option::is_none",
4692 deserialize_with = "double_option"
4693 )]
4694 pub is_validated: Option<Option<bool>>,
4695}
4696
4697#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4698pub struct SignRequestSignerInputCustomValidation {
4699 pub validation_type: SignRequestSignerInputCustomValidationValidationType,
4700 pub custom_regex: Option<String>,
4701 pub custom_error_message: Option<String>,
4702}
4703
4704#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4705pub struct SignRequestSignerInputDateAsiaValidation {
4706 #[serde(default, skip_serializing_if = "Option::is_none")]
4707 pub validation_type: Option<SignRequestSignerInputDateAsiaValidationValidationType>,
4708}
4709
4710#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4711pub struct SignRequestSignerInputDateEUValidation {
4712 #[serde(default, skip_serializing_if = "Option::is_none")]
4713 pub validation_type: Option<SignRequestSignerInputDateEUValidationValidationType>,
4714}
4715
4716#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4717pub struct SignRequestSignerInputDateISOValidation {
4718 #[serde(default, skip_serializing_if = "Option::is_none")]
4719 pub validation_type: Option<SignRequestSignerInputDateISOValidationValidationType>,
4720}
4721
4722#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4723pub struct SignRequestSignerInputDateUSValidation {
4724 #[serde(default, skip_serializing_if = "Option::is_none")]
4725 pub validation_type: Option<SignRequestSignerInputDateUSValidationValidationType>,
4726}
4727
4728#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4729pub struct SignRequestSignerInputEmailValidation {
4730 pub validation_type: SignRequestSignerInputEmailValidationValidationType,
4731}
4732
4733#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4734pub struct SignRequestSignerInputNumberWithCommaValidation {
4735 #[serde(default, skip_serializing_if = "Option::is_none")]
4736 pub validation_type: Option<SignRequestSignerInputNumberWithCommaValidationValidationType>,
4737}
4738
4739#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4740pub struct SignRequestSignerInputNumberWithPeriodValidation {
4741 #[serde(default, skip_serializing_if = "Option::is_none")]
4742 pub validation_type: Option<SignRequestSignerInputNumberWithPeriodValidationValidationType>,
4743}
4744
4745#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4746pub struct SignRequestSignerInputSSNValidation {
4747 pub validation_type: SignRequestSignerInputSSNValidationValidationType,
4748}
4749
4750#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4751#[serde(transparent)]
4752pub struct SignRequestSignerInputValidation(pub serde_json::Value);
4753
4754#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4755pub struct SignRequestSignerInputZIP4Validation {
4756 pub validation_type: SignRequestSignerInputZIP4ValidationValidationType,
4757}
4758
4759#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4760pub struct SignRequestSignerInputZIPValidation {
4761 pub validation_type: SignRequestSignerInputZIPValidationValidationType,
4762}
4763
4764#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4765pub struct SignTemplate {
4766 #[serde(default, skip_serializing_if = "Option::is_none")]
4767 pub r#type: Option<SignTemplateType>,
4768 #[serde(default, skip_serializing_if = "Option::is_none")]
4769 pub id: Option<String>,
4770 #[serde(
4771 default,
4772 skip_serializing_if = "Option::is_none",
4773 deserialize_with = "double_option"
4774 )]
4775 pub name: Option<Option<String>>,
4776 #[serde(
4777 default,
4778 skip_serializing_if = "Option::is_none",
4779 deserialize_with = "double_option"
4780 )]
4781 pub email_subject: Option<Option<String>>,
4782 #[serde(
4783 default,
4784 skip_serializing_if = "Option::is_none",
4785 deserialize_with = "double_option"
4786 )]
4787 pub email_message: Option<Option<String>>,
4788 #[serde(
4789 default,
4790 skip_serializing_if = "Option::is_none",
4791 deserialize_with = "double_option"
4792 )]
4793 pub days_valid: Option<Option<i64>>,
4794 #[serde(default, skip_serializing_if = "Option::is_none")]
4795 pub parent_folder: Option<FolderMini>,
4796 #[serde(default, skip_serializing_if = "Option::is_none")]
4797 pub source_files: Option<Vec<FileMini>>,
4798 #[serde(default, skip_serializing_if = "Option::is_none")]
4799 pub are_fields_locked: Option<bool>,
4800 #[serde(default, skip_serializing_if = "Option::is_none")]
4801 pub are_options_locked: Option<bool>,
4802 #[serde(default, skip_serializing_if = "Option::is_none")]
4803 pub are_recipients_locked: Option<bool>,
4804 #[serde(default, skip_serializing_if = "Option::is_none")]
4805 pub are_email_settings_locked: Option<bool>,
4806 #[serde(default, skip_serializing_if = "Option::is_none")]
4807 pub are_files_locked: Option<bool>,
4808 #[serde(default, skip_serializing_if = "Option::is_none")]
4809 pub signers: Option<Vec<TemplateSigner>>,
4810 #[serde(default, skip_serializing_if = "Option::is_none")]
4811 pub additional_info: Option<SignTemplateAdditionalInfo>,
4812 #[serde(
4813 default,
4814 skip_serializing_if = "Option::is_none",
4815 deserialize_with = "double_option"
4816 )]
4817 pub ready_sign_link: Option<Option<SignTemplateReadySignLink>>,
4818 #[serde(
4819 default,
4820 skip_serializing_if = "Option::is_none",
4821 deserialize_with = "double_option"
4822 )]
4823 pub custom_branding: Option<Option<SignTemplateCustomBranding>>,
4824 #[serde(
4825 default,
4826 skip_serializing_if = "Option::is_none",
4827 deserialize_with = "double_option"
4828 )]
4829 pub request_flow: Option<Option<String>>,
4830}
4831
4832#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4833pub struct SignTemplates {
4834 #[serde(default, skip_serializing_if = "Option::is_none")]
4835 pub limit: Option<i64>,
4836 #[serde(
4837 default,
4838 skip_serializing_if = "Option::is_none",
4839 deserialize_with = "double_option"
4840 )]
4841 pub next_marker: Option<Option<String>>,
4842 #[serde(
4843 default,
4844 skip_serializing_if = "Option::is_none",
4845 deserialize_with = "double_option"
4846 )]
4847 pub prev_marker: Option<Option<String>>,
4848 #[serde(default, skip_serializing_if = "Option::is_none")]
4849 pub entries: Option<Vec<SignTemplate>>,
4850}
4851
4852#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4853#[serde(transparent)]
4854pub struct SkillCard(pub serde_json::Value);
4855
4856#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4857pub struct SkillCardsMetadata {
4858 #[serde(rename = "$canEdit", default, skip_serializing_if = "Option::is_none")]
4859 pub can_edit: Option<bool>,
4860 #[serde(rename = "$id", default, skip_serializing_if = "Option::is_none")]
4861 pub id: Option<String>,
4862 #[serde(rename = "$parent", default, skip_serializing_if = "Option::is_none")]
4863 pub parent: Option<String>,
4864 #[serde(rename = "$scope", default, skip_serializing_if = "Option::is_none")]
4865 pub scope: Option<String>,
4866 #[serde(rename = "$template", default, skip_serializing_if = "Option::is_none")]
4867 pub template: Option<String>,
4868 #[serde(rename = "$type", default, skip_serializing_if = "Option::is_none")]
4869 pub r#type: Option<String>,
4870 #[serde(
4871 rename = "$typeVersion",
4872 default,
4873 skip_serializing_if = "Option::is_none"
4874 )]
4875 pub type_version: Option<i64>,
4876 #[serde(rename = "$version", default, skip_serializing_if = "Option::is_none")]
4877 pub version: Option<i64>,
4878 #[serde(default, skip_serializing_if = "Option::is_none")]
4879 pub cards: Option<Vec<SkillCard>>,
4880}
4881
4882#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4883pub struct StatusSkillCard {
4884 #[serde(default, skip_serializing_if = "Option::is_none")]
4885 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
4886 pub r#type: KeywordSkillCardType,
4887 pub skill_card_type: StatusSkillCardSkillCardType,
4888 #[serde(default, skip_serializing_if = "Option::is_none")]
4889 pub skill_card_title: Option<KeywordSkillCardSkillCardTitle>,
4890 pub status: StatusSkillCardStatus,
4891 pub skill: KeywordSkillCardSkill,
4892 pub invocation: KeywordSkillCardInvocation,
4893}
4894
4895#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4896pub struct StoragePolicies {
4897 #[serde(default, skip_serializing_if = "Option::is_none")]
4898 pub limit: Option<i64>,
4899 #[serde(
4900 default,
4901 skip_serializing_if = "Option::is_none",
4902 deserialize_with = "double_option"
4903 )]
4904 pub next_marker: Option<Option<String>>,
4905 #[serde(
4906 default,
4907 skip_serializing_if = "Option::is_none",
4908 deserialize_with = "double_option"
4909 )]
4910 pub prev_marker: Option<Option<String>>,
4911 #[serde(default, skip_serializing_if = "Option::is_none")]
4912 pub entries: Option<Vec<StoragePolicy>>,
4913}
4914
4915#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4916pub struct StoragePolicy {
4917 pub id: String,
4918 pub r#type: StoragePolicyType,
4919 #[serde(default, skip_serializing_if = "Option::is_none")]
4920 pub name: Option<String>,
4921}
4922
4923#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4924pub struct StoragePolicyMini {
4925 pub id: String,
4926 pub r#type: StoragePolicyType,
4927}
4928
4929#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4930pub struct StoragePolicyAssignment {
4931 pub id: String,
4932 pub r#type: StoragePolicyAssignmentType,
4933 #[serde(default, skip_serializing_if = "Option::is_none")]
4934 pub storage_policy: Option<StoragePolicyMini>,
4935 #[serde(default, skip_serializing_if = "Option::is_none")]
4936 pub assigned_to: Option<CommentItem>,
4937}
4938
4939#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4940pub struct StoragePolicyAssignments {
4941 #[serde(default, skip_serializing_if = "Option::is_none")]
4942 pub limit: Option<i64>,
4943 #[serde(
4944 default,
4945 skip_serializing_if = "Option::is_none",
4946 deserialize_with = "double_option"
4947 )]
4948 pub next_marker: Option<Option<String>>,
4949 #[serde(
4950 default,
4951 skip_serializing_if = "Option::is_none",
4952 deserialize_with = "double_option"
4953 )]
4954 pub prev_marker: Option<Option<String>>,
4955 #[serde(default, skip_serializing_if = "Option::is_none")]
4956 pub entries: Option<Vec<StoragePolicyAssignment>>,
4957}
4958
4959#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4960pub struct Task {
4961 #[serde(default, skip_serializing_if = "Option::is_none")]
4962 pub id: Option<String>,
4963 #[serde(default, skip_serializing_if = "Option::is_none")]
4964 pub r#type: Option<TaskType>,
4965 #[serde(default, skip_serializing_if = "Option::is_none")]
4966 pub item: Option<FileMini>,
4967 #[serde(default, skip_serializing_if = "Option::is_none")]
4968 pub due_at: Option<chrono::DateTime<chrono::Utc>>,
4969 #[serde(default, skip_serializing_if = "Option::is_none")]
4970 pub action: Option<TaskAction>,
4971 #[serde(default, skip_serializing_if = "Option::is_none")]
4972 pub message: Option<String>,
4973 #[serde(default, skip_serializing_if = "Option::is_none")]
4974 pub task_assignment_collection: Option<TaskAssignments>,
4975 #[serde(default, skip_serializing_if = "Option::is_none")]
4976 pub is_completed: Option<bool>,
4977 #[serde(default, skip_serializing_if = "Option::is_none")]
4978 pub created_by: Option<UserMini>,
4979 #[serde(default, skip_serializing_if = "Option::is_none")]
4980 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
4981 #[serde(default, skip_serializing_if = "Option::is_none")]
4982 pub completion_rule: Option<TaskCompletionRule>,
4983}
4984
4985#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
4986pub struct TaskAssignment {
4987 #[serde(default, skip_serializing_if = "Option::is_none")]
4988 pub id: Option<String>,
4989 #[serde(default, skip_serializing_if = "Option::is_none")]
4990 pub r#type: Option<TaskAssignmentType>,
4991 #[serde(default, skip_serializing_if = "Option::is_none")]
4992 pub item: Option<FileMini>,
4993 #[serde(default, skip_serializing_if = "Option::is_none")]
4994 pub assigned_to: Option<UserMini>,
4995 #[serde(default, skip_serializing_if = "Option::is_none")]
4996 pub message: Option<String>,
4997 #[serde(default, skip_serializing_if = "Option::is_none")]
4998 pub completed_at: Option<chrono::DateTime<chrono::Utc>>,
4999 #[serde(default, skip_serializing_if = "Option::is_none")]
5000 pub assigned_at: Option<chrono::DateTime<chrono::Utc>>,
5001 #[serde(default, skip_serializing_if = "Option::is_none")]
5002 pub reminded_at: Option<chrono::DateTime<chrono::Utc>>,
5003 #[serde(default, skip_serializing_if = "Option::is_none")]
5004 pub resolution_state: Option<TaskAssignmentResolutionState>,
5005 #[serde(default, skip_serializing_if = "Option::is_none")]
5006 pub assigned_by: Option<UserMini>,
5007}
5008
5009#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5010pub struct TaskAssignments {
5011 #[serde(default, skip_serializing_if = "Option::is_none")]
5012 pub total_count: Option<i64>,
5013 #[serde(default, skip_serializing_if = "Option::is_none")]
5014 pub entries: Option<Vec<TaskAssignment>>,
5015}
5016
5017#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5018pub struct Tasks {
5019 #[serde(default, skip_serializing_if = "Option::is_none")]
5020 pub total_count: Option<i64>,
5021 #[serde(default, skip_serializing_if = "Option::is_none")]
5022 pub entries: Option<Vec<Task>>,
5023}
5024
5025#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5026pub struct TemplateSigner {
5027 #[serde(default, skip_serializing_if = "Option::is_none")]
5028 pub inputs: Option<Vec<TemplateSignerInput>>,
5029 #[serde(
5030 default,
5031 skip_serializing_if = "Option::is_none",
5032 deserialize_with = "double_option"
5033 )]
5034 pub email: Option<Option<String>>,
5035 #[serde(default, skip_serializing_if = "Option::is_none")]
5036 pub role: Option<SignRequestCreateSignerRole>,
5037 #[serde(default, skip_serializing_if = "Option::is_none")]
5038 pub is_in_person: Option<bool>,
5039 #[serde(default, skip_serializing_if = "Option::is_none")]
5040 pub order: Option<i64>,
5041 #[serde(
5042 default,
5043 skip_serializing_if = "Option::is_none",
5044 deserialize_with = "double_option"
5045 )]
5046 pub signer_group_id: Option<Option<String>>,
5047 #[serde(
5048 default,
5049 skip_serializing_if = "Option::is_none",
5050 deserialize_with = "double_option"
5051 )]
5052 pub label: Option<Option<String>>,
5053 #[serde(default, skip_serializing_if = "Option::is_none")]
5054 pub public_id: Option<String>,
5055 #[serde(
5056 default,
5057 skip_serializing_if = "Option::is_none",
5058 deserialize_with = "double_option"
5059 )]
5060 pub is_password_required: Option<Option<bool>>,
5061 #[serde(
5062 default,
5063 skip_serializing_if = "Option::is_none",
5064 deserialize_with = "double_option"
5065 )]
5066 pub is_phone_number_required: Option<Option<bool>>,
5067 #[serde(
5068 default,
5069 skip_serializing_if = "Option::is_none",
5070 deserialize_with = "double_option"
5071 )]
5072 pub login_required: Option<Option<bool>>,
5073}
5074
5075#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5076pub struct TemplateSignerInput {
5077 #[serde(
5078 default,
5079 skip_serializing_if = "Option::is_none",
5080 deserialize_with = "double_option"
5081 )]
5082 pub document_tag_id: Option<Option<String>>,
5083 #[serde(
5084 default,
5085 skip_serializing_if = "Option::is_none",
5086 deserialize_with = "double_option"
5087 )]
5088 pub text_value: Option<Option<String>>,
5089 #[serde(
5090 default,
5091 skip_serializing_if = "Option::is_none",
5092 deserialize_with = "double_option"
5093 )]
5094 pub checkbox_value: Option<Option<bool>>,
5095 #[serde(
5096 default,
5097 skip_serializing_if = "Option::is_none",
5098 deserialize_with = "double_option"
5099 )]
5100 pub date_value: Option<Option<chrono::NaiveDate>>,
5101 #[serde(default, skip_serializing_if = "Option::is_none")]
5102 pub r#type: Option<TemplateSignerInputType>,
5103 #[serde(default, skip_serializing_if = "Option::is_none")]
5104 pub content_type: Option<SignRequestSignerInputContentType>,
5105 #[serde(default, skip_serializing_if = "Option::is_none")]
5106 pub is_required: Option<bool>,
5107 pub page_index: i64,
5108 #[serde(
5109 default,
5110 skip_serializing_if = "Option::is_none",
5111 deserialize_with = "double_option"
5112 )]
5113 pub document_id: Option<Option<String>>,
5114 #[serde(
5115 default,
5116 skip_serializing_if = "Option::is_none",
5117 deserialize_with = "double_option"
5118 )]
5119 pub dropdown_choices: Option<Option<Vec<String>>>,
5120 #[serde(
5121 default,
5122 skip_serializing_if = "Option::is_none",
5123 deserialize_with = "double_option"
5124 )]
5125 pub group_id: Option<Option<String>>,
5126 #[serde(default, skip_serializing_if = "Option::is_none")]
5127 pub coordinates: Option<TemplateSignerInputCoordinates>,
5128 #[serde(default, skip_serializing_if = "Option::is_none")]
5129 pub dimensions: Option<TemplateSignerInputDimensions>,
5130 #[serde(
5131 default,
5132 skip_serializing_if = "Option::is_none",
5133 deserialize_with = "double_option"
5134 )]
5135 pub label: Option<Option<String>>,
5136 #[serde(default, skip_serializing_if = "Option::is_none")]
5137 pub read_only: Option<bool>,
5138 #[serde(default, skip_serializing_if = "Option::is_none")]
5139 pub validation: Option<SignRequestSignerInputValidation2>,
5140}
5141
5142#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5143pub struct TermsOfService {
5144 pub id: String,
5145 pub r#type: TermsOfServiceType,
5146 #[serde(default, skip_serializing_if = "Option::is_none")]
5147 pub status: Option<TermsOfServiceStatus>,
5148 #[serde(default, skip_serializing_if = "Option::is_none")]
5149 pub enterprise: Option<CollaborationAllowlistEntryEnterprise>,
5150 #[serde(default, skip_serializing_if = "Option::is_none")]
5151 pub tos_type: Option<TermsOfServiceTosType>,
5152 #[serde(default, skip_serializing_if = "Option::is_none")]
5153 pub text: Option<String>,
5154 #[serde(default, skip_serializing_if = "Option::is_none")]
5155 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
5156 #[serde(default, skip_serializing_if = "Option::is_none")]
5157 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
5158}
5159
5160#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5161pub struct TermsOfServiceBase {
5162 pub id: String,
5163 pub r#type: TermsOfServiceType,
5164}
5165
5166#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5167pub struct TermsOfServices {
5168 #[serde(default, skip_serializing_if = "Option::is_none")]
5169 pub total_count: Option<i64>,
5170 #[serde(default, skip_serializing_if = "Option::is_none")]
5171 pub entries: Option<Vec<TermsOfService>>,
5172}
5173
5174#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5175pub struct TermsOfServiceUserStatus {
5176 pub id: String,
5177 pub r#type: TermsOfServiceUserStatusType,
5178 #[serde(default, skip_serializing_if = "Option::is_none")]
5179 pub tos: Option<TermsOfServiceBase>,
5180 #[serde(default, skip_serializing_if = "Option::is_none")]
5181 pub user: Option<UserMini>,
5182 #[serde(default, skip_serializing_if = "Option::is_none")]
5183 pub is_accepted: Option<bool>,
5184 #[serde(default, skip_serializing_if = "Option::is_none")]
5185 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
5186 #[serde(default, skip_serializing_if = "Option::is_none")]
5187 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
5188}
5189
5190#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5191pub struct TermsOfServiceUserStatuses {
5192 #[serde(default, skip_serializing_if = "Option::is_none")]
5193 pub total_count: Option<i64>,
5194 #[serde(default, skip_serializing_if = "Option::is_none")]
5195 pub entries: Option<Vec<TermsOfServiceUserStatus>>,
5196}
5197
5198#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5199pub struct TimelineSkillCard {
5200 #[serde(default, skip_serializing_if = "Option::is_none")]
5201 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
5202 pub r#type: KeywordSkillCardType,
5203 pub skill_card_type: TimelineSkillCardSkillCardType,
5204 #[serde(default, skip_serializing_if = "Option::is_none")]
5205 pub skill_card_title: Option<KeywordSkillCardSkillCardTitle>,
5206 pub skill: KeywordSkillCardSkill,
5207 pub invocation: KeywordSkillCardInvocation,
5208 #[serde(default, skip_serializing_if = "Option::is_none")]
5209 pub duration: Option<i64>,
5210 pub entries: Vec<TimelineSkillCardEntries>,
5211}
5212
5213#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5214pub struct TrackingCode {
5215 #[serde(default, skip_serializing_if = "Option::is_none")]
5216 pub r#type: Option<TrackingCodeType>,
5217 #[serde(default, skip_serializing_if = "Option::is_none")]
5218 pub name: Option<String>,
5219 #[serde(default, skip_serializing_if = "Option::is_none")]
5220 pub value: Option<String>,
5221}
5222
5223#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5224pub struct TranscriptSkillCard {
5225 #[serde(default, skip_serializing_if = "Option::is_none")]
5226 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
5227 pub r#type: KeywordSkillCardType,
5228 pub skill_card_type: TranscriptSkillCardSkillCardType,
5229 #[serde(default, skip_serializing_if = "Option::is_none")]
5230 pub skill_card_title: Option<KeywordSkillCardSkillCardTitle>,
5231 pub skill: KeywordSkillCardSkill,
5232 pub invocation: KeywordSkillCardInvocation,
5233 #[serde(default, skip_serializing_if = "Option::is_none")]
5234 pub duration: Option<i64>,
5235 pub entries: Vec<TranscriptSkillCardEntries>,
5236}
5237
5238#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5239pub struct TrashFile {
5240 pub id: String,
5241 #[serde(
5242 default,
5243 skip_serializing_if = "Option::is_none",
5244 deserialize_with = "double_option"
5245 )]
5246 pub etag: Option<Option<String>>,
5247 pub r#type: AiCitationType,
5248 pub sequence_id: String,
5249 #[serde(default, skip_serializing_if = "Option::is_none")]
5250 pub name: Option<String>,
5251 pub sha1: String,
5252 #[serde(default, skip_serializing_if = "Option::is_none")]
5253 pub file_version: Option<FileVersionMini>,
5254 pub description: String,
5255 pub size: i64,
5256 pub path_collection: TrashFilePathCollection,
5257 pub created_at: chrono::DateTime<chrono::Utc>,
5258 pub modified_at: chrono::DateTime<chrono::Utc>,
5259 #[serde(
5260 default,
5261 skip_serializing_if = "Option::is_none",
5262 deserialize_with = "double_option"
5263 )]
5264 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5265 #[serde(
5266 default,
5267 skip_serializing_if = "Option::is_none",
5268 deserialize_with = "double_option"
5269 )]
5270 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5271 #[serde(
5272 default,
5273 skip_serializing_if = "Option::is_none",
5274 deserialize_with = "double_option"
5275 )]
5276 pub content_created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5277 #[serde(
5278 default,
5279 skip_serializing_if = "Option::is_none",
5280 deserialize_with = "double_option"
5281 )]
5282 pub content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5283 #[serde(default, skip_serializing_if = "Option::is_none")]
5284 pub created_by: Option<UserMini>,
5285 pub modified_by: UserMini,
5286 pub owned_by: UserMini,
5287 #[serde(
5288 default,
5289 skip_serializing_if = "Option::is_none",
5290 deserialize_with = "double_option"
5291 )]
5292 pub shared_link: Option<Option<String>>,
5293 #[serde(
5294 default,
5295 skip_serializing_if = "Option::is_none",
5296 deserialize_with = "double_option"
5297 )]
5298 pub parent: Option<Option<FolderMini>>,
5299 pub item_status: FileItemStatus,
5300}
5301
5302#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5303pub struct TrashFileRestored {
5304 pub id: String,
5305 #[serde(
5306 default,
5307 skip_serializing_if = "Option::is_none",
5308 deserialize_with = "double_option"
5309 )]
5310 pub etag: Option<Option<String>>,
5311 pub r#type: AiCitationType,
5312 pub sequence_id: String,
5313 #[serde(default, skip_serializing_if = "Option::is_none")]
5314 pub name: Option<String>,
5315 pub sha1: String,
5316 #[serde(default, skip_serializing_if = "Option::is_none")]
5317 pub file_version: Option<FileVersionMini>,
5318 pub description: String,
5319 pub size: i64,
5320 pub path_collection: FilePathCollection,
5321 pub created_at: chrono::DateTime<chrono::Utc>,
5322 pub modified_at: chrono::DateTime<chrono::Utc>,
5323 #[serde(
5324 default,
5325 skip_serializing_if = "Option::is_none",
5326 deserialize_with = "double_option"
5327 )]
5328 pub trashed_at: Option<Option<String>>,
5329 #[serde(
5330 default,
5331 skip_serializing_if = "Option::is_none",
5332 deserialize_with = "double_option"
5333 )]
5334 pub purged_at: Option<Option<String>>,
5335 #[serde(
5336 default,
5337 skip_serializing_if = "Option::is_none",
5338 deserialize_with = "double_option"
5339 )]
5340 pub content_created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5341 #[serde(
5342 default,
5343 skip_serializing_if = "Option::is_none",
5344 deserialize_with = "double_option"
5345 )]
5346 pub content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5347 #[serde(default, skip_serializing_if = "Option::is_none")]
5348 pub created_by: Option<UserMini>,
5349 pub modified_by: UserMini,
5350 pub owned_by: UserMini,
5351 #[serde(
5352 default,
5353 skip_serializing_if = "Option::is_none",
5354 deserialize_with = "double_option"
5355 )]
5356 pub shared_link: Option<Option<String>>,
5357 #[serde(
5358 default,
5359 skip_serializing_if = "Option::is_none",
5360 deserialize_with = "double_option"
5361 )]
5362 pub parent: Option<Option<FolderMini>>,
5363 pub item_status: FileItemStatus,
5364}
5365
5366#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5367pub struct TrashFolder {
5368 pub id: String,
5369 #[serde(
5370 default,
5371 skip_serializing_if = "Option::is_none",
5372 deserialize_with = "double_option"
5373 )]
5374 pub etag: Option<Option<String>>,
5375 pub r#type: FolderType,
5376 #[serde(default, skip_serializing_if = "Option::is_none")]
5377 pub sequence_id: Option<String>,
5378 pub name: String,
5379 #[serde(
5380 default,
5381 skip_serializing_if = "Option::is_none",
5382 deserialize_with = "double_option"
5383 )]
5384 pub created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5385 #[serde(
5386 default,
5387 skip_serializing_if = "Option::is_none",
5388 deserialize_with = "double_option"
5389 )]
5390 pub modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5391 pub description: String,
5392 pub size: i64,
5393 pub path_collection: TrashFilePathCollection,
5394 pub created_by: UserMini,
5395 pub modified_by: UserMini,
5396 #[serde(
5397 default,
5398 skip_serializing_if = "Option::is_none",
5399 deserialize_with = "double_option"
5400 )]
5401 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5402 #[serde(
5403 default,
5404 skip_serializing_if = "Option::is_none",
5405 deserialize_with = "double_option"
5406 )]
5407 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5408 #[serde(
5409 default,
5410 skip_serializing_if = "Option::is_none",
5411 deserialize_with = "double_option"
5412 )]
5413 pub content_created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5414 #[serde(
5415 default,
5416 skip_serializing_if = "Option::is_none",
5417 deserialize_with = "double_option"
5418 )]
5419 pub content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5420 pub owned_by: UserMini,
5421 #[serde(
5422 default,
5423 skip_serializing_if = "Option::is_none",
5424 deserialize_with = "double_option"
5425 )]
5426 pub shared_link: Option<Option<String>>,
5427 #[serde(
5428 default,
5429 skip_serializing_if = "Option::is_none",
5430 deserialize_with = "double_option"
5431 )]
5432 pub folder_upload_email: Option<Option<String>>,
5433 #[serde(
5434 default,
5435 skip_serializing_if = "Option::is_none",
5436 deserialize_with = "double_option"
5437 )]
5438 pub parent: Option<Option<FolderMini>>,
5439 pub item_status: FileItemStatus,
5440}
5441
5442#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5443pub struct TrashFolderRestored {
5444 #[serde(default, skip_serializing_if = "Option::is_none")]
5445 pub id: Option<String>,
5446 #[serde(
5447 default,
5448 skip_serializing_if = "Option::is_none",
5449 deserialize_with = "double_option"
5450 )]
5451 pub etag: Option<Option<String>>,
5452 #[serde(default, skip_serializing_if = "Option::is_none")]
5453 pub r#type: Option<FolderType>,
5454 #[serde(default, skip_serializing_if = "Option::is_none")]
5455 pub sequence_id: Option<String>,
5456 #[serde(default, skip_serializing_if = "Option::is_none")]
5457 pub name: Option<String>,
5458 #[serde(
5459 default,
5460 skip_serializing_if = "Option::is_none",
5461 deserialize_with = "double_option"
5462 )]
5463 pub created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5464 #[serde(
5465 default,
5466 skip_serializing_if = "Option::is_none",
5467 deserialize_with = "double_option"
5468 )]
5469 pub modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5470 #[serde(default, skip_serializing_if = "Option::is_none")]
5471 pub description: Option<String>,
5472 #[serde(default, skip_serializing_if = "Option::is_none")]
5473 pub size: Option<i64>,
5474 #[serde(default, skip_serializing_if = "Option::is_none")]
5475 pub path_collection: Option<FilePathCollection>,
5476 #[serde(default, skip_serializing_if = "Option::is_none")]
5477 pub created_by: Option<UserMini>,
5478 #[serde(default, skip_serializing_if = "Option::is_none")]
5479 pub modified_by: Option<UserMini>,
5480 #[serde(
5481 default,
5482 skip_serializing_if = "Option::is_none",
5483 deserialize_with = "double_option"
5484 )]
5485 pub trashed_at: Option<Option<String>>,
5486 #[serde(
5487 default,
5488 skip_serializing_if = "Option::is_none",
5489 deserialize_with = "double_option"
5490 )]
5491 pub purged_at: Option<Option<String>>,
5492 #[serde(
5493 default,
5494 skip_serializing_if = "Option::is_none",
5495 deserialize_with = "double_option"
5496 )]
5497 pub content_created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5498 #[serde(
5499 default,
5500 skip_serializing_if = "Option::is_none",
5501 deserialize_with = "double_option"
5502 )]
5503 pub content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5504 #[serde(default, skip_serializing_if = "Option::is_none")]
5505 pub owned_by: Option<UserMini>,
5506 #[serde(
5507 default,
5508 skip_serializing_if = "Option::is_none",
5509 deserialize_with = "double_option"
5510 )]
5511 pub shared_link: Option<Option<String>>,
5512 #[serde(
5513 default,
5514 skip_serializing_if = "Option::is_none",
5515 deserialize_with = "double_option"
5516 )]
5517 pub folder_upload_email: Option<Option<String>>,
5518 #[serde(
5519 default,
5520 skip_serializing_if = "Option::is_none",
5521 deserialize_with = "double_option"
5522 )]
5523 pub parent: Option<Option<FolderMini>>,
5524 #[serde(default, skip_serializing_if = "Option::is_none")]
5525 pub item_status: Option<FileItemStatus>,
5526}
5527
5528#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5529pub struct TrashWebLink {
5530 #[serde(default, skip_serializing_if = "Option::is_none")]
5531 pub r#type: Option<TrashWebLinkType>,
5532 #[serde(default, skip_serializing_if = "Option::is_none")]
5533 pub id: Option<String>,
5534 #[serde(default, skip_serializing_if = "Option::is_none")]
5535 pub sequence_id: Option<String>,
5536 #[serde(default, skip_serializing_if = "Option::is_none")]
5537 pub etag: Option<String>,
5538 #[serde(default, skip_serializing_if = "Option::is_none")]
5539 pub name: Option<String>,
5540 #[serde(default, skip_serializing_if = "Option::is_none")]
5541 pub url: Option<String>,
5542 #[serde(default, skip_serializing_if = "Option::is_none")]
5543 pub parent: Option<FolderMini>,
5544 #[serde(default, skip_serializing_if = "Option::is_none")]
5545 pub description: Option<String>,
5546 #[serde(default, skip_serializing_if = "Option::is_none")]
5547 pub path_collection: Option<TrashFilePathCollection>,
5548 #[serde(default, skip_serializing_if = "Option::is_none")]
5549 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
5550 #[serde(default, skip_serializing_if = "Option::is_none")]
5551 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
5552 #[serde(
5553 default,
5554 skip_serializing_if = "Option::is_none",
5555 deserialize_with = "double_option"
5556 )]
5557 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5558 #[serde(
5559 default,
5560 skip_serializing_if = "Option::is_none",
5561 deserialize_with = "double_option"
5562 )]
5563 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5564 #[serde(default, skip_serializing_if = "Option::is_none")]
5565 pub created_by: Option<UserMini>,
5566 #[serde(default, skip_serializing_if = "Option::is_none")]
5567 pub modified_by: Option<UserMini>,
5568 #[serde(default, skip_serializing_if = "Option::is_none")]
5569 pub owned_by: Option<UserMini>,
5570 #[serde(
5571 default,
5572 skip_serializing_if = "Option::is_none",
5573 deserialize_with = "double_option"
5574 )]
5575 pub shared_link: Option<Option<String>>,
5576 #[serde(default, skip_serializing_if = "Option::is_none")]
5577 pub item_status: Option<FileItemStatus>,
5578}
5579
5580#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5581pub struct TrashWebLinkRestored {
5582 #[serde(default, skip_serializing_if = "Option::is_none")]
5583 pub r#type: Option<TrashWebLinkType>,
5584 #[serde(default, skip_serializing_if = "Option::is_none")]
5585 pub id: Option<String>,
5586 pub sequence_id: String,
5587 #[serde(default, skip_serializing_if = "Option::is_none")]
5588 pub etag: Option<String>,
5589 #[serde(default, skip_serializing_if = "Option::is_none")]
5590 pub name: Option<String>,
5591 #[serde(default, skip_serializing_if = "Option::is_none")]
5592 pub url: Option<String>,
5593 #[serde(default, skip_serializing_if = "Option::is_none")]
5594 pub parent: Option<FolderMini>,
5595 #[serde(default, skip_serializing_if = "Option::is_none")]
5596 pub description: Option<String>,
5597 pub path_collection: FilePathCollection,
5598 #[serde(default, skip_serializing_if = "Option::is_none")]
5599 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
5600 #[serde(default, skip_serializing_if = "Option::is_none")]
5601 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
5602 #[serde(
5603 default,
5604 skip_serializing_if = "Option::is_none",
5605 deserialize_with = "double_option"
5606 )]
5607 pub trashed_at: Option<Option<String>>,
5608 #[serde(
5609 default,
5610 skip_serializing_if = "Option::is_none",
5611 deserialize_with = "double_option"
5612 )]
5613 pub purged_at: Option<Option<String>>,
5614 #[serde(default, skip_serializing_if = "Option::is_none")]
5615 pub created_by: Option<UserMini>,
5616 #[serde(default, skip_serializing_if = "Option::is_none")]
5617 pub modified_by: Option<UserMini>,
5618 #[serde(default, skip_serializing_if = "Option::is_none")]
5619 pub owned_by: Option<UserMini>,
5620 #[serde(
5621 default,
5622 skip_serializing_if = "Option::is_none",
5623 deserialize_with = "double_option"
5624 )]
5625 pub shared_link: Option<Option<String>>,
5626 #[serde(default, skip_serializing_if = "Option::is_none")]
5627 pub item_status: Option<FileItemStatus>,
5628}
5629
5630#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5631pub struct UploadedPart {
5632 #[serde(default, skip_serializing_if = "Option::is_none")]
5633 pub part: Option<UploadPart>,
5634}
5635
5636#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5637pub struct UploadPart {
5638 #[serde(default, skip_serializing_if = "Option::is_none")]
5639 pub part_id: Option<String>,
5640 #[serde(default, skip_serializing_if = "Option::is_none")]
5641 pub offset: Option<i64>,
5642 #[serde(default, skip_serializing_if = "Option::is_none")]
5643 pub size: Option<i64>,
5644 #[serde(default, skip_serializing_if = "Option::is_none")]
5645 pub sha1: Option<String>,
5646}
5647
5648#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5649pub struct UploadPartMini {
5650 #[serde(default, skip_serializing_if = "Option::is_none")]
5651 pub part_id: Option<String>,
5652 #[serde(default, skip_serializing_if = "Option::is_none")]
5653 pub offset: Option<i64>,
5654 #[serde(default, skip_serializing_if = "Option::is_none")]
5655 pub size: Option<i64>,
5656}
5657
5658#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5659pub struct UploadParts {
5660 #[serde(default, skip_serializing_if = "Option::is_none")]
5661 pub total_count: Option<i64>,
5662 #[serde(default, skip_serializing_if = "Option::is_none")]
5663 pub limit: Option<i64>,
5664 #[serde(default, skip_serializing_if = "Option::is_none")]
5665 pub offset: Option<i64>,
5666 #[serde(default, skip_serializing_if = "Option::is_none")]
5667 pub order: Option<Vec<CollectionsOrder>>,
5668 #[serde(default, skip_serializing_if = "Option::is_none")]
5669 pub entries: Option<Vec<UploadPart>>,
5670}
5671
5672#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5673pub struct UploadSession {
5674 #[serde(default, skip_serializing_if = "Option::is_none")]
5675 pub id: Option<String>,
5676 #[serde(default, skip_serializing_if = "Option::is_none")]
5677 pub r#type: Option<UploadSessionType>,
5678 #[serde(default, skip_serializing_if = "Option::is_none")]
5679 pub session_expires_at: Option<chrono::DateTime<chrono::Utc>>,
5680 #[serde(default, skip_serializing_if = "Option::is_none")]
5681 pub part_size: Option<i64>,
5682 #[serde(default, skip_serializing_if = "Option::is_none")]
5683 pub total_parts: Option<i64>,
5684 #[serde(default, skip_serializing_if = "Option::is_none")]
5685 pub num_parts_processed: Option<i64>,
5686 #[serde(default, skip_serializing_if = "Option::is_none")]
5687 pub session_endpoints: Option<UploadSessionSessionEndpoints>,
5688}
5689
5690#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5691pub struct UploadUrl {
5692 #[serde(default, skip_serializing_if = "Option::is_none")]
5693 pub upload_url: Option<String>,
5694 #[serde(default, skip_serializing_if = "Option::is_none")]
5695 pub upload_token: Option<String>,
5696}
5697
5698#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5699pub struct User {
5700 pub id: String,
5701 pub r#type: VariableValueType,
5702 #[serde(default, skip_serializing_if = "Option::is_none")]
5703 pub name: Option<String>,
5704 #[serde(default, skip_serializing_if = "Option::is_none")]
5705 pub login: Option<String>,
5706 #[serde(default, skip_serializing_if = "Option::is_none")]
5707 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
5708 #[serde(default, skip_serializing_if = "Option::is_none")]
5709 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
5710 #[serde(default, skip_serializing_if = "Option::is_none")]
5711 pub language: Option<String>,
5712 #[serde(default, skip_serializing_if = "Option::is_none")]
5713 pub timezone: Option<String>,
5714 #[serde(default, skip_serializing_if = "Option::is_none")]
5715 pub space_amount: Option<i64>,
5716 #[serde(default, skip_serializing_if = "Option::is_none")]
5717 pub space_used: Option<i64>,
5718 #[serde(default, skip_serializing_if = "Option::is_none")]
5719 pub max_upload_size: Option<i64>,
5720 #[serde(default, skip_serializing_if = "Option::is_none")]
5721 pub status: Option<UserStatus>,
5722 #[serde(default, skip_serializing_if = "Option::is_none")]
5723 pub job_title: Option<String>,
5724 #[serde(default, skip_serializing_if = "Option::is_none")]
5725 pub phone: Option<String>,
5726 #[serde(default, skip_serializing_if = "Option::is_none")]
5727 pub address: Option<String>,
5728 #[serde(default, skip_serializing_if = "Option::is_none")]
5729 pub avatar_url: Option<String>,
5730 #[serde(
5731 default,
5732 skip_serializing_if = "Option::is_none",
5733 deserialize_with = "double_option"
5734 )]
5735 pub notification_email: Option<Option<UserNotificationEmail>>,
5736}
5737
5738#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5739pub struct UserBase {
5740 pub id: String,
5741 pub r#type: VariableValueType,
5742}
5743
5744#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5745pub struct UserCollaborations {
5746 pub id: String,
5747 pub r#type: VariableValueType,
5748 #[serde(default, skip_serializing_if = "Option::is_none")]
5749 pub name: Option<String>,
5750 #[serde(default, skip_serializing_if = "Option::is_none")]
5751 pub login: Option<String>,
5752 #[serde(default, skip_serializing_if = "Option::is_none")]
5753 pub is_active: Option<bool>,
5754}
5755
5756#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5757pub struct UserFull {
5758 pub id: String,
5759 pub r#type: VariableValueType,
5760 #[serde(default, skip_serializing_if = "Option::is_none")]
5761 pub name: Option<String>,
5762 #[serde(default, skip_serializing_if = "Option::is_none")]
5763 pub login: Option<String>,
5764 #[serde(default, skip_serializing_if = "Option::is_none")]
5765 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
5766 #[serde(default, skip_serializing_if = "Option::is_none")]
5767 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
5768 #[serde(default, skip_serializing_if = "Option::is_none")]
5769 pub language: Option<String>,
5770 #[serde(default, skip_serializing_if = "Option::is_none")]
5771 pub timezone: Option<String>,
5772 #[serde(default, skip_serializing_if = "Option::is_none")]
5773 pub space_amount: Option<i64>,
5774 #[serde(default, skip_serializing_if = "Option::is_none")]
5775 pub space_used: Option<i64>,
5776 #[serde(default, skip_serializing_if = "Option::is_none")]
5777 pub max_upload_size: Option<i64>,
5778 #[serde(default, skip_serializing_if = "Option::is_none")]
5779 pub status: Option<UserStatus>,
5780 #[serde(default, skip_serializing_if = "Option::is_none")]
5781 pub job_title: Option<String>,
5782 #[serde(default, skip_serializing_if = "Option::is_none")]
5783 pub phone: Option<String>,
5784 #[serde(default, skip_serializing_if = "Option::is_none")]
5785 pub address: Option<String>,
5786 #[serde(default, skip_serializing_if = "Option::is_none")]
5787 pub avatar_url: Option<String>,
5788 #[serde(
5789 default,
5790 skip_serializing_if = "Option::is_none",
5791 deserialize_with = "double_option"
5792 )]
5793 pub notification_email: Option<Option<UserNotificationEmail>>,
5794 #[serde(default, skip_serializing_if = "Option::is_none")]
5795 pub role: Option<UserFullRole>,
5796 #[serde(default, skip_serializing_if = "Option::is_none")]
5797 pub tracking_codes: Option<Vec<TrackingCode>>,
5798 #[serde(default, skip_serializing_if = "Option::is_none")]
5799 pub can_see_managed_users: Option<bool>,
5800 #[serde(default, skip_serializing_if = "Option::is_none")]
5801 pub is_sync_enabled: Option<bool>,
5802 #[serde(default, skip_serializing_if = "Option::is_none")]
5803 pub is_external_collab_restricted: Option<bool>,
5804 #[serde(default, skip_serializing_if = "Option::is_none")]
5805 pub is_exempt_from_device_limits: Option<bool>,
5806 #[serde(default, skip_serializing_if = "Option::is_none")]
5807 pub is_exempt_from_login_verification: Option<bool>,
5808 #[serde(default, skip_serializing_if = "Option::is_none")]
5809 pub enterprise: Option<CollaborationAllowlistEntryEnterprise>,
5810 #[serde(default, skip_serializing_if = "Option::is_none")]
5811 pub my_tags: Option<Vec<String>>,
5812 #[serde(default, skip_serializing_if = "Option::is_none")]
5813 pub hostname: Option<String>,
5814 #[serde(default, skip_serializing_if = "Option::is_none")]
5815 pub is_platform_access_only: Option<bool>,
5816 #[serde(default, skip_serializing_if = "Option::is_none")]
5817 pub external_app_user_id: Option<String>,
5818}
5819
5820#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5821pub struct UserMini {
5822 pub id: String,
5823 pub r#type: VariableValueType,
5824 #[serde(default, skip_serializing_if = "Option::is_none")]
5825 pub name: Option<String>,
5826 #[serde(default, skip_serializing_if = "Option::is_none")]
5827 pub login: Option<String>,
5828}
5829
5830#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5831pub struct UserAvatar {
5832 #[serde(default, skip_serializing_if = "Option::is_none")]
5833 pub pic_urls: Option<UserAvatarPicUrls>,
5834}
5835
5836#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5837pub struct UserIntegrationMappings {
5838 pub id: String,
5839 pub r#type: VariableValueType,
5840 #[serde(default, skip_serializing_if = "Option::is_none")]
5841 pub name: Option<String>,
5842 #[serde(default, skip_serializing_if = "Option::is_none")]
5843 pub login: Option<String>,
5844}
5845
5846#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5847pub struct Users {
5848 #[serde(default, skip_serializing_if = "Option::is_none")]
5849 pub limit: Option<i64>,
5850 #[serde(
5851 default,
5852 skip_serializing_if = "Option::is_none",
5853 deserialize_with = "double_option"
5854 )]
5855 pub next_marker: Option<Option<String>>,
5856 #[serde(
5857 default,
5858 skip_serializing_if = "Option::is_none",
5859 deserialize_with = "double_option"
5860 )]
5861 pub prev_marker: Option<Option<String>>,
5862 #[serde(default, skip_serializing_if = "Option::is_none")]
5863 pub total_count: Option<i64>,
5864 #[serde(default, skip_serializing_if = "Option::is_none")]
5865 pub offset: Option<i64>,
5866 #[serde(default, skip_serializing_if = "Option::is_none")]
5867 pub order: Option<Vec<CollectionsOrder>>,
5868 #[serde(default, skip_serializing_if = "Option::is_none")]
5869 pub entries: Option<Vec<UserFull>>,
5870}
5871
5872#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5873pub struct Watermark {
5874 #[serde(default, skip_serializing_if = "Option::is_none")]
5875 pub watermark: Option<WatermarkWatermark>,
5876}
5877
5878#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5879pub struct Webhook {
5880 #[serde(default, skip_serializing_if = "Option::is_none")]
5881 pub id: Option<String>,
5882 #[serde(default, skip_serializing_if = "Option::is_none")]
5883 pub r#type: Option<WebhookType>,
5884 #[serde(default, skip_serializing_if = "Option::is_none")]
5885 pub target: Option<WebhookTarget>,
5886 #[serde(default, skip_serializing_if = "Option::is_none")]
5887 pub created_by: Option<UserMini>,
5888 #[serde(default, skip_serializing_if = "Option::is_none")]
5889 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
5890 #[serde(default, skip_serializing_if = "Option::is_none")]
5891 pub address: Option<String>,
5892 #[serde(default, skip_serializing_if = "Option::is_none")]
5893 pub triggers: Option<Vec<WebhookTriggers>>,
5894}
5895
5896#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5897pub struct WebhookMini {
5898 #[serde(default, skip_serializing_if = "Option::is_none")]
5899 pub id: Option<String>,
5900 #[serde(default, skip_serializing_if = "Option::is_none")]
5901 pub r#type: Option<WebhookType>,
5902 #[serde(default, skip_serializing_if = "Option::is_none")]
5903 pub target: Option<WebhookTarget>,
5904}
5905
5906#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5907pub struct Webhooks {
5908 #[serde(default, skip_serializing_if = "Option::is_none")]
5909 pub limit: Option<i64>,
5910 #[serde(
5911 default,
5912 skip_serializing_if = "Option::is_none",
5913 deserialize_with = "double_option"
5914 )]
5915 pub next_marker: Option<Option<String>>,
5916 #[serde(
5917 default,
5918 skip_serializing_if = "Option::is_none",
5919 deserialize_with = "double_option"
5920 )]
5921 pub prev_marker: Option<Option<String>>,
5922 #[serde(default, skip_serializing_if = "Option::is_none")]
5923 pub entries: Option<Vec<WebhookMini>>,
5924}
5925
5926#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5927pub struct WebLink {
5928 pub id: String,
5929 pub r#type: TrashWebLinkType,
5930 #[serde(default, skip_serializing_if = "Option::is_none")]
5931 pub etag: Option<String>,
5932 #[serde(default, skip_serializing_if = "Option::is_none")]
5933 pub url: Option<String>,
5934 #[serde(default, skip_serializing_if = "Option::is_none")]
5935 pub sequence_id: Option<String>,
5936 #[serde(default, skip_serializing_if = "Option::is_none")]
5937 pub name: Option<String>,
5938 #[serde(default, skip_serializing_if = "Option::is_none")]
5939 pub parent: Option<FolderMini>,
5940 #[serde(default, skip_serializing_if = "Option::is_none")]
5941 pub description: Option<String>,
5942 #[serde(default, skip_serializing_if = "Option::is_none")]
5943 pub path_collection: Option<FilePathCollection>,
5944 #[serde(default, skip_serializing_if = "Option::is_none")]
5945 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
5946 #[serde(default, skip_serializing_if = "Option::is_none")]
5947 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
5948 #[serde(
5949 default,
5950 skip_serializing_if = "Option::is_none",
5951 deserialize_with = "double_option"
5952 )]
5953 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5954 #[serde(
5955 default,
5956 skip_serializing_if = "Option::is_none",
5957 deserialize_with = "double_option"
5958 )]
5959 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5960 #[serde(default, skip_serializing_if = "Option::is_none")]
5961 pub created_by: Option<UserMini>,
5962 #[serde(default, skip_serializing_if = "Option::is_none")]
5963 pub modified_by: Option<UserMini>,
5964 #[serde(default, skip_serializing_if = "Option::is_none")]
5965 pub owned_by: Option<UserMini>,
5966 #[serde(
5967 default,
5968 skip_serializing_if = "Option::is_none",
5969 deserialize_with = "double_option"
5970 )]
5971 pub shared_link: Option<Option<FileSharedLink>>,
5972 #[serde(default, skip_serializing_if = "Option::is_none")]
5973 pub item_status: Option<FileItemStatus>,
5974}
5975
5976#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5977pub struct WebLinkBase {
5978 pub id: String,
5979 pub r#type: TrashWebLinkType,
5980 #[serde(default, skip_serializing_if = "Option::is_none")]
5981 pub etag: Option<String>,
5982}
5983
5984#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5985pub struct WebLinkMini {
5986 pub id: String,
5987 pub r#type: TrashWebLinkType,
5988 #[serde(default, skip_serializing_if = "Option::is_none")]
5989 pub etag: Option<String>,
5990 #[serde(default, skip_serializing_if = "Option::is_none")]
5991 pub url: Option<String>,
5992 #[serde(default, skip_serializing_if = "Option::is_none")]
5993 pub sequence_id: Option<String>,
5994 #[serde(default, skip_serializing_if = "Option::is_none")]
5995 pub name: Option<String>,
5996}
5997
5998#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
5999pub struct Workflow {
6000 #[serde(default, skip_serializing_if = "Option::is_none")]
6001 pub id: Option<String>,
6002 #[serde(default, skip_serializing_if = "Option::is_none")]
6003 pub r#type: Option<WorkflowType>,
6004 #[serde(default, skip_serializing_if = "Option::is_none")]
6005 pub name: Option<String>,
6006 #[serde(default, skip_serializing_if = "Option::is_none")]
6007 pub description: Option<String>,
6008 #[serde(default, skip_serializing_if = "Option::is_none")]
6009 pub is_enabled: Option<bool>,
6010 #[serde(default, skip_serializing_if = "Option::is_none")]
6011 pub flows: Option<Vec<WorkflowFlows>>,
6012}
6013
6014#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6015pub struct WorkflowMini {
6016 #[serde(default, skip_serializing_if = "Option::is_none")]
6017 pub id: Option<String>,
6018 #[serde(default, skip_serializing_if = "Option::is_none")]
6019 pub r#type: Option<WorkflowType>,
6020 #[serde(default, skip_serializing_if = "Option::is_none")]
6021 pub name: Option<String>,
6022 #[serde(default, skip_serializing_if = "Option::is_none")]
6023 pub description: Option<String>,
6024 #[serde(default, skip_serializing_if = "Option::is_none")]
6025 pub is_enabled: Option<bool>,
6026}
6027
6028#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6029pub struct Workflows {
6030 #[serde(default, skip_serializing_if = "Option::is_none")]
6031 pub limit: Option<i64>,
6032 #[serde(
6033 default,
6034 skip_serializing_if = "Option::is_none",
6035 deserialize_with = "double_option"
6036 )]
6037 pub next_marker: Option<Option<String>>,
6038 #[serde(
6039 default,
6040 skip_serializing_if = "Option::is_none",
6041 deserialize_with = "double_option"
6042 )]
6043 pub prev_marker: Option<Option<String>>,
6044 #[serde(default, skip_serializing_if = "Option::is_none")]
6045 pub entries: Option<Vec<Workflow>>,
6046}
6047
6048#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6049pub struct ZipDownload {
6050 #[serde(default, skip_serializing_if = "Option::is_none")]
6051 pub download_url: Option<String>,
6052 #[serde(default, skip_serializing_if = "Option::is_none")]
6053 pub status_url: Option<String>,
6054 #[serde(default, skip_serializing_if = "Option::is_none")]
6055 pub expires_at: Option<chrono::DateTime<chrono::Utc>>,
6056 #[serde(default, skip_serializing_if = "Option::is_none")]
6057 pub name_conflicts: Option<Vec<Vec<ZipDownloadNameConflicts>>>,
6058}
6059
6060#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6061pub struct ZipDownloadRequest {
6062 pub items: Vec<ZipDownloadRequestItems>,
6063 #[serde(default, skip_serializing_if = "Option::is_none")]
6064 pub download_file_name: Option<String>,
6065}
6066
6067#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6068pub struct ZipDownloadStatus {
6069 #[serde(default, skip_serializing_if = "Option::is_none")]
6070 pub total_file_count: Option<i64>,
6071 #[serde(default, skip_serializing_if = "Option::is_none")]
6072 pub downloaded_file_count: Option<i64>,
6073 #[serde(default, skip_serializing_if = "Option::is_none")]
6074 pub skipped_file_count: Option<i64>,
6075 #[serde(default, skip_serializing_if = "Option::is_none")]
6076 pub skipped_folder_count: Option<i64>,
6077 #[serde(default, skip_serializing_if = "Option::is_none")]
6078 pub state: Option<ZipDownloadStatusState>,
6079}
6080
6081#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6082#[serde(transparent)]
6083pub struct AccessTokenTokenType(pub String);
6084
6085impl AccessTokenTokenType {
6086 pub const BEARER: &'static str = "bearer";
6087}
6088
6089#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6090#[serde(transparent)]
6091pub struct AccessTokenIssuedTokenType(pub String);
6092
6093impl AccessTokenIssuedTokenType {
6094 pub const URN_IETF_PARAMS_OAUTH_TOKEN_TYPE_ACCESS_TOKEN: &'static str =
6095 "urn:ietf:params:oauth:token-type:access_token";
6096}
6097
6098#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6099#[serde(transparent)]
6100pub struct AiAgentAskType(pub String);
6101
6102impl AiAgentAskType {
6103 pub const AI_AGENT_ASK: &'static str = "ai_agent_ask";
6104}
6105
6106#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6107pub struct EmbeddingsStrategy {
6108 #[serde(default, skip_serializing_if = "Option::is_none")]
6109 pub id: Option<String>,
6110 #[serde(default, skip_serializing_if = "Option::is_none")]
6111 pub num_tokens_per_chunk: Option<i64>,
6112}
6113
6114#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6115pub struct AiAgentBasicGenToolEmbeddings {
6116 #[serde(default, skip_serializing_if = "Option::is_none")]
6117 pub model: Option<String>,
6118 #[serde(default, skip_serializing_if = "Option::is_none")]
6119 pub strategy: Option<EmbeddingsStrategy>,
6120}
6121
6122#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6123#[serde(transparent)]
6124pub struct AiAgentExtractType(pub String);
6125
6126impl AiAgentExtractType {
6127 pub const AI_AGENT_EXTRACT: &'static str = "ai_agent_extract";
6128}
6129
6130#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6131#[serde(transparent)]
6132pub struct AiAgentExtractStructuredType(pub String);
6133
6134impl AiAgentExtractStructuredType {
6135 pub const AI_AGENT_EXTRACT_STRUCTURED: &'static str = "ai_agent_extract_structured";
6136}
6137
6138#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6139pub struct AiAgentInfoModels {
6140 #[serde(default, skip_serializing_if = "Option::is_none")]
6141 pub name: Option<String>,
6142 #[serde(default, skip_serializing_if = "Option::is_none")]
6143 pub provider: Option<String>,
6144 #[serde(default, skip_serializing_if = "Option::is_none")]
6145 pub supported_purpose: Option<String>,
6146}
6147
6148#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6149#[serde(transparent)]
6150pub struct AiAgentReferenceType(pub String);
6151
6152impl AiAgentReferenceType {
6153 pub const AI_AGENT_ID: &'static str = "ai_agent_id";
6154}
6155
6156#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6157#[serde(transparent)]
6158pub struct AiAgentTextGenType(pub String);
6159
6160impl AiAgentTextGenType {
6161 pub const AI_AGENT_TEXT_GEN: &'static str = "ai_agent_text_gen";
6162}
6163
6164#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6165#[serde(transparent)]
6166pub struct AiAskMode(pub String);
6167
6168impl AiAskMode {
6169 pub const MULTIPLE_ITEM_QA: &'static str = "multiple_item_qa";
6170 pub const SINGLE_ITEM_QA: &'static str = "single_item_qa";
6171}
6172
6173#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6174#[serde(transparent)]
6175pub struct AiCitationType(pub String);
6176
6177impl AiCitationType {
6178 pub const FILE: &'static str = "file";
6179}
6180
6181#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6182#[serde(transparent)]
6183pub struct MetadataTemplateType(pub String);
6184
6185impl MetadataTemplateType {
6186 pub const METADATA_TEMPLATE: &'static str = "metadata_template";
6187}
6188
6189#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6190pub struct AiExtractStructuredMetadataTemplate {
6191 #[serde(default, skip_serializing_if = "Option::is_none")]
6192 pub template_key: Option<String>,
6193 #[serde(default, skip_serializing_if = "Option::is_none")]
6194 pub r#type: Option<MetadataTemplateType>,
6195 #[serde(default, skip_serializing_if = "Option::is_none")]
6196 pub scope: Option<String>,
6197}
6198
6199#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6200pub struct FieldsOptions {
6201 pub key: String,
6202}
6203
6204#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6205pub struct AiExtractStructuredFields {
6206 pub key: String,
6207 #[serde(default, skip_serializing_if = "Option::is_none")]
6208 pub description: Option<String>,
6209 #[serde(
6210 rename = "displayName",
6211 default,
6212 skip_serializing_if = "Option::is_none"
6213 )]
6214 pub display_name: Option<String>,
6215 #[serde(default, skip_serializing_if = "Option::is_none")]
6216 pub prompt: Option<String>,
6217 #[serde(default, skip_serializing_if = "Option::is_none")]
6218 pub r#type: Option<String>,
6219 #[serde(default, skip_serializing_if = "Option::is_none")]
6220 pub options: Option<Vec<FieldsOptions>>,
6221 #[serde(default, skip_serializing_if = "Option::is_none")]
6222 pub fields: Option<Vec<AiExtractSubField>>,
6223 #[serde(default, skip_serializing_if = "Option::is_none")]
6224 pub taxonomy_key: Option<String>,
6225 #[serde(default, skip_serializing_if = "Option::is_none")]
6226 pub namespace: Option<String>,
6227 #[serde(default, skip_serializing_if = "Option::is_none")]
6228 pub options_rules: Option<AiOptionsRules>,
6229}
6230
6231#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6232#[serde(transparent)]
6233pub struct AiItemAskType(pub String);
6234
6235impl AiItemAskType {
6236 pub const FILE: &'static str = "file";
6237 pub const HUBS: &'static str = "hubs";
6238}
6239
6240#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6241#[serde(transparent)]
6242pub struct AiLlmEndpointParamsAWSType(pub String);
6243
6244impl AiLlmEndpointParamsAWSType {
6245 pub const AWS_PARAMS: &'static str = "aws_params";
6246}
6247
6248#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6249#[serde(transparent)]
6250pub struct AiLlmEndpointParamsGoogleType(pub String);
6251
6252impl AiLlmEndpointParamsGoogleType {
6253 pub const GOOGLE_PARAMS: &'static str = "google_params";
6254}
6255
6256#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6257#[serde(transparent)]
6258pub struct AiLlmEndpointParamsIBMType(pub String);
6259
6260impl AiLlmEndpointParamsIBMType {
6261 pub const IBM_PARAMS: &'static str = "ibm_params";
6262}
6263
6264#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6265#[serde(transparent)]
6266pub struct AiLlmEndpointParamsOpenAiType(pub String);
6267
6268impl AiLlmEndpointParamsOpenAiType {
6269 pub const OPENAI_PARAMS: &'static str = "openai_params";
6270}
6271
6272#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6273#[serde(transparent)]
6274pub struct AiSingleAgentResponseType(pub String);
6275
6276impl AiSingleAgentResponseType {
6277 pub const AI_AGENT: &'static str = "ai_agent";
6278}
6279
6280#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6281#[serde(transparent)]
6282pub struct AiTaxonomyReferenceType(pub String);
6283
6284impl AiTaxonomyReferenceType {
6285 pub const TAXONOMY: &'static str = "taxonomy";
6286}
6287
6288#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6289pub struct AiTextGenItems {
6290 pub id: String,
6291 pub r#type: AiCitationType,
6292 #[serde(default, skip_serializing_if = "Option::is_none")]
6293 pub content: Option<String>,
6294}
6295
6296#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6297#[serde(transparent)]
6298pub struct AppItemType(pub String);
6299
6300impl AppItemType {
6301 pub const APP_ITEM: &'static str = "app_item";
6302}
6303
6304#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6305#[serde(transparent)]
6306pub struct AppItemAssociationType(pub String);
6307
6308impl AppItemAssociationType {
6309 pub const APP_ITEM_ASSOCIATION: &'static str = "app_item_association";
6310}
6311
6312#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6313#[serde(transparent)]
6314pub struct ClassificationTemplate2(pub String);
6315
6316impl ClassificationTemplate2 {
6317 pub const SECURITYCLASSIFICATION_6VMVOCHWUWO: &'static str =
6318 "securityClassification-6VMVochwUWo";
6319}
6320
6321#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6322#[serde(transparent)]
6323pub struct ClassificationTemplateDisplayName(pub String);
6324
6325impl ClassificationTemplateDisplayName {
6326 pub const CLASSIFICATION: &'static str = "Classification";
6327}
6328
6329#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6330#[serde(transparent)]
6331pub struct FieldsType(pub String);
6332
6333impl FieldsType {
6334 pub const ENUM: &'static str = "enum";
6335}
6336
6337#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6338#[serde(transparent)]
6339pub struct FieldsKey(pub String);
6340
6341impl FieldsKey {
6342 pub const BOX_SECURITY_CLASSIFICATION_KEY: &'static str = "Box__Security__Classification__Key";
6343}
6344
6345#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6346pub struct StaticConfigClassification {
6347 #[serde(
6348 rename = "classificationDefinition",
6349 default,
6350 skip_serializing_if = "Option::is_none"
6351 )]
6352 pub classification_definition: Option<String>,
6353 #[serde(rename = "colorID", default, skip_serializing_if = "Option::is_none")]
6354 pub color_id: Option<i64>,
6355}
6356
6357#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6358pub struct OptionsStaticConfig {
6359 #[serde(default, skip_serializing_if = "Option::is_none")]
6360 pub classification: Option<StaticConfigClassification>,
6361}
6362
6363#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6364pub struct FieldsOptions2 {
6365 pub id: String,
6366 pub key: String,
6367 #[serde(
6368 rename = "staticConfig",
6369 default,
6370 skip_serializing_if = "Option::is_none"
6371 )]
6372 pub static_config: Option<OptionsStaticConfig>,
6373}
6374
6375#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6376pub struct ClassificationTemplateFields {
6377 pub id: String,
6378 pub r#type: FieldsType,
6379 pub key: FieldsKey,
6380 #[serde(rename = "displayName")]
6381 pub display_name: ClassificationTemplateDisplayName,
6382 #[serde(default, skip_serializing_if = "Option::is_none")]
6383 pub hidden: Option<bool>,
6384 pub options: Vec<FieldsOptions2>,
6385}
6386
6387#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6388#[serde(transparent)]
6389pub struct ClientErrorType(pub String);
6390
6391impl ClientErrorType {
6392 pub const ERROR: &'static str = "error";
6393}
6394
6395#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6396#[serde(transparent)]
6397pub struct ClientErrorCode(pub String);
6398
6399impl ClientErrorCode {
6400 pub const CREATED: &'static str = "created";
6401 pub const ACCEPTED: &'static str = "accepted";
6402 pub const NO_CONTENT: &'static str = "no_content";
6403 pub const REDIRECT: &'static str = "redirect";
6404 pub const NOT_MODIFIED: &'static str = "not_modified";
6405 pub const BAD_REQUEST: &'static str = "bad_request";
6406 pub const UNAUTHORIZED: &'static str = "unauthorized";
6407 pub const FORBIDDEN: &'static str = "forbidden";
6408 pub const NOT_FOUND: &'static str = "not_found";
6409 pub const METHOD_NOT_ALLOWED: &'static str = "method_not_allowed";
6410 pub const CONFLICT: &'static str = "conflict";
6411 pub const PRECONDITION_FAILED: &'static str = "precondition_failed";
6412 pub const TOO_MANY_REQUESTS: &'static str = "too_many_requests";
6413 pub const INTERNAL_SERVER_ERROR: &'static str = "internal_server_error";
6414 pub const UNAVAILABLE: &'static str = "unavailable";
6415 pub const ITEM_NAME_INVALID: &'static str = "item_name_invalid";
6416 pub const INSUFFICIENT_SCOPE: &'static str = "insufficient_scope";
6417}
6418
6419#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6420#[serde(transparent)]
6421pub struct CollaborationType(pub String);
6422
6423impl CollaborationType {
6424 pub const COLLABORATION: &'static str = "collaboration";
6425}
6426
6427#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6428#[serde(transparent)]
6429pub struct CollaborationRole(pub String);
6430
6431impl CollaborationRole {
6432 pub const EDITOR: &'static str = "editor";
6433 pub const VIEWER: &'static str = "viewer";
6434 pub const PREVIEWER: &'static str = "previewer";
6435 pub const UPLOADER: &'static str = "uploader";
6436 pub const PREVIEWER_UPLOADER: &'static str = "previewer uploader";
6437 pub const VIEWER_UPLOADER: &'static str = "viewer uploader";
6438 pub const CO_OWNER: &'static str = "co-owner";
6439 pub const OWNER: &'static str = "owner";
6440}
6441
6442#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6443#[serde(transparent)]
6444pub struct CollaborationStatus(pub String);
6445
6446impl CollaborationStatus {
6447 pub const ACCEPTED: &'static str = "accepted";
6448 pub const PENDING: &'static str = "pending";
6449 pub const REJECTED: &'static str = "rejected";
6450}
6451
6452#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6453pub struct AcceptanceRequirementsStatusTermsOfServiceRequirement {
6454 #[serde(
6455 default,
6456 skip_serializing_if = "Option::is_none",
6457 deserialize_with = "double_option"
6458 )]
6459 pub is_accepted: Option<Option<bool>>,
6460 #[serde(default, skip_serializing_if = "Option::is_none")]
6461 pub terms_of_service: Option<TermsOfServiceBase>,
6462}
6463
6464#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6465pub struct AcceptanceRequirementsStatusStrongPasswordRequirement {
6466 #[serde(default, skip_serializing_if = "Option::is_none")]
6467 pub enterprise_has_strong_password_required_for_external_users: Option<bool>,
6468 #[serde(
6469 default,
6470 skip_serializing_if = "Option::is_none",
6471 deserialize_with = "double_option"
6472 )]
6473 pub user_has_strong_password: Option<Option<bool>>,
6474}
6475
6476#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6477pub struct AcceptanceRequirementsStatusTwoFactorAuthenticationRequirement {
6478 #[serde(default, skip_serializing_if = "Option::is_none")]
6479 pub enterprise_has_two_factor_auth_enabled: Option<bool>,
6480 #[serde(
6481 default,
6482 skip_serializing_if = "Option::is_none",
6483 deserialize_with = "double_option"
6484 )]
6485 pub user_has_two_factor_authentication_enabled: Option<Option<bool>>,
6486}
6487
6488#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6489pub struct CollaborationAcceptanceRequirementsStatus {
6490 #[serde(default, skip_serializing_if = "Option::is_none")]
6491 pub terms_of_service_requirement: Option<AcceptanceRequirementsStatusTermsOfServiceRequirement>,
6492 #[serde(default, skip_serializing_if = "Option::is_none")]
6493 pub strong_password_requirement: Option<AcceptanceRequirementsStatusStrongPasswordRequirement>,
6494 #[serde(default, skip_serializing_if = "Option::is_none")]
6495 pub two_factor_authentication_requirement:
6496 Option<AcceptanceRequirementsStatusTwoFactorAuthenticationRequirement>,
6497}
6498
6499#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6500#[serde(transparent)]
6501pub struct CollaborationAllowlistEntryType(pub String);
6502
6503impl CollaborationAllowlistEntryType {
6504 pub const COLLABORATION_WHITELIST_ENTRY: &'static str = "collaboration_whitelist_entry";
6505}
6506
6507#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6508#[serde(transparent)]
6509pub struct CollaborationAllowlistEntryDirection(pub String);
6510
6511impl CollaborationAllowlistEntryDirection {
6512 pub const INBOUND: &'static str = "inbound";
6513 pub const OUTBOUND: &'static str = "outbound";
6514 pub const BOTH: &'static str = "both";
6515}
6516
6517#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6518#[serde(transparent)]
6519pub struct EnterpriseType(pub String);
6520
6521impl EnterpriseType {
6522 pub const ENTERPRISE: &'static str = "enterprise";
6523}
6524
6525#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6526pub struct CollaborationAllowlistEntryEnterprise {
6527 #[serde(default, skip_serializing_if = "Option::is_none")]
6528 pub id: Option<String>,
6529 #[serde(default, skip_serializing_if = "Option::is_none")]
6530 pub r#type: Option<EnterpriseType>,
6531 #[serde(default, skip_serializing_if = "Option::is_none")]
6532 pub name: Option<String>,
6533}
6534
6535#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6536#[serde(transparent)]
6537pub struct CollaborationAllowlistExemptTargetType(pub String);
6538
6539impl CollaborationAllowlistExemptTargetType {
6540 pub const COLLABORATION_WHITELIST_EXEMPT_TARGET: &'static str =
6541 "collaboration_whitelist_exempt_target";
6542}
6543
6544#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6545#[serde(transparent)]
6546pub struct CollaboratorVariableType(pub String);
6547
6548impl CollaboratorVariableType {
6549 pub const VARIABLE: &'static str = "variable";
6550}
6551
6552#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6553#[serde(transparent)]
6554pub struct CollaboratorVariableVariableType(pub String);
6555
6556impl CollaboratorVariableVariableType {
6557 pub const USER_LIST: &'static str = "user_list";
6558}
6559
6560#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6561#[serde(transparent)]
6562pub struct VariableValueType(pub String);
6563
6564impl VariableValueType {
6565 pub const USER: &'static str = "user";
6566}
6567
6568#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6569pub struct CollaboratorVariableVariableValue {
6570 pub r#type: VariableValueType,
6571 pub id: String,
6572}
6573
6574#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6575#[serde(transparent)]
6576pub struct CollectionType(pub String);
6577
6578impl CollectionType {
6579 pub const COLLECTION: &'static str = "collection";
6580}
6581
6582#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6583#[serde(transparent)]
6584pub struct CollectionName(pub String);
6585
6586impl CollectionName {
6587 pub const FAVORITES: &'static str = "Favorites";
6588}
6589
6590#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6591#[serde(transparent)]
6592pub struct CollectionCollectionType(pub String);
6593
6594impl CollectionCollectionType {
6595 pub const FAVORITES: &'static str = "favorites";
6596}
6597
6598#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6599#[serde(transparent)]
6600pub struct OrderDirection(pub String);
6601
6602impl OrderDirection {
6603 pub const ASC: &'static str = "ASC";
6604 pub const DESC: &'static str = "DESC";
6605}
6606
6607#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6608pub struct CollectionsOrder {
6609 #[serde(default, skip_serializing_if = "Option::is_none")]
6610 pub by: Option<String>,
6611 #[serde(default, skip_serializing_if = "Option::is_none")]
6612 pub direction: Option<OrderDirection>,
6613}
6614
6615#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6616#[serde(transparent)]
6617pub struct CommentType(pub String);
6618
6619impl CommentType {
6620 pub const COMMENT: &'static str = "comment";
6621}
6622
6623#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6624pub struct CommentItem {
6625 #[serde(default, skip_serializing_if = "Option::is_none")]
6626 pub id: Option<String>,
6627 #[serde(default, skip_serializing_if = "Option::is_none")]
6628 pub r#type: Option<String>,
6629}
6630
6631#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6632#[serde(transparent)]
6633pub struct CompletionRuleVariableVariableType(pub String);
6634
6635impl CompletionRuleVariableVariableType {
6636 pub const TASK_COMPLETION_RULE: &'static str = "task_completion_rule";
6637}
6638
6639#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6640#[serde(transparent)]
6641pub struct CompletionRuleVariableVariableValue(pub String);
6642
6643impl CompletionRuleVariableVariableValue {
6644 pub const ALL_ASSIGNEES: &'static str = "all_assignees";
6645 pub const ANY_ASSIGNEES: &'static str = "any_assignees";
6646}
6647
6648#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6649pub struct ConflictErrorContextInfo {
6650 #[serde(default, skip_serializing_if = "Option::is_none")]
6651 pub conflicts: Option<Vec<FileConflict>>,
6652}
6653
6654#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6655#[serde(transparent)]
6656pub struct DevicePinnerType(pub String);
6657
6658impl DevicePinnerType {
6659 pub const DEVICE_PINNER: &'static str = "device_pinner";
6660}
6661
6662#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6663#[serde(transparent)]
6664pub struct OrderBy(pub String);
6665
6666impl OrderBy {
6667 pub const ID: &'static str = "id";
6668}
6669
6670#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6671#[serde(transparent)]
6672pub struct OrderDirection2(pub String);
6673
6674impl OrderDirection2 {
6675 pub const ASC: &'static str = "asc";
6676 pub const DESC: &'static str = "desc";
6677}
6678
6679#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6680pub struct DevicePinnersOrder {
6681 #[serde(default, skip_serializing_if = "Option::is_none")]
6682 pub by: Option<OrderBy>,
6683 #[serde(default, skip_serializing_if = "Option::is_none")]
6684 pub direction: Option<OrderDirection2>,
6685}
6686
6687#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6688#[serde(transparent)]
6689pub struct EmailAliasType(pub String);
6690
6691impl EmailAliasType {
6692 pub const EMAIL_ALIAS: &'static str = "email_alias";
6693}
6694
6695#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6696#[serde(transparent)]
6697pub struct EventEventType(pub String);
6698
6699impl EventEventType {
6700 pub const ACCESS_GRANTED: &'static str = "ACCESS_GRANTED";
6701 pub const ACCESS_REVOKED: &'static str = "ACCESS_REVOKED";
6702 pub const ADD_DEVICE_ASSOCIATION: &'static str = "ADD_DEVICE_ASSOCIATION";
6703 pub const ADD_LOGIN_ACTIVITY_DEVICE: &'static str = "ADD_LOGIN_ACTIVITY_DEVICE";
6704 pub const ADMIN_LOGIN: &'static str = "ADMIN_LOGIN";
6705 pub const ADVANCED_FOLDER_SETTINGS_UPDATE: &'static str = "ADVANCED_FOLDER_SETTINGS_UPDATE";
6706 pub const AI_SECURITY_DETECTION: &'static str = "AI_SECURITY_DETECTION";
6707 pub const ANNOTATIONV2_CREATE: &'static str = "ANNOTATIONV2_CREATE";
6708 pub const ANNOTATIONV2_DELETE: &'static str = "ANNOTATIONV2_DELETE";
6709 pub const ANNOTATIONV2_EDIT: &'static str = "ANNOTATIONV2_EDIT";
6710 pub const APPLICATION_CREATED: &'static str = "APPLICATION_CREATED";
6711 pub const APPLICATION_PUBLIC_KEY_ADDED: &'static str = "APPLICATION_PUBLIC_KEY_ADDED";
6712 pub const APPLICATION_PUBLIC_KEY_DELETED: &'static str = "APPLICATION_PUBLIC_KEY_DELETED";
6713 pub const BOX_AI_USER_FAILED_REQUEST: &'static str = "BOX_AI_USER_FAILED_REQUEST";
6714 pub const BOX_AI_USER_REQUEST: &'static str = "BOX_AI_USER_REQUEST";
6715 pub const CHANGE_ADMIN_ROLE: &'static str = "CHANGE_ADMIN_ROLE";
6716 pub const CHANGE_FOLDER_PERMISSION: &'static str = "CHANGE_FOLDER_PERMISSION";
6717 pub const COLLABORATION_ACCEPT: &'static str = "COLLABORATION_ACCEPT";
6718 pub const COLLABORATION_EXPIRATION: &'static str = "COLLABORATION_EXPIRATION";
6719 pub const COLLABORATION_INVITE: &'static str = "COLLABORATION_INVITE";
6720 pub const COLLABORATION_REMOVE: &'static str = "COLLABORATION_REMOVE";
6721 pub const COLLABORATION_ROLE_CHANGE: &'static str = "COLLABORATION_ROLE_CHANGE";
6722 pub const COLLAB_ADD_COLLABORATOR: &'static str = "COLLAB_ADD_COLLABORATOR";
6723 pub const COLLAB_INVITE_COLLABORATOR: &'static str = "COLLAB_INVITE_COLLABORATOR";
6724 pub const COLLAB_REMOVE_COLLABORATOR: &'static str = "COLLAB_REMOVE_COLLABORATOR";
6725 pub const COLLAB_ROLE_CHANGE: &'static str = "COLLAB_ROLE_CHANGE";
6726 pub const COLLECTION_CREATE: &'static str = "COLLECTION_CREATE";
6727 pub const COLLECTION_DELETE: &'static str = "COLLECTION_DELETE";
6728 pub const COLLECTION_ITEM_CREATE: &'static str = "COLLECTION_ITEM_CREATE";
6729 pub const COLLECTION_ITEM_DELETE: &'static str = "COLLECTION_ITEM_DELETE";
6730 pub const COLLECTION_ITEM_UPDATE: &'static str = "COLLECTION_ITEM_UPDATE";
6731 pub const COLLECTION_UPDATE: &'static str = "COLLECTION_UPDATE";
6732 pub const COMMENT_CREATE: &'static str = "COMMENT_CREATE";
6733 pub const COMMENT_DELETE: &'static str = "COMMENT_DELETE";
6734 pub const COMMENT_EDIT: &'static str = "COMMENT_EDIT";
6735 pub const CONTENT_ACCESS: &'static str = "CONTENT_ACCESS";
6736 pub const CONTENT_RECOVERY_REPORT_CREATE: &'static str = "CONTENT_RECOVERY_REPORT_CREATE";
6737 pub const CONTENT_RECOVERY_REPORT_DELETE: &'static str = "CONTENT_RECOVERY_REPORT_DELETE";
6738 pub const CONTENT_RECOVERY_REPORT_INITIATE: &'static str = "CONTENT_RECOVERY_REPORT_INITIATE";
6739 pub const CONTENT_WORKFLOW_ABNORMAL_DOWNLOAD_ACTIVITY: &'static str =
6740 "CONTENT_WORKFLOW_ABNORMAL_DOWNLOAD_ACTIVITY";
6741 pub const CONTENT_WORKFLOW_AUTOMATION_ADD: &'static str = "CONTENT_WORKFLOW_AUTOMATION_ADD";
6742 pub const CONTENT_WORKFLOW_AUTOMATION_DELETE: &'static str =
6743 "CONTENT_WORKFLOW_AUTOMATION_DELETE";
6744 pub const CONTENT_WORKFLOW_POLICY_ADD: &'static str = "CONTENT_WORKFLOW_POLICY_ADD";
6745 pub const CONTENT_WORKFLOW_SHARING_POLICY_VIOLATION: &'static str =
6746 "CONTENT_WORKFLOW_SHARING_POLICY_VIOLATION";
6747 pub const CONTENT_WORKFLOW_UPLOAD_POLICY_VIOLATION: &'static str =
6748 "CONTENT_WORKFLOW_UPLOAD_POLICY_VIOLATION";
6749 pub const COPY: &'static str = "COPY";
6750 pub const DATA_RETENTION_CREATE_RETENTION: &'static str = "DATA_RETENTION_CREATE_RETENTION";
6751 pub const DATA_RETENTION_REMOVE_RETENTION: &'static str = "DATA_RETENTION_REMOVE_RETENTION";
6752 pub const DELETE: &'static str = "DELETE";
6753 pub const DELETE_USER: &'static str = "DELETE_USER";
6754 pub const DEVICE_TRUST_CHECK_FAILED: &'static str = "DEVICE_TRUST_CHECK_FAILED";
6755 pub const DISABLE_MULTI_FACTOR_AUTH: &'static str = "DISABLE_MULTI_FACTOR_AUTH";
6756 pub const DOWNLOAD: &'static str = "DOWNLOAD";
6757 pub const EDIT: &'static str = "EDIT";
6758 pub const EDIT_USER: &'static str = "EDIT_USER";
6759 pub const EDR_CROWDSTRIKE_ACCESS_ALLOWED_NO_CROWDSTRIKE_DEVICE: &'static str =
6760 "EDR_CROWDSTRIKE_ACCESS_ALLOWED_NO_CROWDSTRIKE_DEVICE";
6761 pub const EDR_CROWDSTRIKE_ACCESS_REVOKED: &'static str = "EDR_CROWDSTRIKE_ACCESS_REVOKED";
6762 pub const EDR_CROWDSTRIKE_BOX_TOOLS_OUTDATED: &'static str =
6763 "EDR_CROWDSTRIKE_BOX_TOOLS_OUTDATED";
6764 pub const EDR_CROWDSTRIKE_DEVICE_DETECTED: &'static str = "EDR_CROWDSTRIKE_DEVICE_DETECTED";
6765 pub const EDR_CROWDSTRIKE_DRIVE_OUTDATED: &'static str = "EDR_CROWDSTRIKE_DRIVE_OUTDATED";
6766 pub const EDR_CROWDSTRIKE_NO_BOX_TOOLS: &'static str = "EDR_CROWDSTRIKE_NO_BOX_TOOLS";
6767 pub const EMAIL_ALIAS_CONFIRM: &'static str = "EMAIL_ALIAS_CONFIRM";
6768 pub const EMAIL_ALIAS_PRIMARY: &'static str = "EMAIL_ALIAS_PRIMARY";
6769 pub const EMAIL_ALIAS_REMOVE: &'static str = "EMAIL_ALIAS_REMOVE";
6770 pub const EMAIL_UPLOAD_DISABLED: &'static str = "EMAIL_UPLOAD_DISABLED";
6771 pub const EMAIL_UPLOAD_ENABLED: &'static str = "EMAIL_UPLOAD_ENABLED";
6772 pub const ENABLE_MULTI_FACTOR_AUTH: &'static str = "ENABLE_MULTI_FACTOR_AUTH";
6773 pub const ENABLE_TWO_FACTOR_AUTH: &'static str = "ENABLE_TWO_FACTOR_AUTH";
6774 pub const ENTERPRISE_APP_AUTHORIZATION_UPDATE: &'static str =
6775 "ENTERPRISE_APP_AUTHORIZATION_UPDATE";
6776 pub const EXTERNAL_COLLAB_SECURITY_SETTINGS: &'static str = "EXTERNAL_COLLAB_SECURITY_SETTINGS";
6777 pub const FAILED_LOGIN: &'static str = "FAILED_LOGIN";
6778 pub const FAVORITE: &'static str = "FAVORITE";
6779 pub const FILE_MARKED_MALICIOUS: &'static str = "FILE_MARKED_MALICIOUS";
6780 pub const FILE_REQUEST_CREATE: &'static str = "FILE_REQUEST_CREATE";
6781 pub const FILE_REQUEST_DELETE: &'static str = "FILE_REQUEST_DELETE";
6782 pub const FILE_REQUEST_UPDATE: &'static str = "FILE_REQUEST_UPDATE";
6783 pub const FILE_VERSION_RESTORE: &'static str = "FILE_VERSION_RESTORE";
6784 pub const FILE_WATERMARKED_DOWNLOAD: &'static str = "FILE_WATERMARKED_DOWNLOAD";
6785 pub const GROUP_ADD_ITEM: &'static str = "GROUP_ADD_ITEM";
6786 pub const GROUP_ADD_USER: &'static str = "GROUP_ADD_USER";
6787 pub const GROUP_ADMIN_CREATED: &'static str = "GROUP_ADMIN_CREATED";
6788 pub const GROUP_ADMIN_DELETED: &'static str = "GROUP_ADMIN_DELETED";
6789 pub const GROUP_ADMIN_PERMISSIONS_UPDATED: &'static str = "GROUP_ADMIN_PERMISSIONS_UPDATED";
6790 pub const GROUP_CREATION: &'static str = "GROUP_CREATION";
6791 pub const GROUP_DELETION: &'static str = "GROUP_DELETION";
6792 pub const GROUP_EDITED: &'static str = "GROUP_EDITED";
6793 pub const GROUP_REMOVE_ITEM: &'static str = "GROUP_REMOVE_ITEM";
6794 pub const GROUP_REMOVE_USER: &'static str = "GROUP_REMOVE_USER";
6795 pub const ILLEGAL_ITEM_OWNERSHIP_TRANSFER_BY_USER: &'static str =
6796 "ILLEGAL_ITEM_OWNERSHIP_TRANSFER_BY_USER";
6797 pub const ITEM_ASSOCIATION_CREATED: &'static str = "ITEM_ASSOCIATION_CREATED";
6798 pub const ITEM_ASSOCIATION_DELETED: &'static str = "ITEM_ASSOCIATION_DELETED";
6799 pub const ITEM_ASSOCIATION_UPDATED: &'static str = "ITEM_ASSOCIATION_UPDATED";
6800 pub const ITEM_COPY: &'static str = "ITEM_COPY";
6801 pub const ITEM_CREATE: &'static str = "ITEM_CREATE";
6802 pub const ITEM_DOWNLOAD: &'static str = "ITEM_DOWNLOAD";
6803 pub const ITEM_EMAIL_SEND: &'static str = "ITEM_EMAIL_SEND";
6804 pub const ITEM_MAKE_CURRENT_VERSION: &'static str = "ITEM_MAKE_CURRENT_VERSION";
6805 pub const ITEM_MODIFY: &'static str = "ITEM_MODIFY";
6806 pub const ITEM_MOVE: &'static str = "ITEM_MOVE";
6807 pub const ITEM_OPEN: &'static str = "ITEM_OPEN";
6808 pub const ITEM_PREVIEW: &'static str = "ITEM_PREVIEW";
6809 pub const ITEM_RENAME: &'static str = "ITEM_RENAME";
6810 pub const ITEM_SHARED: &'static str = "ITEM_SHARED";
6811 pub const ITEM_SHARED_CREATE: &'static str = "ITEM_SHARED_CREATE";
6812 pub const ITEM_SHARED_UNSHARE: &'static str = "ITEM_SHARED_UNSHARE";
6813 pub const ITEM_SHARED_UPDATE: &'static str = "ITEM_SHARED_UPDATE";
6814 pub const ITEM_SYNC: &'static str = "ITEM_SYNC";
6815 pub const ITEM_TRASH: &'static str = "ITEM_TRASH";
6816 pub const ITEM_UNDELETE_VIA_TRASH: &'static str = "ITEM_UNDELETE_VIA_TRASH";
6817 pub const ITEM_UNSYNC: &'static str = "ITEM_UNSYNC";
6818 pub const ITEM_UPLOAD: &'static str = "ITEM_UPLOAD";
6819 pub const LEGAL_HOLD_ASSIGNMENT_CREATE: &'static str = "LEGAL_HOLD_ASSIGNMENT_CREATE";
6820 pub const LEGAL_HOLD_ASSIGNMENT_DELETE: &'static str = "LEGAL_HOLD_ASSIGNMENT_DELETE";
6821 pub const LEGAL_HOLD_POLICY_CREATE: &'static str = "LEGAL_HOLD_POLICY_CREATE";
6822 pub const LEGAL_HOLD_POLICY_DELETE: &'static str = "LEGAL_HOLD_POLICY_DELETE";
6823 pub const LEGAL_HOLD_POLICY_UPDATE: &'static str = "LEGAL_HOLD_POLICY_UPDATE";
6824 pub const LOCK: &'static str = "LOCK";
6825 pub const LOCK_CREATE: &'static str = "LOCK_CREATE";
6826 pub const LOCK_DESTROY: &'static str = "LOCK_DESTROY";
6827 pub const LOGIN: &'static str = "LOGIN";
6828 pub const MASTER_INVITE_ACCEPT: &'static str = "MASTER_INVITE_ACCEPT";
6829 pub const MASTER_INVITE_REJECT: &'static str = "MASTER_INVITE_REJECT";
6830 pub const METADATA_CASCADE_POLICY_APPLY: &'static str = "METADATA_CASCADE_POLICY_APPLY";
6831 pub const METADATA_CASCADE_POLICY_CREATE: &'static str = "METADATA_CASCADE_POLICY_CREATE";
6832 pub const METADATA_INSTANCE_COPY: &'static str = "METADATA_INSTANCE_COPY";
6833 pub const METADATA_INSTANCE_CREATE: &'static str = "METADATA_INSTANCE_CREATE";
6834 pub const METADATA_INSTANCE_DELETE: &'static str = "METADATA_INSTANCE_DELETE";
6835 pub const METADATA_INSTANCE_UPDATE: &'static str = "METADATA_INSTANCE_UPDATE";
6836 pub const METADATA_TEMPLATE_CREATE: &'static str = "METADATA_TEMPLATE_CREATE";
6837 pub const METADATA_TEMPLATE_DELETE: &'static str = "METADATA_TEMPLATE_DELETE";
6838 pub const METADATA_TEMPLATE_UPDATE: &'static str = "METADATA_TEMPLATE_UPDATE";
6839 pub const MOVE: &'static str = "MOVE";
6840 pub const NEW_USER: &'static str = "NEW_USER";
6841 pub const OAUTH2_ACCESS_TOKEN_REVOKE: &'static str = "OAUTH2_ACCESS_TOKEN_REVOKE";
6842 pub const OAUTH2_REFRESH_TOKEN_REVOKE: &'static str = "OAUTH2_REFRESH_TOKEN_REVOKE";
6843 pub const PREVIEW: &'static str = "PREVIEW";
6844 pub const REMOVE_DEVICE_ASSOCIATION: &'static str = "REMOVE_DEVICE_ASSOCIATION";
6845 pub const REMOVE_LOGIN_ACTIVITY_DEVICE: &'static str = "REMOVE_LOGIN_ACTIVITY_DEVICE";
6846 pub const RENAME: &'static str = "RENAME";
6847 pub const RETENTION_POLICY_ASSIGNMENT_ADD: &'static str = "RETENTION_POLICY_ASSIGNMENT_ADD";
6848 pub const SHARE: &'static str = "SHARE";
6849 pub const SHARED_LINK_REDIRECT_OUT_OF_SHARED_CONTEXT: &'static str =
6850 "SHARED_LINK_REDIRECT_OUT_OF_SHARED_CONTEXT";
6851 pub const SHARED_LINK_SEND: &'static str = "SHARED_LINK_SEND";
6852 pub const SHARE_EXPIRATION: &'static str = "SHARE_EXPIRATION";
6853 pub const SHIELD_ACCESS_POLICY_CREATED: &'static str = "SHIELD_ACCESS_POLICY_CREATED";
6854 pub const SHIELD_ACCESS_POLICY_DELETED: &'static str = "SHIELD_ACCESS_POLICY_DELETED";
6855 pub const SHIELD_ACCESS_POLICY_UPDATED: &'static str = "SHIELD_ACCESS_POLICY_UPDATED";
6856 pub const SHIELD_ALERT: &'static str = "SHIELD_ALERT";
6857 pub const SHIELD_DOWNLOAD_BLOCKED: &'static str = "SHIELD_DOWNLOAD_BLOCKED";
6858 pub const SHIELD_EXTERNAL_COLLAB_ACCESS_BLOCKED: &'static str =
6859 "SHIELD_EXTERNAL_COLLAB_ACCESS_BLOCKED";
6860 pub const SHIELD_EXTERNAL_COLLAB_ACCESS_BLOCKED_MISSING_JUSTIFICATION: &'static str =
6861 "SHIELD_EXTERNAL_COLLAB_ACCESS_BLOCKED_MISSING_JUSTIFICATION";
6862 pub const SHIELD_EXTERNAL_COLLAB_INVITE_BLOCKED: &'static str =
6863 "SHIELD_EXTERNAL_COLLAB_INVITE_BLOCKED";
6864 pub const SHIELD_EXTERNAL_COLLAB_INVITE_BLOCKED_MISSING_JUSTIFICATION: &'static str =
6865 "SHIELD_EXTERNAL_COLLAB_INVITE_BLOCKED_MISSING_JUSTIFICATION";
6866 pub const SHIELD_EXTERNAL_COLLAB_INVITE_JUSTIFIED: &'static str =
6867 "SHIELD_EXTERNAL_COLLAB_INVITE_JUSTIFIED";
6868 pub const SHIELD_INFORMATION_BARRIER_COLLAB_BLOCKED: &'static str =
6869 "SHIELD_INFORMATION_BARRIER_COLLAB_BLOCKED";
6870 pub const SHIELD_INFORMATION_BARRIER_DISABLED: &'static str =
6871 "SHIELD_INFORMATION_BARRIER_DISABLED";
6872 pub const SHIELD_INFORMATION_BARRIER_ENABLED: &'static str =
6873 "SHIELD_INFORMATION_BARRIER_ENABLED";
6874 pub const SHIELD_INFORMATION_BARRIER_GROUP_ADD_USER_BLOCKED: &'static str =
6875 "SHIELD_INFORMATION_BARRIER_GROUP_ADD_USER_BLOCKED";
6876 pub const SHIELD_INFORMATION_BARRIER_ITEM_COPY_BLOCKED: &'static str =
6877 "SHIELD_INFORMATION_BARRIER_ITEM_COPY_BLOCKED";
6878 pub const SHIELD_INFORMATION_BARRIER_ITEM_MOVE_BLOCKED: &'static str =
6879 "SHIELD_INFORMATION_BARRIER_ITEM_MOVE_BLOCKED";
6880 pub const SHIELD_INFORMATION_BARRIER_ITEM_OWNER_TRANSFER_BLOCKED: &'static str =
6881 "SHIELD_INFORMATION_BARRIER_ITEM_OWNER_TRANSFER_BLOCKED";
6882 pub const SHIELD_INFORMATION_BARRIER_PENDING: &'static str =
6883 "SHIELD_INFORMATION_BARRIER_PENDING";
6884 pub const SHIELD_INFORMATION_BARRIER_SHARED_ITEM_ACCESS_BLOCKED: &'static str =
6885 "SHIELD_INFORMATION_BARRIER_SHARED_ITEM_ACCESS_BLOCKED";
6886 pub const SHIELD_JUSTIFICATION_APPROVAL: &'static str = "SHIELD_JUSTIFICATION_APPROVAL";
6887 pub const SHIELD_SHARED_LINK_ACCESS_BLOCKED: &'static str = "SHIELD_SHARED_LINK_ACCESS_BLOCKED";
6888 pub const SHIELD_SHARED_LINK_STATUS_RESTRICTED_ON_CREATE: &'static str =
6889 "SHIELD_SHARED_LINK_STATUS_RESTRICTED_ON_CREATE";
6890 pub const SHIELD_SHARED_LINK_STATUS_RESTRICTED_ON_UPDATE: &'static str =
6891 "SHIELD_SHARED_LINK_STATUS_RESTRICTED_ON_UPDATE";
6892 pub const SIGN_DOCUMENT_ASSIGNED: &'static str = "SIGN_DOCUMENT_ASSIGNED";
6893 pub const SIGN_DOCUMENT_CANCELLED: &'static str = "SIGN_DOCUMENT_CANCELLED";
6894 pub const SIGN_DOCUMENT_COMPLETED: &'static str = "SIGN_DOCUMENT_COMPLETED";
6895 pub const SIGN_DOCUMENT_CONVERTED: &'static str = "SIGN_DOCUMENT_CONVERTED";
6896 pub const SIGN_DOCUMENT_CREATED: &'static str = "SIGN_DOCUMENT_CREATED";
6897 pub const SIGN_DOCUMENT_DECLINED: &'static str = "SIGN_DOCUMENT_DECLINED";
6898 pub const SIGN_DOCUMENT_EXPIRED: &'static str = "SIGN_DOCUMENT_EXPIRED";
6899 pub const SIGN_DOCUMENT_SIGNED: &'static str = "SIGN_DOCUMENT_SIGNED";
6900 pub const SIGN_DOCUMENT_VIEWED_BY_SIGNED: &'static str = "SIGN_DOCUMENT_VIEWED_BY_SIGNED";
6901 pub const SIGN_DOCUMENT_VIEWED_BY_SIGNER: &'static str = "SIGN_DOCUMENT_VIEWED_BY_SIGNER";
6902 pub const SIGNER_DOWNLOADED: &'static str = "SIGNER_DOWNLOADED";
6903 pub const SIGNER_FORWARDED: &'static str = "SIGNER_FORWARDED";
6904 pub const STORAGE_EXPIRATION: &'static str = "STORAGE_EXPIRATION";
6905 pub const TAG_ITEM_CREATE: &'static str = "TAG_ITEM_CREATE";
6906 pub const TASK_ASSIGNMENT_CREATE: &'static str = "TASK_ASSIGNMENT_CREATE";
6907 pub const TASK_ASSIGNMENT_DELETE: &'static str = "TASK_ASSIGNMENT_DELETE";
6908 pub const TASK_ASSIGNMENT_UPDATE: &'static str = "TASK_ASSIGNMENT_UPDATE";
6909 pub const TASK_CREATE: &'static str = "TASK_CREATE";
6910 pub const TASK_UPDATE: &'static str = "TASK_UPDATE";
6911 pub const TERMS_OF_SERVICE_ACCEPT: &'static str = "TERMS_OF_SERVICE_ACCEPT";
6912 pub const TERMS_OF_SERVICE_REJECT: &'static str = "TERMS_OF_SERVICE_REJECT";
6913 pub const UNDELETE: &'static str = "UNDELETE";
6914 pub const UNFAVORITE: &'static str = "UNFAVORITE";
6915 pub const UNLOCK: &'static str = "UNLOCK";
6916 pub const UNSHARE: &'static str = "UNSHARE";
6917 pub const UPDATE_COLLABORATION_EXPIRATION: &'static str = "UPDATE_COLLABORATION_EXPIRATION";
6918 pub const UPDATE_SHARE_EXPIRATION: &'static str = "UPDATE_SHARE_EXPIRATION";
6919 pub const UPLOAD: &'static str = "UPLOAD";
6920 pub const USER_AUTHENTICATE_OAUTH2_ACCESS_TOKEN_CREATE: &'static str =
6921 "USER_AUTHENTICATE_OAUTH2_ACCESS_TOKEN_CREATE";
6922 pub const WATERMARK_LABEL_CREATE: &'static str = "WATERMARK_LABEL_CREATE";
6923 pub const WATERMARK_LABEL_DELETE: &'static str = "WATERMARK_LABEL_DELETE";
6924 pub const WORKFLOW_AUTOMATION_CREATE: &'static str = "WORKFLOW_AUTOMATION_CREATE";
6925 pub const WORKFLOW_AUTOMATION_DELETE: &'static str = "WORKFLOW_AUTOMATION_DELETE";
6926 pub const WORKFLOW_AUTOMATION_UPDATE: &'static str = "WORKFLOW_AUTOMATION_UPDATE";
6927}
6928
6929#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6930#[serde(transparent)]
6931pub struct EventsNextStreamPosition(pub serde_json::Value);
6932
6933#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6934#[serde(transparent)]
6935pub struct EventSourceItemType(pub String);
6936
6937impl EventSourceItemType {
6938 pub const FILE: &'static str = "file";
6939 pub const FOLDER: &'static str = "folder";
6940}
6941
6942#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6943pub struct EventSourceClassification {
6944 #[serde(default, skip_serializing_if = "Option::is_none")]
6945 pub name: Option<String>,
6946}
6947
6948#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6949pub struct FilePathCollection {
6950 pub total_count: i64,
6951 pub entries: Vec<FolderMini>,
6952}
6953
6954#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6955#[serde(transparent)]
6956pub struct SharedLinkAccess(pub String);
6957
6958impl SharedLinkAccess {
6959 pub const OPEN: &'static str = "open";
6960 pub const COMPANY: &'static str = "company";
6961 pub const COLLABORATORS: &'static str = "collaborators";
6962}
6963
6964#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6965#[serde(transparent)]
6966pub struct SharedLinkEffectivePermission(pub String);
6967
6968impl SharedLinkEffectivePermission {
6969 pub const CAN_EDIT: &'static str = "can_edit";
6970 pub const CAN_DOWNLOAD: &'static str = "can_download";
6971 pub const CAN_PREVIEW: &'static str = "can_preview";
6972 pub const NO_ACCESS: &'static str = "no_access";
6973}
6974
6975#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
6976pub struct SharedLinkPermissions {
6977 #[serde(default, skip_serializing_if = "Option::is_none")]
6978 pub can_download: Option<bool>,
6979 #[serde(default, skip_serializing_if = "Option::is_none")]
6980 pub can_preview: Option<bool>,
6981 #[serde(default, skip_serializing_if = "Option::is_none")]
6982 pub can_edit: Option<bool>,
6983 #[serde(
6984 default,
6985 skip_serializing_if = "Option::is_none",
6986 deserialize_with = "double_option"
6987 )]
6988 pub shared_links_option: Option<Option<String>>,
6989 #[serde(
6990 default,
6991 skip_serializing_if = "Option::is_none",
6992 deserialize_with = "double_option"
6993 )]
6994 pub default_shared_link_type: Option<Option<String>>,
6995 #[serde(
6996 default,
6997 skip_serializing_if = "Option::is_none",
6998 deserialize_with = "double_option"
6999 )]
7000 pub notes_shared_link_option: Option<Option<String>>,
7001 #[serde(
7002 default,
7003 skip_serializing_if = "Option::is_none",
7004 deserialize_with = "double_option"
7005 )]
7006 pub default_notes_shared_link_type: Option<Option<String>>,
7007}
7008
7009#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7010pub struct FileSharedLink {
7011 pub url: String,
7012 #[serde(
7013 default,
7014 skip_serializing_if = "Option::is_none",
7015 deserialize_with = "double_option"
7016 )]
7017 pub download_url: Option<Option<String>>,
7018 #[serde(
7019 default,
7020 skip_serializing_if = "Option::is_none",
7021 deserialize_with = "double_option"
7022 )]
7023 pub vanity_url: Option<Option<String>>,
7024 #[serde(
7025 default,
7026 skip_serializing_if = "Option::is_none",
7027 deserialize_with = "double_option"
7028 )]
7029 pub vanity_name: Option<Option<String>>,
7030 #[serde(default, skip_serializing_if = "Option::is_none")]
7031 pub access: Option<SharedLinkAccess>,
7032 pub effective_access: SharedLinkAccess,
7033 pub effective_permission: SharedLinkEffectivePermission,
7034 #[serde(
7035 default,
7036 skip_serializing_if = "Option::is_none",
7037 deserialize_with = "double_option"
7038 )]
7039 pub unshared_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
7040 pub is_password_enabled: bool,
7041 #[serde(default, skip_serializing_if = "Option::is_none")]
7042 pub permissions: Option<SharedLinkPermissions>,
7043 pub download_count: i64,
7044 pub preview_count: i64,
7045}
7046
7047#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7048#[serde(transparent)]
7049pub struct FileItemStatus(pub String);
7050
7051impl FileItemStatus {
7052 pub const ACTIVE: &'static str = "active";
7053 pub const TRASHED: &'static str = "trashed";
7054 pub const DELETED: &'static str = "deleted";
7055}
7056
7057#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7058pub struct FileFullPermissions {
7059 pub can_delete: bool,
7060 pub can_download: bool,
7061 pub can_invite_collaborator: bool,
7062 pub can_rename: bool,
7063 pub can_set_share_access: bool,
7064 pub can_share: bool,
7065 pub can_annotate: bool,
7066 pub can_comment: bool,
7067 pub can_preview: bool,
7068 pub can_upload: bool,
7069 pub can_view_annotations_all: bool,
7070 pub can_view_annotations_self: bool,
7071 #[serde(default, skip_serializing_if = "Option::is_none")]
7072 pub can_apply_watermark: Option<bool>,
7073}
7074
7075#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7076#[serde(transparent)]
7077pub struct LockType(pub String);
7078
7079impl LockType {
7080 pub const LOCK: &'static str = "lock";
7081}
7082
7083#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7084#[serde(transparent)]
7085pub struct LockAppType(pub String);
7086
7087impl LockAppType {
7088 pub const GSUITE: &'static str = "gsuite";
7089 pub const OFFICE_WOPI: &'static str = "office_wopi";
7090 pub const OFFICE_WOPIPLUS: &'static str = "office_wopiplus";
7091 pub const OTHER: &'static str = "other";
7092}
7093
7094#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7095pub struct FileFullLock {
7096 #[serde(default, skip_serializing_if = "Option::is_none")]
7097 pub id: Option<String>,
7098 #[serde(default, skip_serializing_if = "Option::is_none")]
7099 pub r#type: Option<LockType>,
7100 #[serde(default, skip_serializing_if = "Option::is_none")]
7101 pub created_by: Option<UserMini>,
7102 #[serde(default, skip_serializing_if = "Option::is_none")]
7103 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
7104 #[serde(default, skip_serializing_if = "Option::is_none")]
7105 pub expired_at: Option<chrono::DateTime<chrono::Utc>>,
7106 #[serde(default, skip_serializing_if = "Option::is_none")]
7107 pub is_download_prevented: Option<bool>,
7108 #[serde(
7109 default,
7110 skip_serializing_if = "Option::is_none",
7111 deserialize_with = "double_option"
7112 )]
7113 pub app_type: Option<Option<LockAppType>>,
7114}
7115
7116#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7117pub struct FileFullExpiringEmbedLink {
7118 #[serde(default, skip_serializing_if = "Option::is_none")]
7119 pub access_token: Option<String>,
7120 #[serde(default, skip_serializing_if = "Option::is_none")]
7121 pub expires_in: Option<i64>,
7122 #[serde(default, skip_serializing_if = "Option::is_none")]
7123 pub token_type: Option<AccessTokenTokenType>,
7124 #[serde(default, skip_serializing_if = "Option::is_none")]
7125 pub restricted_to: Option<Vec<ResourceScope>>,
7126 #[serde(default, skip_serializing_if = "Option::is_none")]
7127 pub url: Option<String>,
7128}
7129
7130#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7131pub struct FileFullWatermarkInfo {
7132 #[serde(default, skip_serializing_if = "Option::is_none")]
7133 pub is_watermarked: Option<bool>,
7134 #[serde(default, skip_serializing_if = "Option::is_none")]
7135 pub is_watermark_inherited: Option<bool>,
7136 #[serde(default, skip_serializing_if = "Option::is_none")]
7137 pub is_watermarked_by_access_policy: Option<bool>,
7138}
7139
7140#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7141#[serde(transparent)]
7142pub struct FileFullAllowedInviteeRoles(pub String);
7143
7144impl FileFullAllowedInviteeRoles {
7145 pub const EDITOR: &'static str = "editor";
7146 pub const VIEWER: &'static str = "viewer";
7147 pub const PREVIEWER: &'static str = "previewer";
7148 pub const UPLOADER: &'static str = "uploader";
7149 pub const PREVIEWER_UPLOADER: &'static str = "previewer uploader";
7150 pub const VIEWER_UPLOADER: &'static str = "viewer uploader";
7151 pub const CO_OWNER: &'static str = "co-owner";
7152}
7153
7154#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7155pub struct EntriesContent {
7156 #[serde(default, skip_serializing_if = "Option::is_none")]
7157 pub url_template: Option<String>,
7158}
7159
7160#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7161pub struct EntriesInfo {
7162 #[serde(default, skip_serializing_if = "Option::is_none")]
7163 pub url: Option<String>,
7164}
7165
7166#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7167pub struct EntriesProperties {
7168 #[serde(default, skip_serializing_if = "Option::is_none")]
7169 pub dimensions: Option<String>,
7170 #[serde(default, skip_serializing_if = "Option::is_none")]
7171 pub paged: Option<String>,
7172 #[serde(default, skip_serializing_if = "Option::is_none")]
7173 pub thumb: Option<String>,
7174}
7175
7176#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7177#[serde(transparent)]
7178pub struct StatusState(pub String);
7179
7180impl StatusState {
7181 pub const SUCCESS: &'static str = "success";
7182 pub const VIEWABLE: &'static str = "viewable";
7183 pub const PENDING: &'static str = "pending";
7184 pub const NONE: &'static str = "none";
7185}
7186
7187#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7188pub struct EntriesStatus {
7189 #[serde(default, skip_serializing_if = "Option::is_none")]
7190 pub state: Option<StatusState>,
7191}
7192
7193#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7194pub struct RepresentationsEntries {
7195 #[serde(default, skip_serializing_if = "Option::is_none")]
7196 pub content: Option<EntriesContent>,
7197 #[serde(default, skip_serializing_if = "Option::is_none")]
7198 pub info: Option<EntriesInfo>,
7199 #[serde(default, skip_serializing_if = "Option::is_none")]
7200 pub properties: Option<EntriesProperties>,
7201 #[serde(default, skip_serializing_if = "Option::is_none")]
7202 pub representation: Option<String>,
7203 #[serde(default, skip_serializing_if = "Option::is_none")]
7204 pub status: Option<EntriesStatus>,
7205}
7206
7207#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7208pub struct FileFullRepresentations {
7209 #[serde(default, skip_serializing_if = "Option::is_none")]
7210 pub entries: Option<Vec<RepresentationsEntries>>,
7211}
7212
7213#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7214pub struct FileFullClassification {
7215 #[serde(default, skip_serializing_if = "Option::is_none")]
7216 pub name: Option<String>,
7217 #[serde(default, skip_serializing_if = "Option::is_none")]
7218 pub definition: Option<String>,
7219 #[serde(default, skip_serializing_if = "Option::is_none")]
7220 pub color: Option<String>,
7221}
7222
7223#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7224#[serde(transparent)]
7225pub struct FileFullSharedLinkPermissionOptions(pub String);
7226
7227impl FileFullSharedLinkPermissionOptions {
7228 pub const CAN_PREVIEW: &'static str = "can_preview";
7229 pub const CAN_DOWNLOAD: &'static str = "can_download";
7230 pub const CAN_EDIT: &'static str = "can_edit";
7231}
7232
7233#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7234#[serde(transparent)]
7235pub struct FileRequestType(pub String);
7236
7237impl FileRequestType {
7238 pub const FILE_REQUEST: &'static str = "file_request";
7239}
7240
7241#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7242#[serde(transparent)]
7243pub struct FileRequestStatus(pub String);
7244
7245impl FileRequestStatus {
7246 pub const ACTIVE: &'static str = "active";
7247 pub const INACTIVE: &'static str = "inactive";
7248}
7249
7250#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7251#[serde(transparent)]
7252pub struct FolderType(pub String);
7253
7254impl FolderType {
7255 pub const FOLDER: &'static str = "folder";
7256}
7257
7258#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7259pub struct FileRequestCopyRequestFolder {
7260 #[serde(default, skip_serializing_if = "Option::is_none")]
7261 pub r#type: Option<FolderType>,
7262 pub id: String,
7263}
7264
7265#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7266#[serde(transparent)]
7267pub struct FileVersionType(pub String);
7268
7269impl FileVersionType {
7270 pub const FILE_VERSION: &'static str = "file_version";
7271}
7272
7273#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7274#[serde(transparent)]
7275pub struct FileVersionLegalHoldType(pub String);
7276
7277impl FileVersionLegalHoldType {
7278 pub const FILE_VERSION_LEGAL_HOLD: &'static str = "file_version_legal_hold";
7279}
7280
7281#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7282#[serde(transparent)]
7283pub struct FileVersionRetentionType(pub String);
7284
7285impl FileVersionRetentionType {
7286 pub const FILE_VERSION_RETENTION: &'static str = "file_version_retention";
7287}
7288
7289#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7290#[serde(transparent)]
7291pub struct FolderUploadEmailAccess(pub String);
7292
7293impl FolderUploadEmailAccess {
7294 pub const OPEN: &'static str = "open";
7295 pub const COLLABORATORS: &'static str = "collaborators";
7296}
7297
7298#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7299pub struct FolderFolderUploadEmail {
7300 #[serde(default, skip_serializing_if = "Option::is_none")]
7301 pub access: Option<FolderUploadEmailAccess>,
7302 #[serde(default, skip_serializing_if = "Option::is_none")]
7303 pub email: Option<String>,
7304}
7305
7306#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7307#[serde(transparent)]
7308pub struct FolderFullSyncState(pub String);
7309
7310impl FolderFullSyncState {
7311 pub const SYNCED: &'static str = "synced";
7312 pub const NOT_SYNCED: &'static str = "not_synced";
7313 pub const PARTIALLY_SYNCED: &'static str = "partially_synced";
7314}
7315
7316#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7317pub struct FolderFullPermissions {
7318 pub can_delete: bool,
7319 pub can_download: bool,
7320 pub can_invite_collaborator: bool,
7321 pub can_rename: bool,
7322 pub can_set_share_access: bool,
7323 pub can_share: bool,
7324 pub can_upload: bool,
7325 #[serde(default, skip_serializing_if = "Option::is_none")]
7326 pub can_apply_watermark: Option<bool>,
7327}
7328
7329#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7330pub struct FolderLockLockedOperations {
7331 pub r#move: bool,
7332 pub delete: bool,
7333}
7334
7335#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7336#[serde(transparent)]
7337pub struct GroupType(pub String);
7338
7339impl GroupType {
7340 pub const GROUP: &'static str = "group";
7341}
7342
7343#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7344#[serde(transparent)]
7345pub struct GroupGroupType(pub String);
7346
7347impl GroupGroupType {
7348 pub const MANAGED_GROUP: &'static str = "managed_group";
7349 pub const ALL_USERS_GROUP: &'static str = "all_users_group";
7350}
7351
7352#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7353#[serde(transparent)]
7354pub struct GroupFullInvitabilityLevel(pub String);
7355
7356impl GroupFullInvitabilityLevel {
7357 pub const ADMINS_ONLY: &'static str = "admins_only";
7358 pub const ADMINS_AND_MEMBERS: &'static str = "admins_and_members";
7359 pub const ALL_MANAGED_USERS: &'static str = "all_managed_users";
7360}
7361
7362#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7363pub struct GroupFullPermissions {
7364 #[serde(default, skip_serializing_if = "Option::is_none")]
7365 pub can_invite_as_collaborator: Option<bool>,
7366}
7367
7368#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7369#[serde(transparent)]
7370pub struct GroupMembershipType(pub String);
7371
7372impl GroupMembershipType {
7373 pub const GROUP_MEMBERSHIP: &'static str = "group_membership";
7374}
7375
7376#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7377#[serde(transparent)]
7378pub struct GroupMembershipRole(pub String);
7379
7380impl GroupMembershipRole {
7381 pub const MEMBER: &'static str = "member";
7382 pub const ADMIN: &'static str = "admin";
7383}
7384
7385#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7386#[serde(transparent)]
7387pub struct IntegrationMappingType(pub String);
7388
7389impl IntegrationMappingType {
7390 pub const INTEGRATION_MAPPING: &'static str = "integration_mapping";
7391}
7392
7393#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7394#[serde(transparent)]
7395pub struct IntegrationMappingIntegrationType(pub String);
7396
7397impl IntegrationMappingIntegrationType {
7398 pub const SLACK: &'static str = "slack";
7399}
7400
7401#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7402#[serde(transparent)]
7403pub struct IntegrationMappingPartnerItemSlackType(pub String);
7404
7405impl IntegrationMappingPartnerItemSlackType {
7406 pub const CHANNEL: &'static str = "channel";
7407}
7408
7409#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7410#[serde(transparent)]
7411pub struct IntegrationMappingPartnerItemTeamsType(pub String);
7412
7413impl IntegrationMappingPartnerItemTeamsType {
7414 pub const CHANNEL: &'static str = "channel";
7415 pub const TEAM: &'static str = "team";
7416}
7417
7418#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7419#[serde(transparent)]
7420pub struct IntegrationMappingTeamsIntegrationType(pub String);
7421
7422impl IntegrationMappingTeamsIntegrationType {
7423 pub const TEAMS: &'static str = "teams";
7424}
7425
7426#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7427#[serde(transparent)]
7428pub struct InviteType(pub String);
7429
7430impl InviteType {
7431 pub const INVITE: &'static str = "invite";
7432}
7433
7434#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7435#[serde(transparent)]
7436pub struct KeywordSkillCardType(pub String);
7437
7438impl KeywordSkillCardType {
7439 pub const SKILL_CARD: &'static str = "skill_card";
7440}
7441
7442#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7443#[serde(transparent)]
7444pub struct KeywordSkillCardSkillCardType(pub String);
7445
7446impl KeywordSkillCardSkillCardType {
7447 pub const KEYWORD: &'static str = "keyword";
7448}
7449
7450#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7451pub struct KeywordSkillCardSkillCardTitle {
7452 #[serde(default, skip_serializing_if = "Option::is_none")]
7453 pub code: Option<String>,
7454 pub message: String,
7455}
7456
7457#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7458#[serde(transparent)]
7459pub struct SkillType(pub String);
7460
7461impl SkillType {
7462 pub const SERVICE: &'static str = "service";
7463}
7464
7465#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7466pub struct KeywordSkillCardSkill {
7467 pub r#type: SkillType,
7468 pub id: String,
7469}
7470
7471#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7472#[serde(transparent)]
7473pub struct InvocationType(pub String);
7474
7475impl InvocationType {
7476 pub const SKILL_INVOCATION: &'static str = "skill_invocation";
7477}
7478
7479#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7480pub struct KeywordSkillCardInvocation {
7481 pub r#type: InvocationType,
7482 pub id: String,
7483}
7484
7485#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7486pub struct KeywordSkillCardEntries {
7487 #[serde(default, skip_serializing_if = "Option::is_none")]
7488 pub text: Option<String>,
7489}
7490
7491#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7492#[serde(transparent)]
7493pub struct LegalHoldPolicyType(pub String);
7494
7495impl LegalHoldPolicyType {
7496 pub const LEGAL_HOLD_POLICY: &'static str = "legal_hold_policy";
7497}
7498
7499#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7500#[serde(transparent)]
7501pub struct LegalHoldPolicyStatus(pub String);
7502
7503impl LegalHoldPolicyStatus {
7504 pub const ACTIVE: &'static str = "active";
7505 pub const APPLYING: &'static str = "applying";
7506 pub const RELEASING: &'static str = "releasing";
7507 pub const RELEASED: &'static str = "released";
7508}
7509
7510#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7511pub struct LegalHoldPolicyAssignmentCounts {
7512 #[serde(default, skip_serializing_if = "Option::is_none")]
7513 pub user: Option<i64>,
7514 #[serde(default, skip_serializing_if = "Option::is_none")]
7515 pub folder: Option<i64>,
7516 #[serde(default, skip_serializing_if = "Option::is_none")]
7517 pub file: Option<i64>,
7518 #[serde(default, skip_serializing_if = "Option::is_none")]
7519 pub file_version: Option<i64>,
7520 #[serde(default, skip_serializing_if = "Option::is_none")]
7521 pub ownership: Option<i64>,
7522 #[serde(default, skip_serializing_if = "Option::is_none")]
7523 pub interactions: Option<i64>,
7524}
7525
7526#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7527#[serde(transparent)]
7528pub struct LegalHoldPolicyAssignedItemType(pub String);
7529
7530impl LegalHoldPolicyAssignedItemType {
7531 pub const FILE: &'static str = "file";
7532 pub const FILE_VERSION: &'static str = "file_version";
7533 pub const FOLDER: &'static str = "folder";
7534 pub const USER: &'static str = "user";
7535 pub const OWNERSHIP: &'static str = "ownership";
7536 pub const INTERACTIONS: &'static str = "interactions";
7537}
7538
7539#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7540#[serde(transparent)]
7541pub struct LegalHoldPolicyAssignmentType(pub String);
7542
7543impl LegalHoldPolicyAssignmentType {
7544 pub const LEGAL_HOLD_POLICY_ASSIGNMENT: &'static str = "legal_hold_policy_assignment";
7545}
7546
7547#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7548#[serde(transparent)]
7549pub struct MetadataCascadePolicyType(pub String);
7550
7551impl MetadataCascadePolicyType {
7552 pub const METADATA_CASCADE_POLICY: &'static str = "metadata_cascade_policy";
7553}
7554
7555#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7556pub struct MetadataCascadePolicyOwnerEnterprise {
7557 #[serde(default, skip_serializing_if = "Option::is_none")]
7558 pub r#type: Option<EnterpriseType>,
7559 #[serde(default, skip_serializing_if = "Option::is_none")]
7560 pub id: Option<String>,
7561}
7562
7563#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7564pub struct MetadataCascadePolicyParent {
7565 #[serde(default, skip_serializing_if = "Option::is_none")]
7566 pub r#type: Option<FolderType>,
7567 #[serde(default, skip_serializing_if = "Option::is_none")]
7568 pub id: Option<String>,
7569}
7570
7571#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7572#[serde(transparent)]
7573pub struct MetadataFilterScope(pub String);
7574
7575impl MetadataFilterScope {
7576 pub const GLOBAL: &'static str = "global";
7577 pub const ENTERPRISE: &'static str = "enterprise";
7578 pub const ENTERPRISE_ENTERPRISE_ID: &'static str = "enterprise_{enterprise_id}";
7579}
7580
7581#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7582#[serde(transparent)]
7583pub struct OrderByDirection(pub String);
7584
7585impl OrderByDirection {
7586 pub const ASC: &'static str = "ASC";
7587 pub const DESC: &'static str = "DESC";
7588 pub const ASC_2: &'static str = "asc";
7589 pub const DESC_2: &'static str = "desc";
7590}
7591
7592#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7593pub struct MetadataQueryOrderBy {
7594 #[serde(default, skip_serializing_if = "Option::is_none")]
7595 pub field_key: Option<String>,
7596 #[serde(default, skip_serializing_if = "Option::is_none")]
7597 pub direction: Option<OrderByDirection>,
7598}
7599
7600#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7601#[serde(transparent)]
7602pub struct FieldsType2(pub String);
7603
7604impl FieldsType2 {
7605 pub const STRING: &'static str = "string";
7606 pub const FLOAT: &'static str = "float";
7607 pub const DATE: &'static str = "date";
7608 pub const ENUM: &'static str = "enum";
7609 pub const MULTISELECT: &'static str = "multiSelect";
7610 pub const TAXONOMY: &'static str = "taxonomy";
7611 pub const INTEGER: &'static str = "integer";
7612}
7613
7614#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7615pub struct FieldsOptions3 {
7616 pub key: String,
7617 #[serde(default, skip_serializing_if = "Option::is_none")]
7618 pub id: Option<String>,
7619}
7620
7621#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7622pub struct FieldsOptionsRules {
7623 #[serde(
7624 rename = "multiSelect",
7625 default,
7626 skip_serializing_if = "Option::is_none"
7627 )]
7628 pub multi_select: Option<bool>,
7629 #[serde(
7630 rename = "selectableLevels",
7631 default,
7632 skip_serializing_if = "Option::is_none"
7633 )]
7634 pub selectable_levels: Option<Vec<i64>>,
7635}
7636
7637#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7638pub struct MetadataTemplateFields {
7639 pub r#type: FieldsType2,
7640 pub key: String,
7641 #[serde(rename = "displayName")]
7642 pub display_name: String,
7643 #[serde(default, skip_serializing_if = "Option::is_none")]
7644 pub description: Option<String>,
7645 #[serde(default, skip_serializing_if = "Option::is_none")]
7646 pub hidden: Option<bool>,
7647 #[serde(default, skip_serializing_if = "Option::is_none")]
7648 pub options: Option<Vec<FieldsOptions3>>,
7649 #[serde(
7650 rename = "taxonomyKey",
7651 default,
7652 skip_serializing_if = "Option::is_none"
7653 )]
7654 pub taxonomy_key: Option<String>,
7655 #[serde(
7656 rename = "taxonomyId",
7657 default,
7658 skip_serializing_if = "Option::is_none"
7659 )]
7660 pub taxonomy_id: Option<String>,
7661 #[serde(default, skip_serializing_if = "Option::is_none")]
7662 pub namespace: Option<String>,
7663 #[serde(
7664 rename = "optionsRules",
7665 default,
7666 skip_serializing_if = "Option::is_none"
7667 )]
7668 pub options_rules: Option<FieldsOptionsRules>,
7669 #[serde(default, skip_serializing_if = "Option::is_none")]
7670 pub id: Option<String>,
7671}
7672
7673#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7674#[serde(transparent)]
7675pub struct PostOAuth2TokenGrantType(pub String);
7676
7677impl PostOAuth2TokenGrantType {
7678 pub const AUTHORIZATION_CODE: &'static str = "authorization_code";
7679 pub const REFRESH_TOKEN: &'static str = "refresh_token";
7680 pub const CLIENT_CREDENTIALS: &'static str = "client_credentials";
7681 pub const URN_IETF_PARAMS_OAUTH_GRANT_TYPE_JWT_BEARER: &'static str =
7682 "urn:ietf:params:oauth:grant-type:jwt-bearer";
7683 pub const URN_IETF_PARAMS_OAUTH_GRANT_TYPE_TOKEN_EXCHANGE: &'static str =
7684 "urn:ietf:params:oauth:grant-type:token-exchange";
7685}
7686
7687#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7688#[serde(transparent)]
7689pub struct PostOAuth2TokenActorTokenType(pub String);
7690
7691impl PostOAuth2TokenActorTokenType {
7692 pub const URN_IETF_PARAMS_OAUTH_TOKEN_TYPE_ID_TOKEN: &'static str =
7693 "urn:ietf:params:oauth:token-type:id_token";
7694}
7695
7696#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7697#[serde(transparent)]
7698pub struct PostOAuth2TokenBoxSubjectType(pub String);
7699
7700impl PostOAuth2TokenBoxSubjectType {
7701 pub const ENTERPRISE: &'static str = "enterprise";
7702 pub const USER: &'static str = "user";
7703}
7704
7705#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7706#[serde(transparent)]
7707pub struct PostOAuth2TokenRefreshAccessTokenGrantType(pub String);
7708
7709impl PostOAuth2TokenRefreshAccessTokenGrantType {
7710 pub const REFRESH_TOKEN: &'static str = "refresh_token";
7711}
7712
7713#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7714#[serde(transparent)]
7715pub struct RecentItemInteractionType(pub String);
7716
7717impl RecentItemInteractionType {
7718 pub const ITEM_PREVIEW: &'static str = "item_preview";
7719 pub const ITEM_UPLOAD: &'static str = "item_upload";
7720 pub const ITEM_COMMENT: &'static str = "item_comment";
7721 pub const ITEM_OPEN: &'static str = "item_open";
7722 pub const ITEM_MODIFY: &'static str = "item_modify";
7723}
7724
7725#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7726#[serde(transparent)]
7727pub struct ResourceScopeScope(pub String);
7728
7729impl ResourceScopeScope {
7730 pub const ANNOTATION_EDIT: &'static str = "annotation_edit";
7731 pub const ANNOTATION_VIEW_ALL: &'static str = "annotation_view_all";
7732 pub const ANNOTATION_VIEW_SELF: &'static str = "annotation_view_self";
7733 pub const BASE_EXPLORER: &'static str = "base_explorer";
7734 pub const BASE_PICKER: &'static str = "base_picker";
7735 pub const BASE_PREVIEW: &'static str = "base_preview";
7736 pub const BASE_UPLOAD: &'static str = "base_upload";
7737 pub const ITEM_DELETE: &'static str = "item_delete";
7738 pub const ITEM_DOWNLOAD: &'static str = "item_download";
7739 pub const ITEM_PREVIEW: &'static str = "item_preview";
7740 pub const ITEM_RENAME: &'static str = "item_rename";
7741 pub const ITEM_SHARE: &'static str = "item_share";
7742 pub const ITEM_UPLOAD: &'static str = "item_upload";
7743 pub const ITEM_READ: &'static str = "item_read";
7744}
7745
7746#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7747#[serde(transparent)]
7748pub struct RetentionPolicyType(pub String);
7749
7750impl RetentionPolicyType {
7751 pub const RETENTION_POLICY: &'static str = "retention_policy";
7752}
7753
7754#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7755#[serde(transparent)]
7756pub struct RetentionPolicyDispositionAction(pub String);
7757
7758impl RetentionPolicyDispositionAction {
7759 pub const PERMANENTLY_DELETE: &'static str = "permanently_delete";
7760 pub const REMOVE_RETENTION: &'static str = "remove_retention";
7761}
7762
7763#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7764#[serde(transparent)]
7765pub struct RetentionPolicyPolicyType(pub String);
7766
7767impl RetentionPolicyPolicyType {
7768 pub const FINITE: &'static str = "finite";
7769 pub const INDEFINITE: &'static str = "indefinite";
7770}
7771
7772#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7773#[serde(transparent)]
7774pub struct RetentionPolicyRetentionType(pub String);
7775
7776impl RetentionPolicyRetentionType {
7777 pub const MODIFIABLE: &'static str = "modifiable";
7778 pub const NON_MODIFIABLE: &'static str = "non_modifiable";
7779}
7780
7781#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7782#[serde(transparent)]
7783pub struct RetentionPolicyStatus(pub String);
7784
7785impl RetentionPolicyStatus {
7786 pub const ACTIVE: &'static str = "active";
7787 pub const RETIRED: &'static str = "retired";
7788}
7789
7790#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7791pub struct RetentionPolicyAssignmentCounts {
7792 #[serde(default, skip_serializing_if = "Option::is_none")]
7793 pub enterprise: Option<i64>,
7794 #[serde(default, skip_serializing_if = "Option::is_none")]
7795 pub folder: Option<i64>,
7796 #[serde(default, skip_serializing_if = "Option::is_none")]
7797 pub metadata_template: Option<i64>,
7798}
7799
7800#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7801#[serde(transparent)]
7802pub struct RetentionPolicyAssignmentType(pub String);
7803
7804impl RetentionPolicyAssignmentType {
7805 pub const RETENTION_POLICY_ASSIGNMENT: &'static str = "retention_policy_assignment";
7806}
7807
7808#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7809#[serde(transparent)]
7810pub struct AssignedToType(pub String);
7811
7812impl AssignedToType {
7813 pub const FOLDER: &'static str = "folder";
7814 pub const ENTERPRISE: &'static str = "enterprise";
7815 pub const METADATA_TEMPLATE: &'static str = "metadata_template";
7816}
7817
7818#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7819pub struct RetentionPolicyAssignmentAssignedTo {
7820 #[serde(
7821 default,
7822 skip_serializing_if = "Option::is_none",
7823 deserialize_with = "double_option"
7824 )]
7825 pub id: Option<Option<String>>,
7826 #[serde(default, skip_serializing_if = "Option::is_none")]
7827 pub r#type: Option<AssignedToType>,
7828}
7829
7830#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7831pub struct RetentionPolicyAssignmentFilterFields {
7832 #[serde(
7833 default,
7834 skip_serializing_if = "Option::is_none",
7835 deserialize_with = "double_option"
7836 )]
7837 pub field: Option<Option<String>>,
7838 #[serde(
7839 default,
7840 skip_serializing_if = "Option::is_none",
7841 deserialize_with = "double_option"
7842 )]
7843 pub value: Option<Option<String>>,
7844}
7845
7846#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7847#[serde(transparent)]
7848pub struct RetentionPolicyMaxExtensionLengthRequestVariant0(pub String);
7849
7850impl RetentionPolicyMaxExtensionLengthRequestVariant0 {
7851 pub const NONE: &'static str = "none";
7852}
7853
7854#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7855#[serde(transparent)]
7856pub struct RoleVariableVariableType(pub String);
7857
7858impl RoleVariableVariableType {
7859 pub const COLLABORATOR_ROLE: &'static str = "collaborator_role";
7860}
7861
7862#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7863#[serde(transparent)]
7864pub struct SearchResultsType(pub String);
7865
7866impl SearchResultsType {
7867 pub const SEARCH_RESULTS_ITEMS: &'static str = "search_results_items";
7868}
7869
7870#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7871#[serde(transparent)]
7872pub struct SearchResultsWithSharedLinksType(pub String);
7873
7874impl SearchResultsWithSharedLinksType {
7875 pub const SEARCH_RESULTS_WITH_SHARED_LINKS: &'static str = "search_results_with_shared_links";
7876}
7877
7878#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7879#[serde(transparent)]
7880pub struct ShieldInformationBarrierType(pub String);
7881
7882impl ShieldInformationBarrierType {
7883 pub const SHIELD_INFORMATION_BARRIER: &'static str = "shield_information_barrier";
7884}
7885
7886#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7887#[serde(transparent)]
7888pub struct ShieldInformationBarrierStatus(pub String);
7889
7890impl ShieldInformationBarrierStatus {
7891 pub const DRAFT: &'static str = "draft";
7892 pub const PENDING: &'static str = "pending";
7893 pub const DISABLED: &'static str = "disabled";
7894 pub const ENABLED: &'static str = "enabled";
7895 pub const INVALID: &'static str = "invalid";
7896}
7897
7898#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7899#[serde(transparent)]
7900pub struct ShieldInformationBarrierReportType(pub String);
7901
7902impl ShieldInformationBarrierReportType {
7903 pub const SHIELD_INFORMATION_BARRIER_REPORT: &'static str = "shield_information_barrier_report";
7904}
7905
7906#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7907#[serde(transparent)]
7908pub struct ShieldInformationBarrierReportStatus(pub String);
7909
7910impl ShieldInformationBarrierReportStatus {
7911 pub const PENDING: &'static str = "pending";
7912 pub const ERROR: &'static str = "error";
7913 pub const DONE: &'static str = "done";
7914 pub const CANCELLED: &'static str = "cancelled";
7915}
7916
7917#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7918pub struct ShieldInformationBarrierReportDetailsDetails {
7919 #[serde(default, skip_serializing_if = "Option::is_none")]
7920 pub folder_id: Option<String>,
7921}
7922
7923#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7924#[serde(transparent)]
7925pub struct ShieldInformationBarrierSegmentType(pub String);
7926
7927impl ShieldInformationBarrierSegmentType {
7928 pub const SHIELD_INFORMATION_BARRIER_SEGMENT: &'static str =
7929 "shield_information_barrier_segment";
7930}
7931
7932#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7933#[serde(transparent)]
7934pub struct ShieldInformationBarrierSegmentMemberType(pub String);
7935
7936impl ShieldInformationBarrierSegmentMemberType {
7937 pub const SHIELD_INFORMATION_BARRIER_SEGMENT_MEMBER: &'static str =
7938 "shield_information_barrier_segment_member";
7939}
7940
7941#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7942pub struct ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment {
7943 #[serde(default, skip_serializing_if = "Option::is_none")]
7944 pub id: Option<String>,
7945 #[serde(default, skip_serializing_if = "Option::is_none")]
7946 pub r#type: Option<ShieldInformationBarrierSegmentType>,
7947}
7948
7949#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7950#[serde(transparent)]
7951pub struct ShieldInformationBarrierSegmentRestrictionType(pub String);
7952
7953impl ShieldInformationBarrierSegmentRestrictionType {
7954 pub const SHIELD_INFORMATION_BARRIER_SEGMENT_RESTRICTION: &'static str =
7955 "shield_information_barrier_segment_restriction";
7956}
7957
7958#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7959#[serde(transparent)]
7960pub struct SignRequestType(pub String);
7961
7962impl SignRequestType {
7963 pub const SIGN_REQUEST: &'static str = "sign-request";
7964}
7965
7966#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7967#[serde(transparent)]
7968pub struct SignRequestStatus(pub String);
7969
7970impl SignRequestStatus {
7971 pub const CONVERTING: &'static str = "converting";
7972 pub const CREATED: &'static str = "created";
7973 pub const SENT: &'static str = "sent";
7974 pub const VIEWED: &'static str = "viewed";
7975 pub const SIGNED: &'static str = "signed";
7976 pub const CANCELLED: &'static str = "cancelled";
7977 pub const DECLINED: &'static str = "declined";
7978 pub const ERROR: &'static str = "error";
7979 pub const ERROR_CONVERTING: &'static str = "error_converting";
7980 pub const ERROR_SENDING: &'static str = "error_sending";
7981 pub const EXPIRED: &'static str = "expired";
7982 pub const FINALIZING: &'static str = "finalizing";
7983 pub const ERROR_FINALIZING: &'static str = "error_finalizing";
7984}
7985
7986#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
7987pub struct SignRequestSignFiles {
7988 #[serde(default, skip_serializing_if = "Option::is_none")]
7989 pub files: Option<Vec<FileMini>>,
7990 #[serde(default, skip_serializing_if = "Option::is_none")]
7991 pub is_ready_for_download: Option<bool>,
7992}
7993
7994#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7995#[serde(transparent)]
7996pub struct SignRequestCreateRequestSignatureColor(pub String);
7997
7998impl SignRequestCreateRequestSignatureColor {
7999 pub const BLUE: &'static str = "blue";
8000 pub const BLACK: &'static str = "black";
8001 pub const RED: &'static str = "red";
8002}
8003
8004#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8005#[serde(transparent)]
8006pub struct SignRequestCreateSignerRole(pub String);
8007
8008impl SignRequestCreateSignerRole {
8009 pub const SIGNER: &'static str = "signer";
8010 pub const APPROVER: &'static str = "approver";
8011 pub const FINAL_COPY_READER: &'static str = "final_copy_reader";
8012}
8013
8014#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8015#[serde(transparent)]
8016pub struct SignerDecisionType(pub String);
8017
8018impl SignerDecisionType {
8019 pub const SIGNED: &'static str = "signed";
8020 pub const DECLINED: &'static str = "declined";
8021}
8022
8023#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8024pub struct SignRequestSignerSignerDecision {
8025 #[serde(default, skip_serializing_if = "Option::is_none")]
8026 pub r#type: Option<SignerDecisionType>,
8027 #[serde(default, skip_serializing_if = "Option::is_none")]
8028 pub finalized_at: Option<chrono::DateTime<chrono::Utc>>,
8029 #[serde(
8030 default,
8031 skip_serializing_if = "Option::is_none",
8032 deserialize_with = "double_option"
8033 )]
8034 pub additional_info: Option<Option<String>>,
8035}
8036
8037#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8038#[serde(transparent)]
8039pub struct SignRequestSignerInputType(pub String);
8040
8041impl SignRequestSignerInputType {
8042 pub const SIGNATURE: &'static str = "signature";
8043 pub const DATE: &'static str = "date";
8044 pub const TEXT: &'static str = "text";
8045 pub const CHECKBOX: &'static str = "checkbox";
8046 pub const RADIO: &'static str = "radio";
8047 pub const DROPDOWN: &'static str = "dropdown";
8048}
8049
8050#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8051#[serde(transparent)]
8052pub struct SignRequestSignerInputContentType(pub String);
8053
8054impl SignRequestSignerInputContentType {
8055 pub const SIGNATURE: &'static str = "signature";
8056 pub const INITIAL: &'static str = "initial";
8057 pub const STAMP: &'static str = "stamp";
8058 pub const DATE: &'static str = "date";
8059 pub const CHECKBOX: &'static str = "checkbox";
8060 pub const TEXT: &'static str = "text";
8061 pub const FULL_NAME: &'static str = "full_name";
8062 pub const FIRST_NAME: &'static str = "first_name";
8063 pub const LAST_NAME: &'static str = "last_name";
8064 pub const COMPANY: &'static str = "company";
8065 pub const TITLE: &'static str = "title";
8066 pub const EMAIL: &'static str = "email";
8067 pub const ATTACHMENT: &'static str = "attachment";
8068 pub const RADIO: &'static str = "radio";
8069 pub const DROPDOWN: &'static str = "dropdown";
8070}
8071
8072#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8073#[serde(transparent)]
8074pub struct SignRequestSignerInputValidation2(pub serde_json::Value);
8075
8076#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8077#[serde(transparent)]
8078pub struct SignRequestSignerInputCustomValidationValidationType(pub String);
8079
8080impl SignRequestSignerInputCustomValidationValidationType {
8081 pub const CUSTOM: &'static str = "custom";
8082}
8083
8084#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8085#[serde(transparent)]
8086pub struct SignRequestSignerInputDateAsiaValidationValidationType(pub String);
8087
8088impl SignRequestSignerInputDateAsiaValidationValidationType {
8089 pub const DATE_ASIA: &'static str = "date_asia";
8090}
8091
8092#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8093#[serde(transparent)]
8094pub struct SignRequestSignerInputDateEUValidationValidationType(pub String);
8095
8096impl SignRequestSignerInputDateEUValidationValidationType {
8097 pub const DATE_EU: &'static str = "date_eu";
8098}
8099
8100#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8101#[serde(transparent)]
8102pub struct SignRequestSignerInputDateISOValidationValidationType(pub String);
8103
8104impl SignRequestSignerInputDateISOValidationValidationType {
8105 pub const DATE_ISO: &'static str = "date_iso";
8106}
8107
8108#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8109#[serde(transparent)]
8110pub struct SignRequestSignerInputDateUSValidationValidationType(pub String);
8111
8112impl SignRequestSignerInputDateUSValidationValidationType {
8113 pub const DATE_US: &'static str = "date_us";
8114}
8115
8116#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8117#[serde(transparent)]
8118pub struct SignRequestSignerInputEmailValidationValidationType(pub String);
8119
8120impl SignRequestSignerInputEmailValidationValidationType {
8121 pub const EMAIL: &'static str = "email";
8122}
8123
8124#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8125#[serde(transparent)]
8126pub struct SignRequestSignerInputNumberWithCommaValidationValidationType(pub String);
8127
8128impl SignRequestSignerInputNumberWithCommaValidationValidationType {
8129 pub const NUMBER_WITH_COMMA: &'static str = "number_with_comma";
8130}
8131
8132#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8133#[serde(transparent)]
8134pub struct SignRequestSignerInputNumberWithPeriodValidationValidationType(pub String);
8135
8136impl SignRequestSignerInputNumberWithPeriodValidationValidationType {
8137 pub const NUMBER_WITH_PERIOD: &'static str = "number_with_period";
8138}
8139
8140#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8141#[serde(transparent)]
8142pub struct SignRequestSignerInputSSNValidationValidationType(pub String);
8143
8144impl SignRequestSignerInputSSNValidationValidationType {
8145 pub const SSN: &'static str = "ssn";
8146}
8147
8148#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8149#[serde(transparent)]
8150pub struct SignRequestSignerInputZIP4ValidationValidationType(pub String);
8151
8152impl SignRequestSignerInputZIP4ValidationValidationType {
8153 pub const ZIP_4: &'static str = "zip_4";
8154}
8155
8156#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8157#[serde(transparent)]
8158pub struct SignRequestSignerInputZIPValidationValidationType(pub String);
8159
8160impl SignRequestSignerInputZIPValidationValidationType {
8161 pub const ZIP: &'static str = "zip";
8162}
8163
8164#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8165#[serde(transparent)]
8166pub struct SignTemplateType(pub String);
8167
8168impl SignTemplateType {
8169 pub const SIGN_TEMPLATE: &'static str = "sign-template";
8170}
8171
8172#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8173#[serde(transparent)]
8174pub struct AdditionalInfoNonEditable(pub String);
8175
8176impl AdditionalInfoNonEditable {
8177 pub const EMAIL_SUBJECT: &'static str = "email_subject";
8178 pub const EMAIL_MESSAGE: &'static str = "email_message";
8179 pub const NAME: &'static str = "name";
8180 pub const DAYS_VALID: &'static str = "days_valid";
8181 pub const SIGNERS: &'static str = "signers";
8182 pub const SOURCE_FILES: &'static str = "source_files";
8183}
8184
8185#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8186pub struct AdditionalInfoRequired {
8187 #[serde(default, skip_serializing_if = "Option::is_none")]
8188 pub signers: Option<Vec<Vec<SignRequestSignerInputEmailValidationValidationType>>>,
8189}
8190
8191#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8192pub struct SignTemplateAdditionalInfo {
8193 #[serde(default, skip_serializing_if = "Option::is_none")]
8194 pub non_editable: Option<Vec<AdditionalInfoNonEditable>>,
8195 #[serde(default, skip_serializing_if = "Option::is_none")]
8196 pub required: Option<AdditionalInfoRequired>,
8197}
8198
8199#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8200pub struct SignTemplateReadySignLink {
8201 #[serde(default, skip_serializing_if = "Option::is_none")]
8202 pub url: Option<String>,
8203 #[serde(
8204 default,
8205 skip_serializing_if = "Option::is_none",
8206 deserialize_with = "double_option"
8207 )]
8208 pub name: Option<Option<String>>,
8209 #[serde(
8210 default,
8211 skip_serializing_if = "Option::is_none",
8212 deserialize_with = "double_option"
8213 )]
8214 pub instructions: Option<Option<String>>,
8215 #[serde(
8216 default,
8217 skip_serializing_if = "Option::is_none",
8218 deserialize_with = "double_option"
8219 )]
8220 pub folder_id: Option<Option<String>>,
8221 #[serde(default, skip_serializing_if = "Option::is_none")]
8222 pub is_notification_disabled: Option<bool>,
8223 #[serde(default, skip_serializing_if = "Option::is_none")]
8224 pub is_active: Option<bool>,
8225}
8226
8227#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8228pub struct SignTemplateCustomBranding {
8229 #[serde(
8230 default,
8231 skip_serializing_if = "Option::is_none",
8232 deserialize_with = "double_option"
8233 )]
8234 pub company_name: Option<Option<String>>,
8235 #[serde(
8236 default,
8237 skip_serializing_if = "Option::is_none",
8238 deserialize_with = "double_option"
8239 )]
8240 pub logo_uri: Option<Option<String>>,
8241 #[serde(
8242 default,
8243 skip_serializing_if = "Option::is_none",
8244 deserialize_with = "double_option"
8245 )]
8246 pub branding_color: Option<Option<String>>,
8247 #[serde(
8248 default,
8249 skip_serializing_if = "Option::is_none",
8250 deserialize_with = "double_option"
8251 )]
8252 pub email_footer_text: Option<Option<String>>,
8253}
8254
8255#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8256#[serde(transparent)]
8257pub struct StatusSkillCardSkillCardType(pub String);
8258
8259impl StatusSkillCardSkillCardType {
8260 pub const STATUS: &'static str = "status";
8261}
8262
8263#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8264#[serde(transparent)]
8265pub struct StatusCode(pub String);
8266
8267impl StatusCode {
8268 pub const INVOKED: &'static str = "invoked";
8269 pub const PROCESSING: &'static str = "processing";
8270 pub const SUCCESS: &'static str = "success";
8271 pub const TRANSIENT_FAILURE: &'static str = "transient_failure";
8272 pub const PERMANENT_FAILURE: &'static str = "permanent_failure";
8273}
8274
8275#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8276pub struct StatusSkillCardStatus {
8277 pub code: StatusCode,
8278 #[serde(default, skip_serializing_if = "Option::is_none")]
8279 pub message: Option<String>,
8280}
8281
8282#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8283#[serde(transparent)]
8284pub struct StoragePolicyType(pub String);
8285
8286impl StoragePolicyType {
8287 pub const STORAGE_POLICY: &'static str = "storage_policy";
8288}
8289
8290#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8291#[serde(transparent)]
8292pub struct StoragePolicyAssignmentType(pub String);
8293
8294impl StoragePolicyAssignmentType {
8295 pub const STORAGE_POLICY_ASSIGNMENT: &'static str = "storage_policy_assignment";
8296}
8297
8298#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8299#[serde(transparent)]
8300pub struct TaskType(pub String);
8301
8302impl TaskType {
8303 pub const TASK: &'static str = "task";
8304}
8305
8306#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8307#[serde(transparent)]
8308pub struct TaskAction(pub String);
8309
8310impl TaskAction {
8311 pub const REVIEW: &'static str = "review";
8312 pub const COMPLETE: &'static str = "complete";
8313}
8314
8315#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8316#[serde(transparent)]
8317pub struct TaskCompletionRule(pub String);
8318
8319impl TaskCompletionRule {
8320 pub const ALL_ASSIGNEES: &'static str = "all_assignees";
8321 pub const ANY_ASSIGNEE: &'static str = "any_assignee";
8322}
8323
8324#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8325#[serde(transparent)]
8326pub struct TaskAssignmentType(pub String);
8327
8328impl TaskAssignmentType {
8329 pub const TASK_ASSIGNMENT: &'static str = "task_assignment";
8330}
8331
8332#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8333#[serde(transparent)]
8334pub struct TaskAssignmentResolutionState(pub String);
8335
8336impl TaskAssignmentResolutionState {
8337 pub const COMPLETED: &'static str = "completed";
8338 pub const INCOMPLETE: &'static str = "incomplete";
8339 pub const APPROVED: &'static str = "approved";
8340 pub const REJECTED: &'static str = "rejected";
8341}
8342
8343#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8344#[serde(transparent)]
8345pub struct TemplateSignerInputType(pub String);
8346
8347impl TemplateSignerInputType {
8348 pub const SIGNATURE: &'static str = "signature";
8349 pub const DATE: &'static str = "date";
8350 pub const TEXT: &'static str = "text";
8351 pub const CHECKBOX: &'static str = "checkbox";
8352 pub const ATTACHMENT: &'static str = "attachment";
8353 pub const RADIO: &'static str = "radio";
8354 pub const DROPDOWN: &'static str = "dropdown";
8355}
8356
8357#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8358pub struct TemplateSignerInputCoordinates {
8359 #[serde(default, skip_serializing_if = "Option::is_none")]
8360 pub x: Option<f64>,
8361 #[serde(default, skip_serializing_if = "Option::is_none")]
8362 pub y: Option<f64>,
8363}
8364
8365#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8366pub struct TemplateSignerInputDimensions {
8367 #[serde(default, skip_serializing_if = "Option::is_none")]
8368 pub width: Option<f64>,
8369 #[serde(default, skip_serializing_if = "Option::is_none")]
8370 pub height: Option<f64>,
8371}
8372
8373#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8374#[serde(transparent)]
8375pub struct TermsOfServiceType(pub String);
8376
8377impl TermsOfServiceType {
8378 pub const TERMS_OF_SERVICE: &'static str = "terms_of_service";
8379}
8380
8381#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8382#[serde(transparent)]
8383pub struct TermsOfServiceStatus(pub String);
8384
8385impl TermsOfServiceStatus {
8386 pub const ENABLED: &'static str = "enabled";
8387 pub const DISABLED: &'static str = "disabled";
8388}
8389
8390#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8391#[serde(transparent)]
8392pub struct TermsOfServiceTosType(pub String);
8393
8394impl TermsOfServiceTosType {
8395 pub const MANAGED: &'static str = "managed";
8396 pub const EXTERNAL: &'static str = "external";
8397}
8398
8399#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8400#[serde(transparent)]
8401pub struct TermsOfServiceUserStatusType(pub String);
8402
8403impl TermsOfServiceUserStatusType {
8404 pub const TERMS_OF_SERVICE_USER_STATUS: &'static str = "terms_of_service_user_status";
8405}
8406
8407#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8408#[serde(transparent)]
8409pub struct TimelineSkillCardSkillCardType(pub String);
8410
8411impl TimelineSkillCardSkillCardType {
8412 pub const TIMELINE: &'static str = "timeline";
8413}
8414
8415#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8416pub struct EntriesAppears {
8417 #[serde(default, skip_serializing_if = "Option::is_none")]
8418 pub start: Option<i64>,
8419 #[serde(default, skip_serializing_if = "Option::is_none")]
8420 pub end: Option<i64>,
8421}
8422
8423#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8424pub struct TimelineSkillCardEntries {
8425 #[serde(default, skip_serializing_if = "Option::is_none")]
8426 pub text: Option<String>,
8427 #[serde(default, skip_serializing_if = "Option::is_none")]
8428 pub appears: Option<Vec<EntriesAppears>>,
8429 #[serde(default, skip_serializing_if = "Option::is_none")]
8430 pub image_url: Option<String>,
8431}
8432
8433#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8434#[serde(transparent)]
8435pub struct TrackingCodeType(pub String);
8436
8437impl TrackingCodeType {
8438 pub const TRACKING_CODE: &'static str = "tracking_code";
8439}
8440
8441#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8442#[serde(transparent)]
8443pub struct TranscriptSkillCardSkillCardType(pub String);
8444
8445impl TranscriptSkillCardSkillCardType {
8446 pub const TRANSCRIPT: &'static str = "transcript";
8447}
8448
8449#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8450pub struct EntriesAppears2 {
8451 #[serde(default, skip_serializing_if = "Option::is_none")]
8452 pub start: Option<i64>,
8453}
8454
8455#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8456pub struct TranscriptSkillCardEntries {
8457 #[serde(default, skip_serializing_if = "Option::is_none")]
8458 pub text: Option<String>,
8459 #[serde(default, skip_serializing_if = "Option::is_none")]
8460 pub appears: Option<Vec<EntriesAppears2>>,
8461}
8462
8463#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8464pub struct PathCollectionEntries {
8465 #[serde(default, skip_serializing_if = "Option::is_none")]
8466 pub r#type: Option<FolderType>,
8467 #[serde(default, skip_serializing_if = "Option::is_none")]
8468 pub id: Option<String>,
8469 #[serde(
8470 default,
8471 skip_serializing_if = "Option::is_none",
8472 deserialize_with = "double_option"
8473 )]
8474 pub sequence_id: Option<Option<String>>,
8475 #[serde(
8476 default,
8477 skip_serializing_if = "Option::is_none",
8478 deserialize_with = "double_option"
8479 )]
8480 pub etag: Option<Option<String>>,
8481 #[serde(default, skip_serializing_if = "Option::is_none")]
8482 pub name: Option<String>,
8483}
8484
8485#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8486pub struct TrashFilePathCollection {
8487 pub total_count: i64,
8488 pub entries: Vec<PathCollectionEntries>,
8489}
8490
8491#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8492#[serde(transparent)]
8493pub struct TrashWebLinkType(pub String);
8494
8495impl TrashWebLinkType {
8496 pub const WEB_LINK: &'static str = "web_link";
8497}
8498
8499#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8500#[serde(transparent)]
8501pub struct UploadSessionType(pub String);
8502
8503impl UploadSessionType {
8504 pub const UPLOAD_SESSION: &'static str = "upload_session";
8505}
8506
8507#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8508pub struct UploadSessionSessionEndpoints {
8509 #[serde(default, skip_serializing_if = "Option::is_none")]
8510 pub upload_part: Option<String>,
8511 #[serde(default, skip_serializing_if = "Option::is_none")]
8512 pub commit: Option<String>,
8513 #[serde(default, skip_serializing_if = "Option::is_none")]
8514 pub abort: Option<String>,
8515 #[serde(default, skip_serializing_if = "Option::is_none")]
8516 pub list_parts: Option<String>,
8517 #[serde(default, skip_serializing_if = "Option::is_none")]
8518 pub status: Option<String>,
8519 #[serde(default, skip_serializing_if = "Option::is_none")]
8520 pub log_event: Option<String>,
8521}
8522
8523#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8524#[serde(transparent)]
8525pub struct UserStatus(pub String);
8526
8527impl UserStatus {
8528 pub const ACTIVE: &'static str = "active";
8529 pub const INACTIVE: &'static str = "inactive";
8530 pub const CANNOT_DELETE_EDIT: &'static str = "cannot_delete_edit";
8531 pub const CANNOT_DELETE_EDIT_UPLOAD: &'static str = "cannot_delete_edit_upload";
8532}
8533
8534#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8535pub struct UserNotificationEmail {
8536 #[serde(default, skip_serializing_if = "Option::is_none")]
8537 pub email: Option<String>,
8538 #[serde(default, skip_serializing_if = "Option::is_none")]
8539 pub is_confirmed: Option<bool>,
8540}
8541
8542#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8543#[serde(transparent)]
8544pub struct UserFullRole(pub String);
8545
8546impl UserFullRole {
8547 pub const ADMIN: &'static str = "admin";
8548 pub const COADMIN: &'static str = "coadmin";
8549 pub const USER: &'static str = "user";
8550}
8551
8552#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8553pub struct UserAvatarPicUrls {
8554 #[serde(default, skip_serializing_if = "Option::is_none")]
8555 pub small: Option<String>,
8556 #[serde(default, skip_serializing_if = "Option::is_none")]
8557 pub large: Option<String>,
8558 #[serde(default, skip_serializing_if = "Option::is_none")]
8559 pub preview: Option<String>,
8560}
8561
8562#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8563pub struct WatermarkWatermark {
8564 #[serde(default, skip_serializing_if = "Option::is_none")]
8565 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
8566 #[serde(default, skip_serializing_if = "Option::is_none")]
8567 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
8568}
8569
8570#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8571#[serde(transparent)]
8572pub struct WebhookType(pub String);
8573
8574impl WebhookType {
8575 pub const WEBHOOK: &'static str = "webhook";
8576}
8577
8578#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8579pub struct WebhookTarget {
8580 #[serde(default, skip_serializing_if = "Option::is_none")]
8581 pub id: Option<String>,
8582 #[serde(default, skip_serializing_if = "Option::is_none")]
8583 pub r#type: Option<EventSourceItemType>,
8584}
8585
8586#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8587#[serde(transparent)]
8588pub struct WebhookTriggers(pub String);
8589
8590impl WebhookTriggers {
8591 pub const FILE_UPLOADED: &'static str = "FILE.UPLOADED";
8592 pub const FILE_PREVIEWED: &'static str = "FILE.PREVIEWED";
8593 pub const FILE_DOWNLOADED: &'static str = "FILE.DOWNLOADED";
8594 pub const FILE_TRASHED: &'static str = "FILE.TRASHED";
8595 pub const FILE_DELETED: &'static str = "FILE.DELETED";
8596 pub const FILE_RESTORED: &'static str = "FILE.RESTORED";
8597 pub const FILE_COPIED: &'static str = "FILE.COPIED";
8598 pub const FILE_MOVED: &'static str = "FILE.MOVED";
8599 pub const FILE_LOCKED: &'static str = "FILE.LOCKED";
8600 pub const FILE_UNLOCKED: &'static str = "FILE.UNLOCKED";
8601 pub const FILE_RENAMED: &'static str = "FILE.RENAMED";
8602 pub const COMMENT_CREATED: &'static str = "COMMENT.CREATED";
8603 pub const COMMENT_UPDATED: &'static str = "COMMENT.UPDATED";
8604 pub const COMMENT_DELETED: &'static str = "COMMENT.DELETED";
8605 pub const TASK_ASSIGNMENT_CREATED: &'static str = "TASK_ASSIGNMENT.CREATED";
8606 pub const TASK_ASSIGNMENT_UPDATED: &'static str = "TASK_ASSIGNMENT.UPDATED";
8607 pub const METADATA_INSTANCE_CREATED: &'static str = "METADATA_INSTANCE.CREATED";
8608 pub const METADATA_INSTANCE_UPDATED: &'static str = "METADATA_INSTANCE.UPDATED";
8609 pub const METADATA_INSTANCE_DELETED: &'static str = "METADATA_INSTANCE.DELETED";
8610 pub const FOLDER_CREATED: &'static str = "FOLDER.CREATED";
8611 pub const FOLDER_RENAMED: &'static str = "FOLDER.RENAMED";
8612 pub const FOLDER_DOWNLOADED: &'static str = "FOLDER.DOWNLOADED";
8613 pub const FOLDER_RESTORED: &'static str = "FOLDER.RESTORED";
8614 pub const FOLDER_DELETED: &'static str = "FOLDER.DELETED";
8615 pub const FOLDER_COPIED: &'static str = "FOLDER.COPIED";
8616 pub const FOLDER_MOVED: &'static str = "FOLDER.MOVED";
8617 pub const FOLDER_TRASHED: &'static str = "FOLDER.TRASHED";
8618 pub const WEBHOOK_DELETED: &'static str = "WEBHOOK.DELETED";
8619 pub const COLLABORATION_CREATED: &'static str = "COLLABORATION.CREATED";
8620 pub const COLLABORATION_ACCEPTED: &'static str = "COLLABORATION.ACCEPTED";
8621 pub const COLLABORATION_REJECTED: &'static str = "COLLABORATION.REJECTED";
8622 pub const COLLABORATION_REMOVED: &'static str = "COLLABORATION.REMOVED";
8623 pub const COLLABORATION_UPDATED: &'static str = "COLLABORATION.UPDATED";
8624 pub const SHARED_LINK_DELETED: &'static str = "SHARED_LINK.DELETED";
8625 pub const SHARED_LINK_CREATED: &'static str = "SHARED_LINK.CREATED";
8626 pub const SHARED_LINK_UPDATED: &'static str = "SHARED_LINK.UPDATED";
8627 pub const SIGN_REQUEST_COMPLETED: &'static str = "SIGN_REQUEST.COMPLETED";
8628 pub const SIGN_REQUEST_DECLINED: &'static str = "SIGN_REQUEST.DECLINED";
8629 pub const SIGN_REQUEST_EXPIRED: &'static str = "SIGN_REQUEST.EXPIRED";
8630 pub const SIGN_REQUEST_SIGNER_EMAIL_BOUNCED: &'static str = "SIGN_REQUEST.SIGNER_EMAIL_BOUNCED";
8631 pub const SIGN_REQUEST_SIGN_SIGNER_SIGNED: &'static str = "SIGN_REQUEST.SIGN_SIGNER_SIGNED";
8632 pub const SIGN_REQUEST_SIGN_DOCUMENT_CREATED: &'static str =
8633 "SIGN_REQUEST.SIGN_DOCUMENT_CREATED";
8634 pub const SIGN_REQUEST_SIGN_ERROR_FINALIZING: &'static str =
8635 "SIGN_REQUEST.SIGN_ERROR_FINALIZING";
8636}
8637
8638#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8639#[serde(transparent)]
8640pub struct WorkflowType(pub String);
8641
8642impl WorkflowType {
8643 pub const WORKFLOW: &'static str = "workflow";
8644}
8645
8646#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8647#[serde(transparent)]
8648pub struct FlowsType(pub String);
8649
8650impl FlowsType {
8651 pub const FLOW: &'static str = "flow";
8652}
8653
8654#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8655#[serde(transparent)]
8656pub struct TriggerType(pub String);
8657
8658impl TriggerType {
8659 pub const TRIGGER: &'static str = "trigger";
8660}
8661
8662#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8663#[serde(transparent)]
8664pub struct TriggerTriggerType(pub String);
8665
8666impl TriggerTriggerType {
8667 pub const WORKFLOW_MANUAL_START: &'static str = "WORKFLOW_MANUAL_START";
8668}
8669
8670#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8671#[serde(transparent)]
8672pub struct ScopeType(pub String);
8673
8674impl ScopeType {
8675 pub const TRIGGER_SCOPE: &'static str = "trigger_scope";
8676}
8677
8678#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8679pub struct TriggerScope {
8680 #[serde(default, skip_serializing_if = "Option::is_none")]
8681 pub r#type: Option<ScopeType>,
8682 #[serde(default, skip_serializing_if = "Option::is_none")]
8683 pub r#ref: Option<String>,
8684 #[serde(default, skip_serializing_if = "Option::is_none")]
8685 pub object: Option<MetadataCascadePolicyParent>,
8686}
8687
8688#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8689pub struct FlowsTrigger {
8690 #[serde(default, skip_serializing_if = "Option::is_none")]
8691 pub r#type: Option<TriggerType>,
8692 #[serde(default, skip_serializing_if = "Option::is_none")]
8693 pub trigger_type: Option<TriggerTriggerType>,
8694 #[serde(default, skip_serializing_if = "Option::is_none")]
8695 pub scope: Option<Vec<TriggerScope>>,
8696}
8697
8698#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8699#[serde(transparent)]
8700pub struct OutcomesType(pub String);
8701
8702impl OutcomesType {
8703 pub const OUTCOME: &'static str = "outcome";
8704}
8705
8706#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8707#[serde(transparent)]
8708pub struct OutcomesActionType(pub String);
8709
8710impl OutcomesActionType {
8711 pub const ADD_METADATA: &'static str = "add_metadata";
8712 pub const ASSIGN_TASK: &'static str = "assign_task";
8713 pub const COPY_FILE: &'static str = "copy_file";
8714 pub const COPY_FOLDER: &'static str = "copy_folder";
8715 pub const CREATE_FOLDER: &'static str = "create_folder";
8716 pub const DELETE_FILE: &'static str = "delete_file";
8717 pub const DELETE_FOLDER: &'static str = "delete_folder";
8718 pub const LOCK_FILE: &'static str = "lock_file";
8719 pub const MOVE_FILE: &'static str = "move_file";
8720 pub const MOVE_FOLDER: &'static str = "move_folder";
8721 pub const REMOVE_WATERMARK_FILE: &'static str = "remove_watermark_file";
8722 pub const RENAME_FOLDER: &'static str = "rename_folder";
8723 pub const RESTORE_FOLDER: &'static str = "restore_folder";
8724 pub const SHARE_FILE: &'static str = "share_file";
8725 pub const SHARE_FOLDER: &'static str = "share_folder";
8726 pub const UNLOCK_FILE: &'static str = "unlock_file";
8727 pub const UPLOAD_FILE: &'static str = "upload_file";
8728 pub const WAIT_FOR_TASK: &'static str = "wait_for_task";
8729 pub const WATERMARK_FILE: &'static str = "watermark_file";
8730 pub const GO_BACK_TO_STEP: &'static str = "go_back_to_step";
8731 pub const APPLY_FILE_CLASSIFICATION: &'static str = "apply_file_classification";
8732 pub const APPLY_FOLDER_CLASSIFICATION: &'static str = "apply_folder_classification";
8733 pub const SEND_NOTIFICATION: &'static str = "send_notification";
8734}
8735
8736#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8737pub struct OutcomesIfRejected {
8738 #[serde(default, skip_serializing_if = "Option::is_none")]
8739 pub id: Option<String>,
8740 #[serde(default, skip_serializing_if = "Option::is_none")]
8741 pub r#type: Option<OutcomesType>,
8742 #[serde(default, skip_serializing_if = "Option::is_none")]
8743 pub name: Option<String>,
8744 #[serde(default, skip_serializing_if = "Option::is_none")]
8745 pub action_type: Option<OutcomesActionType>,
8746}
8747
8748#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8749pub struct FlowsOutcomes {
8750 #[serde(default, skip_serializing_if = "Option::is_none")]
8751 pub id: Option<String>,
8752 #[serde(default, skip_serializing_if = "Option::is_none")]
8753 pub r#type: Option<OutcomesType>,
8754 #[serde(default, skip_serializing_if = "Option::is_none")]
8755 pub name: Option<String>,
8756 #[serde(default, skip_serializing_if = "Option::is_none")]
8757 pub action_type: Option<OutcomesActionType>,
8758 #[serde(default, skip_serializing_if = "Option::is_none")]
8759 pub if_rejected: Option<Vec<OutcomesIfRejected>>,
8760}
8761
8762#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8763pub struct WorkflowFlows {
8764 #[serde(default, skip_serializing_if = "Option::is_none")]
8765 pub id: Option<String>,
8766 #[serde(default, skip_serializing_if = "Option::is_none")]
8767 pub r#type: Option<FlowsType>,
8768 #[serde(default, skip_serializing_if = "Option::is_none")]
8769 pub trigger: Option<FlowsTrigger>,
8770 #[serde(default, skip_serializing_if = "Option::is_none")]
8771 pub outcomes: Option<Vec<FlowsOutcomes>>,
8772 #[serde(default, skip_serializing_if = "Option::is_none")]
8773 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
8774 #[serde(default, skip_serializing_if = "Option::is_none")]
8775 pub created_by: Option<UserBase>,
8776}
8777
8778#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8779pub struct ZipDownloadNameConflicts {
8780 #[serde(default, skip_serializing_if = "Option::is_none")]
8781 pub id: Option<String>,
8782 #[serde(default, skip_serializing_if = "Option::is_none")]
8783 pub r#type: Option<EventSourceItemType>,
8784 #[serde(default, skip_serializing_if = "Option::is_none")]
8785 pub original_name: Option<String>,
8786 #[serde(default, skip_serializing_if = "Option::is_none")]
8787 pub download_name: Option<String>,
8788}
8789
8790#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8791pub struct ZipDownloadRequestItems {
8792 pub r#type: EventSourceItemType,
8793 pub id: String,
8794}
8795
8796#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8797#[serde(transparent)]
8798pub struct ZipDownloadStatusState(pub String);
8799
8800impl ZipDownloadStatusState {
8801 pub const IN_PROGRESS: &'static str = "in_progress";
8802 pub const FAILED: &'static str = "failed";
8803 pub const SUCCEEDED: &'static str = "succeeded";
8804}
8805
8806#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8807#[serde(transparent)]
8808pub struct GetAuthorizeResponseType(pub String);
8809
8810impl GetAuthorizeResponseType {
8811 pub const CODE: &'static str = "code";
8812}
8813
8814#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8815pub struct PutIdParent {
8816 #[serde(default, skip_serializing_if = "Option::is_none")]
8817 pub id: Option<String>,
8818 #[serde(default, skip_serializing_if = "Option::is_none")]
8819 pub user_id: Option<String>,
8820}
8821
8822#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8823pub struct SharedLinkPermissions2 {
8824 #[serde(default, skip_serializing_if = "Option::is_none")]
8825 pub can_download: Option<bool>,
8826}
8827
8828#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8829pub struct PutIdSharedLink {
8830 #[serde(default, skip_serializing_if = "Option::is_none")]
8831 pub access: Option<SharedLinkAccess>,
8832 #[serde(
8833 default,
8834 skip_serializing_if = "Option::is_none",
8835 deserialize_with = "double_option"
8836 )]
8837 pub password: Option<Option<String>>,
8838 #[serde(default, skip_serializing_if = "Option::is_none")]
8839 pub vanity_name: Option<String>,
8840 #[serde(default, skip_serializing_if = "Option::is_none")]
8841 pub unshared_at: Option<chrono::DateTime<chrono::Utc>>,
8842 #[serde(default, skip_serializing_if = "Option::is_none")]
8843 pub permissions: Option<SharedLinkPermissions2>,
8844}
8845
8846#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8847pub struct PutIdLock {
8848 #[serde(default, skip_serializing_if = "Option::is_none")]
8849 pub access: Option<LockType>,
8850 #[serde(default, skip_serializing_if = "Option::is_none")]
8851 pub expires_at: Option<chrono::DateTime<chrono::Utc>>,
8852 #[serde(default, skip_serializing_if = "Option::is_none")]
8853 pub is_download_prevented: Option<bool>,
8854}
8855
8856#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8857#[serde(transparent)]
8858pub struct PermissionsCanDownload(pub String);
8859
8860impl PermissionsCanDownload {
8861 pub const OPEN: &'static str = "open";
8862 pub const COMPANY: &'static str = "company";
8863}
8864
8865#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8866pub struct PutIdPermissions {
8867 #[serde(default, skip_serializing_if = "Option::is_none")]
8868 pub can_download: Option<PermissionsCanDownload>,
8869}
8870
8871#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8872pub struct FileUpdateRequest {
8873 #[serde(default, skip_serializing_if = "Option::is_none")]
8874 pub name: Option<String>,
8875 #[serde(default, skip_serializing_if = "Option::is_none")]
8876 pub description: Option<String>,
8877 #[serde(default, skip_serializing_if = "Option::is_none")]
8878 pub parent: Option<PutIdParent>,
8879 #[serde(
8880 default,
8881 skip_serializing_if = "Option::is_none",
8882 deserialize_with = "double_option"
8883 )]
8884 pub shared_link: Option<Option<PutIdSharedLink>>,
8885 #[serde(
8886 default,
8887 skip_serializing_if = "Option::is_none",
8888 deserialize_with = "double_option"
8889 )]
8890 pub lock: Option<Option<PutIdLock>>,
8891 #[serde(default, skip_serializing_if = "Option::is_none")]
8892 pub disposition_at: Option<chrono::DateTime<chrono::Utc>>,
8893 #[serde(default, skip_serializing_if = "Option::is_none")]
8894 pub permissions: Option<PutIdPermissions>,
8895 #[serde(
8896 default,
8897 skip_serializing_if = "Option::is_none",
8898 deserialize_with = "double_option"
8899 )]
8900 pub collections: Option<Option<Vec<CommentItem>>>,
8901 #[serde(default, skip_serializing_if = "Option::is_none")]
8902 pub tags: Option<Vec<String>>,
8903}
8904
8905#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8906pub struct PostFileIdParent {
8907 #[serde(default, skip_serializing_if = "Option::is_none")]
8908 pub id: Option<String>,
8909}
8910
8911#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8912pub struct FileCreateRequest {
8913 #[serde(default, skip_serializing_if = "Option::is_none")]
8914 pub name: Option<String>,
8915 #[serde(default, skip_serializing_if = "Option::is_none")]
8916 pub parent: Option<PostFileIdParent>,
8917}
8918
8919#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8920pub struct PostFileIdContentAttributes {
8921 pub name: String,
8922 #[serde(default, skip_serializing_if = "Option::is_none")]
8923 pub content_modified_at: Option<chrono::DateTime<chrono::Utc>>,
8924}
8925
8926#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8927pub struct FileIdContentCreateRequest {
8928 pub attributes: PostFileIdContentAttributes,
8929 #[serde(skip)]
8930 pub file: Vec<u8>,
8931}
8932
8933#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8934pub struct AttributesParent {
8935 pub id: String,
8936}
8937
8938#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8939pub struct PostFileContentAttributes {
8940 pub name: String,
8941 pub parent: AttributesParent,
8942 #[serde(default, skip_serializing_if = "Option::is_none")]
8943 pub content_created_at: Option<chrono::DateTime<chrono::Utc>>,
8944 #[serde(default, skip_serializing_if = "Option::is_none")]
8945 pub content_modified_at: Option<chrono::DateTime<chrono::Utc>>,
8946}
8947
8948#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8949pub struct FileContentCreateRequest {
8950 pub attributes: PostFileContentAttributes,
8951 #[serde(skip)]
8952 pub file: Vec<u8>,
8953}
8954
8955#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8956pub struct OptionFileContentRequest {
8957 #[serde(default, skip_serializing_if = "Option::is_none")]
8958 pub name: Option<String>,
8959 #[serde(default, skip_serializing_if = "Option::is_none")]
8960 pub size: Option<i64>,
8961 #[serde(default, skip_serializing_if = "Option::is_none")]
8962 pub parent: Option<PostFileIdParent>,
8963}
8964
8965#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8966pub struct FileUploadSessionsCreateRequest {
8967 pub folder_id: String,
8968 pub file_size: i64,
8969 pub file_name: String,
8970}
8971
8972#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8973pub struct FileIdUploadSessionsCreateRequest {
8974 pub file_size: i64,
8975 #[serde(default, skip_serializing_if = "Option::is_none")]
8976 pub file_name: Option<String>,
8977}
8978
8979#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8980pub struct FileUploadSessionCommitRequest {
8981 pub parts: Vec<UploadPart>,
8982}
8983
8984#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
8985pub struct FileCopyRequest {
8986 #[serde(default, skip_serializing_if = "Option::is_none")]
8987 pub name: Option<String>,
8988 #[serde(default, skip_serializing_if = "Option::is_none")]
8989 pub version: Option<String>,
8990 pub parent: AttributesParent,
8991}
8992
8993#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8994#[serde(transparent)]
8995pub struct GetIdThumbnailIdExtension(pub String);
8996
8997impl GetIdThumbnailIdExtension {
8998 pub const PNG: &'static str = "png";
8999 pub const JPG: &'static str = "jpg";
9000}
9001
9002#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9003pub struct FileVersionUpdateRequest {
9004 #[serde(
9005 default,
9006 skip_serializing_if = "Option::is_none",
9007 deserialize_with = "double_option"
9008 )]
9009 pub trashed_at: Option<Option<String>>,
9010}
9011
9012#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9013pub struct FileVersionCurrentCreateRequest {
9014 #[serde(default, skip_serializing_if = "Option::is_none")]
9015 pub id: Option<String>,
9016 #[serde(default, skip_serializing_if = "Option::is_none")]
9017 pub r#type: Option<FileVersionType>,
9018}
9019
9020#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9021#[serde(transparent)]
9022pub struct PutOp(pub String);
9023
9024impl PutOp {
9025 pub const REPLACE: &'static str = "replace";
9026}
9027
9028#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9029#[serde(transparent)]
9030pub struct PutPath(pub String);
9031
9032impl PutPath {
9033 pub const BOX_SECURITY_CLASSIFICATION_KEY: &'static str = "/Box__Security__Classification__Key";
9034}
9035
9036#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9037pub struct FileClassificationUpdateRequest {
9038 pub op: PutOp,
9039 pub path: PutPath,
9040 pub value: String,
9041}
9042
9043#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9044pub struct FileClassificationCreateRequest {
9045 #[serde(
9046 rename = "Box__Security__Classification__Key",
9047 default,
9048 skip_serializing_if = "Option::is_none"
9049 )]
9050 pub box_security_classification_key: Option<String>,
9051}
9052
9053#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9054#[serde(transparent)]
9055pub struct GetFileIdMetadataIdIdScope(pub String);
9056
9057impl GetFileIdMetadataIdIdScope {
9058 pub const GLOBAL: &'static str = "global";
9059 pub const ENTERPRISE: &'static str = "enterprise";
9060}
9061
9062#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9063#[serde(transparent)]
9064pub struct PutFileIdMetadataIdIdOp(pub String);
9065
9066impl PutFileIdMetadataIdIdOp {
9067 pub const ADD: &'static str = "add";
9068 pub const REPLACE: &'static str = "replace";
9069 pub const REMOVE: &'static str = "remove";
9070 pub const TEST: &'static str = "test";
9071 pub const MOVE: &'static str = "move";
9072 pub const COPY: &'static str = "copy";
9073}
9074
9075#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9076pub struct FileMetadataUpdateRequest {
9077 #[serde(default, skip_serializing_if = "Option::is_none")]
9078 pub op: Option<PutFileIdMetadataIdIdOp>,
9079 #[serde(default, skip_serializing_if = "Option::is_none")]
9080 pub path: Option<String>,
9081 #[serde(default, skip_serializing_if = "Option::is_none")]
9082 pub value: Option<MetadataInstanceValue>,
9083 #[serde(default, skip_serializing_if = "Option::is_none")]
9084 pub from: Option<String>,
9085}
9086
9087#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9088pub struct SkillUpdateRequest {
9089 #[serde(default, skip_serializing_if = "Option::is_none")]
9090 pub op: Option<PutOp>,
9091 #[serde(default, skip_serializing_if = "Option::is_none")]
9092 pub path: Option<String>,
9093 #[serde(default, skip_serializing_if = "Option::is_none")]
9094 pub value: Option<SkillCard>,
9095}
9096
9097#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9098pub struct SkillCreateRequest {
9099 pub cards: Vec<SkillCard>,
9100}
9101
9102#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9103#[serde(transparent)]
9104pub struct WatermarkImprint(pub String);
9105
9106impl WatermarkImprint {
9107 pub const DEFAULT: &'static str = "default";
9108}
9109
9110#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9111pub struct PutFileIdWatermarkWatermark {
9112 pub imprint: WatermarkImprint,
9113}
9114
9115#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9116pub struct FileWatermarkUpdateRequest {
9117 pub watermark: PutFileIdWatermarkWatermark,
9118}
9119
9120#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9121#[serde(transparent)]
9122pub struct GetIdSort(pub String);
9123
9124impl GetIdSort {
9125 pub const ID: &'static str = "id";
9126 pub const NAME: &'static str = "name";
9127 pub const DATE: &'static str = "date";
9128 pub const SIZE: &'static str = "size";
9129}
9130
9131#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9132pub struct PutIdFolderUploadEmail {
9133 #[serde(default, skip_serializing_if = "Option::is_none")]
9134 pub access: Option<FolderUploadEmailAccess>,
9135}
9136
9137#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9138pub struct FolderUpdateRequest {
9139 #[serde(default, skip_serializing_if = "Option::is_none")]
9140 pub name: Option<String>,
9141 #[serde(default, skip_serializing_if = "Option::is_none")]
9142 pub description: Option<String>,
9143 #[serde(default, skip_serializing_if = "Option::is_none")]
9144 pub sync_state: Option<FolderFullSyncState>,
9145 #[serde(default, skip_serializing_if = "Option::is_none")]
9146 pub can_non_owners_invite: Option<bool>,
9147 #[serde(default, skip_serializing_if = "Option::is_none")]
9148 pub parent: Option<PutIdParent>,
9149 #[serde(default, skip_serializing_if = "Option::is_none")]
9150 pub shared_link: Option<PutIdSharedLink>,
9151 #[serde(
9152 default,
9153 skip_serializing_if = "Option::is_none",
9154 deserialize_with = "double_option"
9155 )]
9156 pub folder_upload_email: Option<Option<PutIdFolderUploadEmail>>,
9157 #[serde(default, skip_serializing_if = "Option::is_none")]
9158 pub tags: Option<Vec<String>>,
9159 #[serde(default, skip_serializing_if = "Option::is_none")]
9160 pub is_collaboration_restricted_to_enterprise: Option<bool>,
9161 #[serde(
9162 default,
9163 skip_serializing_if = "Option::is_none",
9164 deserialize_with = "double_option"
9165 )]
9166 pub collections: Option<Option<Vec<CommentItem>>>,
9167 #[serde(default, skip_serializing_if = "Option::is_none")]
9168 pub can_non_owners_view_collaborators: Option<bool>,
9169}
9170
9171#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9172pub struct FolderCreateRequest {
9173 pub name: String,
9174 pub parent: AttributesParent,
9175 #[serde(default, skip_serializing_if = "Option::is_none")]
9176 pub folder_upload_email: Option<PutIdFolderUploadEmail>,
9177 #[serde(default, skip_serializing_if = "Option::is_none")]
9178 pub sync_state: Option<FolderFullSyncState>,
9179}
9180
9181#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9182pub struct FolderCopyRequest {
9183 #[serde(default, skip_serializing_if = "Option::is_none")]
9184 pub name: Option<String>,
9185 pub parent: AttributesParent,
9186}
9187
9188#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9189#[serde(transparent)]
9190pub struct GetFolderTrashItemsSort(pub String);
9191
9192impl GetFolderTrashItemsSort {
9193 pub const NAME: &'static str = "name";
9194 pub const DATE: &'static str = "date";
9195 pub const SIZE: &'static str = "size";
9196}
9197
9198#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9199pub struct PostFolder {
9200 pub r#type: String,
9201 pub id: String,
9202}
9203
9204#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9205pub struct FolderLockCreateRequest {
9206 #[serde(default, skip_serializing_if = "Option::is_none")]
9207 pub locked_operations: Option<FolderLockLockedOperations>,
9208 pub folder: PostFolder,
9209}
9210
9211#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9212#[serde(transparent)]
9213pub struct PutAddOp(pub String);
9214
9215impl PutAddOp {
9216 pub const ADDENUMOPTION: &'static str = "addEnumOption";
9217}
9218
9219#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9220pub struct PutAddData {
9221 pub key: String,
9222 #[serde(
9223 rename = "staticConfig",
9224 default,
9225 skip_serializing_if = "Option::is_none"
9226 )]
9227 pub static_config: Option<OptionsStaticConfig>,
9228}
9229
9230#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9231pub struct ClassificationUpdateRequest {
9232 pub op: PutAddOp,
9233 #[serde(rename = "fieldKey")]
9234 pub field_key: FieldsKey,
9235 pub data: PutAddData,
9236}
9237
9238#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9239#[serde(transparent)]
9240pub struct PutUpdateOp(pub String);
9241
9242impl PutUpdateOp {
9243 pub const EDITENUMOPTION: &'static str = "editEnumOption";
9244}
9245
9246#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9247pub struct ClassificationUpdateRequest2 {
9248 pub op: PutUpdateOp,
9249 #[serde(rename = "fieldKey")]
9250 pub field_key: FieldsKey,
9251 #[serde(rename = "enumOptionKey")]
9252 pub enum_option_key: String,
9253 pub data: PutAddData,
9254}
9255
9256#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9257#[serde(transparent)]
9258pub struct PutIdIdSchemaOp(pub String);
9259
9260impl PutIdIdSchemaOp {
9261 pub const EDITTEMPLATE: &'static str = "editTemplate";
9262 pub const ADDFIELD: &'static str = "addField";
9263 pub const REORDERFIELDS: &'static str = "reorderFields";
9264 pub const ADDENUMOPTION: &'static str = "addEnumOption";
9265 pub const REORDERENUMOPTIONS: &'static str = "reorderEnumOptions";
9266 pub const REORDERMULTISELECTOPTIONS: &'static str = "reorderMultiSelectOptions";
9267 pub const ADDMULTISELECTOPTION: &'static str = "addMultiSelectOption";
9268 pub const EDITFIELD: &'static str = "editField";
9269 pub const REMOVEFIELD: &'static str = "removeField";
9270 pub const EDITENUMOPTION: &'static str = "editEnumOption";
9271 pub const REMOVEENUMOPTION: &'static str = "removeEnumOption";
9272 pub const EDITMULTISELECTOPTION: &'static str = "editMultiSelectOption";
9273 pub const REMOVEMULTISELECTOPTION: &'static str = "removeMultiSelectOption";
9274}
9275
9276#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9277pub struct SchemaUpdateRequest {
9278 pub op: PutIdIdSchemaOp,
9279 #[serde(default, skip_serializing_if = "Option::is_none")]
9280 pub data: Option<std::collections::HashMap<String, serde_json::Value>>,
9281 #[serde(rename = "fieldKey", default, skip_serializing_if = "Option::is_none")]
9282 pub field_key: Option<String>,
9283 #[serde(rename = "fieldKeys", default, skip_serializing_if = "Option::is_none")]
9284 pub field_keys: Option<Vec<String>>,
9285 #[serde(
9286 rename = "enumOptionKey",
9287 default,
9288 skip_serializing_if = "Option::is_none"
9289 )]
9290 pub enum_option_key: Option<String>,
9291 #[serde(
9292 rename = "enumOptionKeys",
9293 default,
9294 skip_serializing_if = "Option::is_none"
9295 )]
9296 pub enum_option_keys: Option<Vec<String>>,
9297 #[serde(
9298 rename = "multiSelectOptionKey",
9299 default,
9300 skip_serializing_if = "Option::is_none"
9301 )]
9302 pub multi_select_option_key: Option<String>,
9303 #[serde(
9304 rename = "multiSelectOptionKeys",
9305 default,
9306 skip_serializing_if = "Option::is_none"
9307 )]
9308 pub multi_select_option_keys: Option<Vec<String>>,
9309}
9310
9311#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9312#[serde(transparent)]
9313pub struct FieldsType3(pub String);
9314
9315impl FieldsType3 {
9316 pub const STRING: &'static str = "string";
9317 pub const FLOAT: &'static str = "float";
9318 pub const DATE: &'static str = "date";
9319 pub const ENUM: &'static str = "enum";
9320 pub const MULTISELECT: &'static str = "multiSelect";
9321 pub const TAXONOMY: &'static str = "taxonomy";
9322}
9323
9324#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9325pub struct PostSchemaFields {
9326 pub r#type: FieldsType3,
9327 pub key: String,
9328 #[serde(rename = "displayName")]
9329 pub display_name: String,
9330 #[serde(default, skip_serializing_if = "Option::is_none")]
9331 pub description: Option<String>,
9332 #[serde(default, skip_serializing_if = "Option::is_none")]
9333 pub hidden: Option<bool>,
9334 #[serde(default, skip_serializing_if = "Option::is_none")]
9335 pub options: Option<Vec<FieldsOptions>>,
9336 #[serde(
9337 rename = "taxonomyKey",
9338 default,
9339 skip_serializing_if = "Option::is_none"
9340 )]
9341 pub taxonomy_key: Option<String>,
9342 #[serde(
9343 rename = "taxonomyId",
9344 default,
9345 skip_serializing_if = "Option::is_none"
9346 )]
9347 pub taxonomy_id: Option<String>,
9348 #[serde(default, skip_serializing_if = "Option::is_none")]
9349 pub namespace: Option<String>,
9350 #[serde(
9351 rename = "optionsRules",
9352 default,
9353 skip_serializing_if = "Option::is_none"
9354 )]
9355 pub options_rules: Option<FieldsOptionsRules>,
9356}
9357
9358#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9359pub struct SchemaCreateRequest {
9360 pub scope: String,
9361 #[serde(
9362 rename = "templateKey",
9363 default,
9364 skip_serializing_if = "Option::is_none"
9365 )]
9366 pub template_key: Option<String>,
9367 #[serde(rename = "displayName")]
9368 pub display_name: String,
9369 #[serde(default, skip_serializing_if = "Option::is_none")]
9370 pub hidden: Option<bool>,
9371 #[serde(default, skip_serializing_if = "Option::is_none")]
9372 pub fields: Option<Vec<PostSchemaFields>>,
9373 #[serde(
9374 rename = "copyInstanceOnItemCopy",
9375 default,
9376 skip_serializing_if = "Option::is_none"
9377 )]
9378 pub copy_instance_on_item_copy: Option<bool>,
9379}
9380
9381#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9382pub struct PostMetadataTemplateSchemaClassificationsFields {
9383 pub r#type: FieldsType,
9384 pub key: FieldsKey,
9385 #[serde(rename = "displayName")]
9386 pub display_name: ClassificationTemplateDisplayName,
9387 #[serde(default, skip_serializing_if = "Option::is_none")]
9388 pub hidden: Option<bool>,
9389 pub options: Vec<PutAddData>,
9390}
9391
9392#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9393pub struct MetadataTemplateSchemaCreateRequest {
9394 pub scope: EnterpriseType,
9395 #[serde(rename = "templateKey")]
9396 pub template_key: ClassificationTemplate2,
9397 #[serde(rename = "displayName")]
9398 pub display_name: ClassificationTemplateDisplayName,
9399 #[serde(default, skip_serializing_if = "Option::is_none")]
9400 pub hidden: Option<bool>,
9401 #[serde(
9402 rename = "copyInstanceOnItemCopy",
9403 default,
9404 skip_serializing_if = "Option::is_none"
9405 )]
9406 pub copy_instance_on_item_copy: Option<bool>,
9407 pub fields: Vec<PostMetadataTemplateSchemaClassificationsFields>,
9408}
9409
9410#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9411pub struct MetadataCascadePolicyCreateRequest {
9412 pub folder_id: String,
9413 pub scope: GetFileIdMetadataIdIdScope,
9414 #[serde(rename = "templateKey")]
9415 pub template_key: String,
9416}
9417
9418#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9419#[serde(transparent)]
9420pub struct PostIdApplyConflictResolution(pub String);
9421
9422impl PostIdApplyConflictResolution {
9423 pub const NONE: &'static str = "none";
9424 pub const OVERWRITE: &'static str = "overwrite";
9425}
9426
9427#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9428pub struct MetadataCascadePolicyApplyRequest {
9429 pub conflict_resolution: PostIdApplyConflictResolution,
9430}
9431
9432#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9433pub struct CommentUpdateRequest {
9434 #[serde(default, skip_serializing_if = "Option::is_none")]
9435 pub message: Option<String>,
9436}
9437
9438#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9439#[serde(transparent)]
9440pub struct ItemType(pub String);
9441
9442impl ItemType {
9443 pub const FILE: &'static str = "file";
9444 pub const COMMENT: &'static str = "comment";
9445}
9446
9447#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9448pub struct PostItem {
9449 pub id: String,
9450 pub r#type: ItemType,
9451}
9452
9453#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9454pub struct CommentCreateRequest {
9455 pub message: String,
9456 #[serde(default, skip_serializing_if = "Option::is_none")]
9457 pub tagged_message: Option<String>,
9458 pub item: PostItem,
9459}
9460
9461#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9462#[serde(transparent)]
9463pub struct PutCollaborationIdStatus(pub String);
9464
9465impl PutCollaborationIdStatus {
9466 pub const PENDING: &'static str = "pending";
9467 pub const ACCEPTED: &'static str = "accepted";
9468 pub const REJECTED: &'static str = "rejected";
9469}
9470
9471#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9472pub struct CollaborationUpdateRequest {
9473 #[serde(default, skip_serializing_if = "Option::is_none")]
9474 pub role: Option<CollaborationRole>,
9475 #[serde(default, skip_serializing_if = "Option::is_none")]
9476 pub status: Option<PutCollaborationIdStatus>,
9477 #[serde(default, skip_serializing_if = "Option::is_none")]
9478 pub expires_at: Option<chrono::DateTime<chrono::Utc>>,
9479 #[serde(default, skip_serializing_if = "Option::is_none")]
9480 pub can_view_path: Option<bool>,
9481}
9482
9483#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9484#[serde(transparent)]
9485pub struct GetCollaborationsStatus(pub String);
9486
9487impl GetCollaborationsStatus {
9488 pub const PENDING: &'static str = "pending";
9489}
9490
9491#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9492pub struct PostCollaborationsItem {
9493 #[serde(default, skip_serializing_if = "Option::is_none")]
9494 pub r#type: Option<EventSourceItemType>,
9495 #[serde(default, skip_serializing_if = "Option::is_none")]
9496 pub id: Option<String>,
9497}
9498
9499#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9500#[serde(transparent)]
9501pub struct AccessibleByType(pub String);
9502
9503impl AccessibleByType {
9504 pub const USER: &'static str = "user";
9505 pub const GROUP: &'static str = "group";
9506}
9507
9508#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9509pub struct PostCollaborationsAccessibleBy {
9510 pub r#type: AccessibleByType,
9511 #[serde(default, skip_serializing_if = "Option::is_none")]
9512 pub id: Option<String>,
9513 #[serde(default, skip_serializing_if = "Option::is_none")]
9514 pub login: Option<String>,
9515}
9516
9517#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9518pub struct CollaborationsCreateRequest {
9519 pub item: PostCollaborationsItem,
9520 pub accessible_by: PostCollaborationsAccessibleBy,
9521 pub role: FileFullAllowedInviteeRoles,
9522 #[serde(default, skip_serializing_if = "Option::is_none")]
9523 pub is_access_only: Option<bool>,
9524 #[serde(default, skip_serializing_if = "Option::is_none")]
9525 pub can_view_path: Option<bool>,
9526 #[serde(default, skip_serializing_if = "Option::is_none")]
9527 pub expires_at: Option<chrono::DateTime<chrono::Utc>>,
9528}
9529
9530#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9531#[serde(transparent)]
9532pub struct GetScope(pub String);
9533
9534impl GetScope {
9535 pub const USER_CONTENT: &'static str = "user_content";
9536 pub const ENTERPRISE_CONTENT: &'static str = "enterprise_content";
9537}
9538
9539#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9540#[serde(transparent)]
9541pub struct GetContentTypes(pub String);
9542
9543impl GetContentTypes {
9544 pub const NAME: &'static str = "name";
9545 pub const DESCRIPTION: &'static str = "description";
9546 pub const FILE_CONTENT: &'static str = "file_content";
9547 pub const COMMENTS: &'static str = "comments";
9548 pub const TAGS: &'static str = "tags";
9549}
9550
9551#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9552#[serde(transparent)]
9553pub struct GetType(pub String);
9554
9555impl GetType {
9556 pub const FILE: &'static str = "file";
9557 pub const FOLDER: &'static str = "folder";
9558 pub const WEB_LINK: &'static str = "web_link";
9559}
9560
9561#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9562#[serde(transparent)]
9563pub struct GetTrashContent(pub String);
9564
9565impl GetTrashContent {
9566 pub const NON_TRASHED_ONLY: &'static str = "non_trashed_only";
9567 pub const TRASHED_ONLY: &'static str = "trashed_only";
9568 pub const ALL_ITEMS: &'static str = "all_items";
9569}
9570
9571#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9572#[serde(transparent)]
9573pub struct GetSort(pub String);
9574
9575impl GetSort {
9576 pub const MODIFIED_AT: &'static str = "modified_at";
9577 pub const RELEVANCE: &'static str = "relevance";
9578}
9579
9580#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9581#[serde(transparent)]
9582pub struct GetDirection(pub String);
9583
9584impl GetDirection {
9585 pub const DESC: &'static str = "DESC";
9586 pub const ASC: &'static str = "ASC";
9587}
9588
9589#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9590pub struct PostItem2 {
9591 #[serde(default, skip_serializing_if = "Option::is_none")]
9592 pub id: Option<String>,
9593 #[serde(default, skip_serializing_if = "Option::is_none")]
9594 pub r#type: Option<AiCitationType>,
9595}
9596
9597#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9598pub struct TaskCreateRequest {
9599 pub item: PostItem2,
9600 #[serde(default, skip_serializing_if = "Option::is_none")]
9601 pub action: Option<TaskAction>,
9602 #[serde(default, skip_serializing_if = "Option::is_none")]
9603 pub message: Option<String>,
9604 #[serde(default, skip_serializing_if = "Option::is_none")]
9605 pub due_at: Option<chrono::DateTime<chrono::Utc>>,
9606 #[serde(default, skip_serializing_if = "Option::is_none")]
9607 pub completion_rule: Option<TaskCompletionRule>,
9608}
9609
9610#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9611pub struct TaskUpdateRequest {
9612 #[serde(default, skip_serializing_if = "Option::is_none")]
9613 pub action: Option<TaskAction>,
9614 #[serde(default, skip_serializing_if = "Option::is_none")]
9615 pub message: Option<String>,
9616 #[serde(default, skip_serializing_if = "Option::is_none")]
9617 pub due_at: Option<chrono::DateTime<chrono::Utc>>,
9618 #[serde(default, skip_serializing_if = "Option::is_none")]
9619 pub completion_rule: Option<TaskCompletionRule>,
9620}
9621
9622#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9623pub struct PostTask {
9624 pub id: String,
9625 pub r#type: TaskType,
9626}
9627
9628#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9629pub struct PostAssignTo {
9630 #[serde(default, skip_serializing_if = "Option::is_none")]
9631 pub id: Option<String>,
9632 #[serde(default, skip_serializing_if = "Option::is_none")]
9633 pub login: Option<String>,
9634}
9635
9636#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9637pub struct TaskAssignmentCreateRequest {
9638 pub task: PostTask,
9639 pub assign_to: PostAssignTo,
9640}
9641
9642#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9643pub struct TaskAssignmentUpdateRequest {
9644 #[serde(default, skip_serializing_if = "Option::is_none")]
9645 pub message: Option<String>,
9646 #[serde(default, skip_serializing_if = "Option::is_none")]
9647 pub resolution_state: Option<TaskAssignmentResolutionState>,
9648}
9649
9650#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9651pub struct SharedLinkPermissions3 {
9652 #[serde(default, skip_serializing_if = "Option::is_none")]
9653 pub can_download: Option<bool>,
9654 #[serde(default, skip_serializing_if = "Option::is_none")]
9655 pub can_preview: Option<bool>,
9656 #[serde(default, skip_serializing_if = "Option::is_none")]
9657 pub can_edit: Option<bool>,
9658}
9659
9660#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9661pub struct PutFileIdAddSharedLinkSharedLink {
9662 #[serde(default, skip_serializing_if = "Option::is_none")]
9663 pub access: Option<SharedLinkAccess>,
9664 #[serde(
9665 default,
9666 skip_serializing_if = "Option::is_none",
9667 deserialize_with = "double_option"
9668 )]
9669 pub password: Option<Option<String>>,
9670 #[serde(default, skip_serializing_if = "Option::is_none")]
9671 pub vanity_name: Option<String>,
9672 #[serde(default, skip_serializing_if = "Option::is_none")]
9673 pub unshared_at: Option<chrono::DateTime<chrono::Utc>>,
9674 #[serde(default, skip_serializing_if = "Option::is_none")]
9675 pub permissions: Option<SharedLinkPermissions3>,
9676}
9677
9678#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9679pub struct FileUpdateRequest2 {
9680 #[serde(default, skip_serializing_if = "Option::is_none")]
9681 pub shared_link: Option<PutFileIdAddSharedLinkSharedLink>,
9682}
9683
9684#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9685pub struct FileUpdateRequest3 {
9686 #[serde(
9687 default,
9688 skip_serializing_if = "Option::is_none",
9689 deserialize_with = "double_option"
9690 )]
9691 pub shared_link: Option<Option<std::collections::HashMap<String, serde_json::Value>>>,
9692}
9693
9694#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9695pub struct PutFolderIdUpdateSharedLinkSharedLink {
9696 #[serde(default, skip_serializing_if = "Option::is_none")]
9697 pub access: Option<SharedLinkAccess>,
9698 #[serde(default, skip_serializing_if = "Option::is_none")]
9699 pub password: Option<String>,
9700 #[serde(default, skip_serializing_if = "Option::is_none")]
9701 pub vanity_name: Option<String>,
9702 #[serde(default, skip_serializing_if = "Option::is_none")]
9703 pub unshared_at: Option<chrono::DateTime<chrono::Utc>>,
9704 #[serde(default, skip_serializing_if = "Option::is_none")]
9705 pub permissions: Option<SharedLinkPermissions3>,
9706}
9707
9708#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9709pub struct FolderUpdateRequest2 {
9710 #[serde(default, skip_serializing_if = "Option::is_none")]
9711 pub shared_link: Option<PutFolderIdUpdateSharedLinkSharedLink>,
9712}
9713
9714#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9715pub struct WebLinkCreateRequest {
9716 pub url: String,
9717 pub parent: AttributesParent,
9718 #[serde(default, skip_serializing_if = "Option::is_none")]
9719 pub name: Option<String>,
9720 #[serde(default, skip_serializing_if = "Option::is_none")]
9721 pub description: Option<String>,
9722}
9723
9724#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9725pub struct PutIdSharedLink2 {
9726 #[serde(default, skip_serializing_if = "Option::is_none")]
9727 pub access: Option<SharedLinkAccess>,
9728 #[serde(
9729 default,
9730 skip_serializing_if = "Option::is_none",
9731 deserialize_with = "double_option"
9732 )]
9733 pub password: Option<Option<String>>,
9734 #[serde(default, skip_serializing_if = "Option::is_none")]
9735 pub vanity_name: Option<String>,
9736 #[serde(default, skip_serializing_if = "Option::is_none")]
9737 pub unshared_at: Option<chrono::DateTime<chrono::Utc>>,
9738}
9739
9740#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9741pub struct WebLinkUpdateRequest {
9742 #[serde(default, skip_serializing_if = "Option::is_none")]
9743 pub url: Option<String>,
9744 #[serde(default, skip_serializing_if = "Option::is_none")]
9745 pub parent: Option<PutIdParent>,
9746 #[serde(default, skip_serializing_if = "Option::is_none")]
9747 pub name: Option<String>,
9748 #[serde(default, skip_serializing_if = "Option::is_none")]
9749 pub description: Option<String>,
9750 #[serde(default, skip_serializing_if = "Option::is_none")]
9751 pub shared_link: Option<PutIdSharedLink2>,
9752}
9753
9754#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9755#[serde(transparent)]
9756pub struct GetUserType(pub String);
9757
9758impl GetUserType {
9759 pub const ALL: &'static str = "all";
9760 pub const MANAGED: &'static str = "managed";
9761 pub const EXTERNAL: &'static str = "external";
9762}
9763
9764#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9765#[serde(transparent)]
9766pub struct PostRole(pub String);
9767
9768impl PostRole {
9769 pub const COADMIN: &'static str = "coadmin";
9770 pub const USER: &'static str = "user";
9771}
9772
9773#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9774pub struct UserCreateRequest {
9775 pub name: String,
9776 #[serde(default, skip_serializing_if = "Option::is_none")]
9777 pub login: Option<String>,
9778 #[serde(default, skip_serializing_if = "Option::is_none")]
9779 pub is_platform_access_only: Option<bool>,
9780 #[serde(default, skip_serializing_if = "Option::is_none")]
9781 pub role: Option<PostRole>,
9782 #[serde(default, skip_serializing_if = "Option::is_none")]
9783 pub language: Option<String>,
9784 #[serde(default, skip_serializing_if = "Option::is_none")]
9785 pub is_sync_enabled: Option<bool>,
9786 #[serde(default, skip_serializing_if = "Option::is_none")]
9787 pub job_title: Option<String>,
9788 #[serde(default, skip_serializing_if = "Option::is_none")]
9789 pub phone: Option<String>,
9790 #[serde(default, skip_serializing_if = "Option::is_none")]
9791 pub address: Option<String>,
9792 #[serde(default, skip_serializing_if = "Option::is_none")]
9793 pub space_amount: Option<i64>,
9794 #[serde(default, skip_serializing_if = "Option::is_none")]
9795 pub tracking_codes: Option<Vec<TrackingCode>>,
9796 #[serde(default, skip_serializing_if = "Option::is_none")]
9797 pub can_see_managed_users: Option<bool>,
9798 #[serde(default, skip_serializing_if = "Option::is_none")]
9799 pub timezone: Option<String>,
9800 #[serde(default, skip_serializing_if = "Option::is_none")]
9801 pub is_external_collab_restricted: Option<bool>,
9802 #[serde(default, skip_serializing_if = "Option::is_none")]
9803 pub is_exempt_from_device_limits: Option<bool>,
9804 #[serde(default, skip_serializing_if = "Option::is_none")]
9805 pub is_exempt_from_login_verification: Option<bool>,
9806 #[serde(default, skip_serializing_if = "Option::is_none")]
9807 pub status: Option<UserStatus>,
9808 #[serde(default, skip_serializing_if = "Option::is_none")]
9809 pub external_app_user_id: Option<String>,
9810}
9811
9812#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9813pub struct UserTerminateSessionsCreateRequest {
9814 pub user_ids: Vec<String>,
9815 pub user_logins: Vec<String>,
9816}
9817
9818#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9819pub struct PutIdNotificationEmail {
9820 #[serde(default, skip_serializing_if = "Option::is_none")]
9821 pub email: Option<String>,
9822}
9823
9824#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9825pub struct UserUpdateRequest {
9826 #[serde(
9827 default,
9828 skip_serializing_if = "Option::is_none",
9829 deserialize_with = "double_option"
9830 )]
9831 pub enterprise: Option<Option<String>>,
9832 #[serde(default, skip_serializing_if = "Option::is_none")]
9833 pub notify: Option<bool>,
9834 #[serde(default, skip_serializing_if = "Option::is_none")]
9835 pub name: Option<String>,
9836 #[serde(default, skip_serializing_if = "Option::is_none")]
9837 pub login: Option<String>,
9838 #[serde(default, skip_serializing_if = "Option::is_none")]
9839 pub role: Option<PostRole>,
9840 #[serde(default, skip_serializing_if = "Option::is_none")]
9841 pub language: Option<String>,
9842 #[serde(default, skip_serializing_if = "Option::is_none")]
9843 pub is_sync_enabled: Option<bool>,
9844 #[serde(default, skip_serializing_if = "Option::is_none")]
9845 pub job_title: Option<String>,
9846 #[serde(default, skip_serializing_if = "Option::is_none")]
9847 pub phone: Option<String>,
9848 #[serde(default, skip_serializing_if = "Option::is_none")]
9849 pub address: Option<String>,
9850 #[serde(default, skip_serializing_if = "Option::is_none")]
9851 pub tracking_codes: Option<Vec<TrackingCode>>,
9852 #[serde(default, skip_serializing_if = "Option::is_none")]
9853 pub can_see_managed_users: Option<bool>,
9854 #[serde(default, skip_serializing_if = "Option::is_none")]
9855 pub timezone: Option<String>,
9856 #[serde(default, skip_serializing_if = "Option::is_none")]
9857 pub is_external_collab_restricted: Option<bool>,
9858 #[serde(default, skip_serializing_if = "Option::is_none")]
9859 pub is_exempt_from_device_limits: Option<bool>,
9860 #[serde(default, skip_serializing_if = "Option::is_none")]
9861 pub is_exempt_from_login_verification: Option<bool>,
9862 #[serde(default, skip_serializing_if = "Option::is_none")]
9863 pub is_password_reset_required: Option<bool>,
9864 #[serde(default, skip_serializing_if = "Option::is_none")]
9865 pub status: Option<UserStatus>,
9866 #[serde(default, skip_serializing_if = "Option::is_none")]
9867 pub space_amount: Option<i64>,
9868 #[serde(
9869 default,
9870 skip_serializing_if = "Option::is_none",
9871 deserialize_with = "double_option"
9872 )]
9873 pub notification_email: Option<Option<PutIdNotificationEmail>>,
9874 #[serde(default, skip_serializing_if = "Option::is_none")]
9875 pub external_app_user_id: Option<String>,
9876}
9877
9878#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9879pub struct UserAvatarCreateRequest {
9880 #[serde(skip)]
9881 pub pic: Vec<u8>,
9882}
9883
9884#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9885pub struct UserFolder0UpdateRequest {
9886 pub owned_by: AttributesParent,
9887}
9888
9889#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9890pub struct UserIdCreateRequest {
9891 pub email: String,
9892}
9893
9894#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9895pub struct PostActionableBy {
9896 #[serde(default, skip_serializing_if = "Option::is_none")]
9897 pub login: Option<String>,
9898}
9899
9900#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9901pub struct InviteCreateRequest {
9902 pub enterprise: AttributesParent,
9903 pub actionable_by: PostActionableBy,
9904}
9905
9906#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9907pub struct GroupCreateRequest {
9908 pub name: String,
9909 #[serde(default, skip_serializing_if = "Option::is_none")]
9910 pub provenance: Option<String>,
9911 #[serde(default, skip_serializing_if = "Option::is_none")]
9912 pub external_sync_identifier: Option<String>,
9913 #[serde(default, skip_serializing_if = "Option::is_none")]
9914 pub description: Option<String>,
9915 #[serde(default, skip_serializing_if = "Option::is_none")]
9916 pub invitability_level: Option<GroupFullInvitabilityLevel>,
9917 #[serde(default, skip_serializing_if = "Option::is_none")]
9918 pub member_viewability_level: Option<GroupFullInvitabilityLevel>,
9919}
9920
9921#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9922pub struct GroupTerminateSessionsCreateRequest {
9923 pub group_ids: Vec<String>,
9924}
9925
9926#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9927pub struct GroupUpdateRequest {
9928 #[serde(default, skip_serializing_if = "Option::is_none")]
9929 pub name: Option<String>,
9930 #[serde(default, skip_serializing_if = "Option::is_none")]
9931 pub provenance: Option<String>,
9932 #[serde(default, skip_serializing_if = "Option::is_none")]
9933 pub external_sync_identifier: Option<String>,
9934 #[serde(default, skip_serializing_if = "Option::is_none")]
9935 pub description: Option<String>,
9936 #[serde(default, skip_serializing_if = "Option::is_none")]
9937 pub invitability_level: Option<GroupFullInvitabilityLevel>,
9938 #[serde(default, skip_serializing_if = "Option::is_none")]
9939 pub member_viewability_level: Option<GroupFullInvitabilityLevel>,
9940}
9941
9942#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9943pub struct GroupCreateRequest2 {
9944 pub user: AttributesParent,
9945 pub group: AttributesParent,
9946 #[serde(default, skip_serializing_if = "Option::is_none")]
9947 pub role: Option<GroupMembershipRole>,
9948 #[serde(
9949 default,
9950 skip_serializing_if = "Option::is_none",
9951 deserialize_with = "double_option"
9952 )]
9953 pub configurable_permissions: Option<Option<std::collections::HashMap<String, bool>>>,
9954}
9955
9956#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9957pub struct GroupUpdateRequest2 {
9958 #[serde(default, skip_serializing_if = "Option::is_none")]
9959 pub role: Option<GroupMembershipRole>,
9960 #[serde(
9961 default,
9962 skip_serializing_if = "Option::is_none",
9963 deserialize_with = "double_option"
9964 )]
9965 pub configurable_permissions: Option<Option<std::collections::HashMap<String, bool>>>,
9966}
9967
9968#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9969pub struct WebhookCreateRequest {
9970 pub target: WebhookTarget,
9971 pub address: String,
9972 pub triggers: Vec<WebhookTriggers>,
9973}
9974
9975#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9976pub struct WebhookUpdateRequest {
9977 #[serde(default, skip_serializing_if = "Option::is_none")]
9978 pub target: Option<WebhookTarget>,
9979 #[serde(default, skip_serializing_if = "Option::is_none")]
9980 pub address: Option<String>,
9981 #[serde(default, skip_serializing_if = "Option::is_none")]
9982 pub triggers: Option<Vec<WebhookTriggers>>,
9983}
9984
9985#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9986pub struct PutSkillInvocationIdMetadata {
9987 #[serde(default, skip_serializing_if = "Option::is_none")]
9988 pub cards: Option<Vec<SkillCard>>,
9989}
9990
9991#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
9992pub struct PutSkillInvocationIdFile {
9993 #[serde(default, skip_serializing_if = "Option::is_none")]
9994 pub r#type: Option<AiCitationType>,
9995 #[serde(default, skip_serializing_if = "Option::is_none")]
9996 pub id: Option<String>,
9997}
9998
9999#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10000pub struct PutSkillInvocationIdFileVersion {
10001 #[serde(default, skip_serializing_if = "Option::is_none")]
10002 pub r#type: Option<FileVersionType>,
10003 #[serde(default, skip_serializing_if = "Option::is_none")]
10004 pub id: Option<String>,
10005}
10006
10007#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10008pub struct PutSkillInvocationIdUsage {
10009 #[serde(default, skip_serializing_if = "Option::is_none")]
10010 pub unit: Option<String>,
10011 #[serde(default, skip_serializing_if = "Option::is_none")]
10012 pub value: Option<f64>,
10013}
10014
10015#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10016pub struct SkillInvocationUpdateRequest {
10017 pub status: StatusCode,
10018 pub metadata: PutSkillInvocationIdMetadata,
10019 pub file: PutSkillInvocationIdFile,
10020 #[serde(default, skip_serializing_if = "Option::is_none")]
10021 pub file_version: Option<PutSkillInvocationIdFileVersion>,
10022 #[serde(default, skip_serializing_if = "Option::is_none")]
10023 pub usage: Option<PutSkillInvocationIdUsage>,
10024}
10025
10026#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
10027#[serde(transparent)]
10028pub struct GetStreamType(pub String);
10029
10030impl GetStreamType {
10031 pub const ALL: &'static str = "all";
10032 pub const CHANGES: &'static str = "changes";
10033 pub const SYNC: &'static str = "sync";
10034 pub const ADMIN_LOGS: &'static str = "admin_logs";
10035 pub const ADMIN_LOGS_STREAMING: &'static str = "admin_logs_streaming";
10036}
10037
10038#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
10039#[serde(transparent)]
10040pub struct GetEventType(pub String);
10041
10042impl GetEventType {
10043 pub const ACCESS_GRANTED: &'static str = "ACCESS_GRANTED";
10044 pub const ACCESS_REVOKED: &'static str = "ACCESS_REVOKED";
10045 pub const ADD_DEVICE_ASSOCIATION: &'static str = "ADD_DEVICE_ASSOCIATION";
10046 pub const ADD_LOGIN_ACTIVITY_DEVICE: &'static str = "ADD_LOGIN_ACTIVITY_DEVICE";
10047 pub const ADMIN_LOGIN: &'static str = "ADMIN_LOGIN";
10048 pub const ADVANCED_FOLDER_SETTINGS_UPDATE: &'static str = "ADVANCED_FOLDER_SETTINGS_UPDATE";
10049 pub const APPLICATION_CREATED: &'static str = "APPLICATION_CREATED";
10050 pub const APPLICATION_PUBLIC_KEY_ADDED: &'static str = "APPLICATION_PUBLIC_KEY_ADDED";
10051 pub const APPLICATION_PUBLIC_KEY_DELETED: &'static str = "APPLICATION_PUBLIC_KEY_DELETED";
10052 pub const CHANGE_ADMIN_ROLE: &'static str = "CHANGE_ADMIN_ROLE";
10053 pub const CHANGE_FOLDER_PERMISSION: &'static str = "CHANGE_FOLDER_PERMISSION";
10054 pub const COLLABORATION_ACCEPT: &'static str = "COLLABORATION_ACCEPT";
10055 pub const COLLABORATION_EXPIRATION: &'static str = "COLLABORATION_EXPIRATION";
10056 pub const COLLABORATION_INVITE: &'static str = "COLLABORATION_INVITE";
10057 pub const COLLABORATION_REMOVE: &'static str = "COLLABORATION_REMOVE";
10058 pub const COLLABORATION_ROLE_CHANGE: &'static str = "COLLABORATION_ROLE_CHANGE";
10059 pub const COMMENT_CREATE: &'static str = "COMMENT_CREATE";
10060 pub const COMMENT_DELETE: &'static str = "COMMENT_DELETE";
10061 pub const COMMENT_EDIT: &'static str = "COMMENT_EDIT";
10062 pub const CONTENT_WORKFLOW_ABNORMAL_DOWNLOAD_ACTIVITY: &'static str =
10063 "CONTENT_WORKFLOW_ABNORMAL_DOWNLOAD_ACTIVITY";
10064 pub const CONTENT_WORKFLOW_AUTOMATION_ADD: &'static str = "CONTENT_WORKFLOW_AUTOMATION_ADD";
10065 pub const CONTENT_WORKFLOW_AUTOMATION_DELETE: &'static str =
10066 "CONTENT_WORKFLOW_AUTOMATION_DELETE";
10067 pub const CONTENT_WORKFLOW_POLICY_ADD: &'static str = "CONTENT_WORKFLOW_POLICY_ADD";
10068 pub const CONTENT_WORKFLOW_SHARING_POLICY_VIOLATION: &'static str =
10069 "CONTENT_WORKFLOW_SHARING_POLICY_VIOLATION";
10070 pub const CONTENT_WORKFLOW_UPLOAD_POLICY_VIOLATION: &'static str =
10071 "CONTENT_WORKFLOW_UPLOAD_POLICY_VIOLATION";
10072 pub const COPY: &'static str = "COPY";
10073 pub const DATA_RETENTION_CREATE_RETENTION: &'static str = "DATA_RETENTION_CREATE_RETENTION";
10074 pub const DATA_RETENTION_REMOVE_RETENTION: &'static str = "DATA_RETENTION_REMOVE_RETENTION";
10075 pub const DELETE: &'static str = "DELETE";
10076 pub const DELETE_USER: &'static str = "DELETE_USER";
10077 pub const DEVICE_TRUST_CHECK_FAILED: &'static str = "DEVICE_TRUST_CHECK_FAILED";
10078 pub const DOWNLOAD: &'static str = "DOWNLOAD";
10079 pub const EDIT: &'static str = "EDIT";
10080 pub const EDIT_USER: &'static str = "EDIT_USER";
10081 pub const EMAIL_ALIAS_CONFIRM: &'static str = "EMAIL_ALIAS_CONFIRM";
10082 pub const EMAIL_ALIAS_PRIMARY: &'static str = "EMAIL_ALIAS_PRIMARY";
10083 pub const EMAIL_ALIAS_REMOVE: &'static str = "EMAIL_ALIAS_REMOVE";
10084 pub const EMAIL_UPLOAD_DISABLED: &'static str = "EMAIL_UPLOAD_DISABLED";
10085 pub const EMAIL_UPLOAD_ENABLED: &'static str = "EMAIL_UPLOAD_ENABLED";
10086 pub const ENTERPRISE_APP_AUTHORIZATION_UPDATE: &'static str =
10087 "ENTERPRISE_APP_AUTHORIZATION_UPDATE";
10088 pub const EXTERNAL_COLLAB_SECURITY_SETTINGS: &'static str = "EXTERNAL_COLLAB_SECURITY_SETTINGS";
10089 pub const FAILED_LOGIN: &'static str = "FAILED_LOGIN";
10090 pub const FAVORITE: &'static str = "FAVORITE";
10091 pub const FILE_MARKED_MALICIOUS: &'static str = "FILE_MARKED_MALICIOUS";
10092 pub const FILE_REQUEST_CREATE: &'static str = "FILE_REQUEST_CREATE";
10093 pub const FILE_REQUEST_DELETE: &'static str = "FILE_REQUEST_DELETE";
10094 pub const FILE_REQUEST_UPDATE: &'static str = "FILE_REQUEST_UPDATE";
10095 pub const FILE_VERSION_RESTORE: &'static str = "FILE_VERSION_RESTORE";
10096 pub const FILE_WATERMARKED_DOWNLOAD: &'static str = "FILE_WATERMARKED_DOWNLOAD";
10097 pub const GROUP_ADD_ITEM: &'static str = "GROUP_ADD_ITEM";
10098 pub const GROUP_ADD_USER: &'static str = "GROUP_ADD_USER";
10099 pub const GROUP_CREATION: &'static str = "GROUP_CREATION";
10100 pub const GROUP_DELETION: &'static str = "GROUP_DELETION";
10101 pub const GROUP_EDITED: &'static str = "GROUP_EDITED";
10102 pub const GROUP_REMOVE_ITEM: &'static str = "GROUP_REMOVE_ITEM";
10103 pub const GROUP_REMOVE_USER: &'static str = "GROUP_REMOVE_USER";
10104 pub const ILLEGAL_ITEM_OWNERSHIP_TRANSFER_BY_USER: &'static str =
10105 "ILLEGAL_ITEM_OWNERSHIP_TRANSFER_BY_USER";
10106 pub const ITEM_EMAIL_SEND: &'static str = "ITEM_EMAIL_SEND";
10107 pub const ITEM_MODIFY: &'static str = "ITEM_MODIFY";
10108 pub const ITEM_OPEN: &'static str = "ITEM_OPEN";
10109 pub const ITEM_SHARED_UPDATE: &'static str = "ITEM_SHARED_UPDATE";
10110 pub const ITEM_SYNC: &'static str = "ITEM_SYNC";
10111 pub const ITEM_UNSYNC: &'static str = "ITEM_UNSYNC";
10112 pub const LEGAL_HOLD_ASSIGNMENT_CREATE: &'static str = "LEGAL_HOLD_ASSIGNMENT_CREATE";
10113 pub const LEGAL_HOLD_ASSIGNMENT_DELETE: &'static str = "LEGAL_HOLD_ASSIGNMENT_DELETE";
10114 pub const LEGAL_HOLD_POLICY_CREATE: &'static str = "LEGAL_HOLD_POLICY_CREATE";
10115 pub const LEGAL_HOLD_POLICY_DELETE: &'static str = "LEGAL_HOLD_POLICY_DELETE";
10116 pub const LEGAL_HOLD_POLICY_UPDATE: &'static str = "LEGAL_HOLD_POLICY_UPDATE";
10117 pub const LOCK: &'static str = "LOCK";
10118 pub const LOGIN: &'static str = "LOGIN";
10119 pub const METADATA_CASCADE_POLICY_APPLY: &'static str = "METADATA_CASCADE_POLICY_APPLY";
10120 pub const METADATA_CASCADE_POLICY_CREATE: &'static str = "METADATA_CASCADE_POLICY_CREATE";
10121 pub const METADATA_INSTANCE_COPY: &'static str = "METADATA_INSTANCE_COPY";
10122 pub const METADATA_INSTANCE_CREATE: &'static str = "METADATA_INSTANCE_CREATE";
10123 pub const METADATA_INSTANCE_DELETE: &'static str = "METADATA_INSTANCE_DELETE";
10124 pub const METADATA_INSTANCE_UPDATE: &'static str = "METADATA_INSTANCE_UPDATE";
10125 pub const METADATA_TEMPLATE_CREATE: &'static str = "METADATA_TEMPLATE_CREATE";
10126 pub const METADATA_TEMPLATE_DELETE: &'static str = "METADATA_TEMPLATE_DELETE";
10127 pub const METADATA_TEMPLATE_UPDATE: &'static str = "METADATA_TEMPLATE_UPDATE";
10128 pub const MOVE: &'static str = "MOVE";
10129 pub const NEW_USER: &'static str = "NEW_USER";
10130 pub const OAUTH2_ACCESS_TOKEN_REVOKE: &'static str = "OAUTH2_ACCESS_TOKEN_REVOKE";
10131 pub const OAUTH2_REFRESH_TOKEN_REVOKE: &'static str = "OAUTH2_REFRESH_TOKEN_REVOKE";
10132 pub const PREVIEW: &'static str = "PREVIEW";
10133 pub const REMOVE_DEVICE_ASSOCIATION: &'static str = "REMOVE_DEVICE_ASSOCIATION";
10134 pub const REMOVE_LOGIN_ACTIVITY_DEVICE: &'static str = "REMOVE_LOGIN_ACTIVITY_DEVICE";
10135 pub const RENAME: &'static str = "RENAME";
10136 pub const RETENTION_POLICY_ASSIGNMENT_ADD: &'static str = "RETENTION_POLICY_ASSIGNMENT_ADD";
10137 pub const SHARE: &'static str = "SHARE";
10138 pub const SHARED_LINK_SEND: &'static str = "SHARED_LINK_SEND";
10139 pub const SHARE_EXPIRATION: &'static str = "SHARE_EXPIRATION";
10140 pub const SHIELD_ALERT: &'static str = "SHIELD_ALERT";
10141 pub const SHIELD_EXTERNAL_COLLAB_ACCESS_BLOCKED: &'static str =
10142 "SHIELD_EXTERNAL_COLLAB_ACCESS_BLOCKED";
10143 pub const SHIELD_EXTERNAL_COLLAB_ACCESS_BLOCKED_MISSING_JUSTIFICATION: &'static str =
10144 "SHIELD_EXTERNAL_COLLAB_ACCESS_BLOCKED_MISSING_JUSTIFICATION";
10145 pub const SHIELD_EXTERNAL_COLLAB_INVITE_BLOCKED: &'static str =
10146 "SHIELD_EXTERNAL_COLLAB_INVITE_BLOCKED";
10147 pub const SHIELD_EXTERNAL_COLLAB_INVITE_BLOCKED_MISSING_JUSTIFICATION: &'static str =
10148 "SHIELD_EXTERNAL_COLLAB_INVITE_BLOCKED_MISSING_JUSTIFICATION";
10149 pub const SHIELD_JUSTIFICATION_APPROVAL: &'static str = "SHIELD_JUSTIFICATION_APPROVAL";
10150 pub const SHIELD_SHARED_LINK_ACCESS_BLOCKED: &'static str = "SHIELD_SHARED_LINK_ACCESS_BLOCKED";
10151 pub const SHIELD_SHARED_LINK_STATUS_RESTRICTED_ON_CREATE: &'static str =
10152 "SHIELD_SHARED_LINK_STATUS_RESTRICTED_ON_CREATE";
10153 pub const SHIELD_SHARED_LINK_STATUS_RESTRICTED_ON_UPDATE: &'static str =
10154 "SHIELD_SHARED_LINK_STATUS_RESTRICTED_ON_UPDATE";
10155 pub const SIGN_DOCUMENT_ASSIGNED: &'static str = "SIGN_DOCUMENT_ASSIGNED";
10156 pub const SIGN_DOCUMENT_CANCELLED: &'static str = "SIGN_DOCUMENT_CANCELLED";
10157 pub const SIGN_DOCUMENT_COMPLETED: &'static str = "SIGN_DOCUMENT_COMPLETED";
10158 pub const SIGN_DOCUMENT_CONVERTED: &'static str = "SIGN_DOCUMENT_CONVERTED";
10159 pub const SIGN_DOCUMENT_CREATED: &'static str = "SIGN_DOCUMENT_CREATED";
10160 pub const SIGN_DOCUMENT_DECLINED: &'static str = "SIGN_DOCUMENT_DECLINED";
10161 pub const SIGN_DOCUMENT_EXPIRED: &'static str = "SIGN_DOCUMENT_EXPIRED";
10162 pub const SIGN_DOCUMENT_SIGNED: &'static str = "SIGN_DOCUMENT_SIGNED";
10163 pub const SIGN_DOCUMENT_VIEWED_BY_SIGNED: &'static str = "SIGN_DOCUMENT_VIEWED_BY_SIGNED";
10164 pub const SIGNER_DOWNLOADED: &'static str = "SIGNER_DOWNLOADED";
10165 pub const SIGNER_FORWARDED: &'static str = "SIGNER_FORWARDED";
10166 pub const STORAGE_EXPIRATION: &'static str = "STORAGE_EXPIRATION";
10167 pub const TASK_ASSIGNMENT_CREATE: &'static str = "TASK_ASSIGNMENT_CREATE";
10168 pub const TASK_ASSIGNMENT_DELETE: &'static str = "TASK_ASSIGNMENT_DELETE";
10169 pub const TASK_ASSIGNMENT_UPDATE: &'static str = "TASK_ASSIGNMENT_UPDATE";
10170 pub const TASK_CREATE: &'static str = "TASK_CREATE";
10171 pub const TASK_UPDATE: &'static str = "TASK_UPDATE";
10172 pub const TERMS_OF_SERVICE_ACCEPT: &'static str = "TERMS_OF_SERVICE_ACCEPT";
10173 pub const TERMS_OF_SERVICE_REJECT: &'static str = "TERMS_OF_SERVICE_REJECT";
10174 pub const UNDELETE: &'static str = "UNDELETE";
10175 pub const UNFAVORITE: &'static str = "UNFAVORITE";
10176 pub const UNLOCK: &'static str = "UNLOCK";
10177 pub const UNSHARE: &'static str = "UNSHARE";
10178 pub const UPDATE_COLLABORATION_EXPIRATION: &'static str = "UPDATE_COLLABORATION_EXPIRATION";
10179 pub const UPDATE_SHARE_EXPIRATION: &'static str = "UPDATE_SHARE_EXPIRATION";
10180 pub const UPLOAD: &'static str = "UPLOAD";
10181 pub const USER_AUTHENTICATE_OAUTH2_ACCESS_TOKEN_CREATE: &'static str =
10182 "USER_AUTHENTICATE_OAUTH2_ACCESS_TOKEN_CREATE";
10183 pub const WATERMARK_LABEL_CREATE: &'static str = "WATERMARK_LABEL_CREATE";
10184 pub const WATERMARK_LABEL_DELETE: &'static str = "WATERMARK_LABEL_DELETE";
10185 pub const WORKFLOW_AUTOMATION_CREATE: &'static str = "WORKFLOW_AUTOMATION_CREATE";
10186 pub const WORKFLOW_AUTOMATION_DELETE: &'static str = "WORKFLOW_AUTOMATION_DELETE";
10187 pub const WORKFLOW_AUTOMATION_UPDATE: &'static str = "WORKFLOW_AUTOMATION_UPDATE";
10188}
10189
10190#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10191#[serde(transparent)]
10192pub struct PostRetentionLength(pub serde_json::Value);
10193
10194#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10195pub struct RetentionPolicyCreateRequest {
10196 pub policy_name: String,
10197 #[serde(default, skip_serializing_if = "Option::is_none")]
10198 pub description: Option<String>,
10199 pub policy_type: RetentionPolicyPolicyType,
10200 pub disposition_action: RetentionPolicyDispositionAction,
10201 #[serde(default, skip_serializing_if = "Option::is_none")]
10202 pub retention_length: Option<PostRetentionLength>,
10203 #[serde(default, skip_serializing_if = "Option::is_none")]
10204 pub retention_type: Option<RetentionPolicyRetentionType>,
10205 #[serde(default, skip_serializing_if = "Option::is_none")]
10206 pub can_owner_extend_retention: Option<bool>,
10207 #[serde(default, skip_serializing_if = "Option::is_none")]
10208 pub max_extension_length: Option<RetentionPolicyMaxExtensionLengthRequest>,
10209 #[serde(default, skip_serializing_if = "Option::is_none")]
10210 pub are_owners_notified: Option<bool>,
10211 #[serde(default, skip_serializing_if = "Option::is_none")]
10212 pub custom_notification_recipients: Option<Vec<UserMini>>,
10213}
10214
10215#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10216#[serde(transparent)]
10217pub struct PutIdDispositionAction(pub serde_json::Value);
10218
10219#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10220pub struct RetentionPolicyUpdateRequest {
10221 #[serde(
10222 default,
10223 skip_serializing_if = "Option::is_none",
10224 deserialize_with = "double_option"
10225 )]
10226 pub policy_name: Option<Option<String>>,
10227 #[serde(
10228 default,
10229 skip_serializing_if = "Option::is_none",
10230 deserialize_with = "double_option"
10231 )]
10232 pub description: Option<Option<String>>,
10233 #[serde(default, skip_serializing_if = "Option::is_none")]
10234 pub disposition_action: Option<PutIdDispositionAction>,
10235 #[serde(
10236 default,
10237 skip_serializing_if = "Option::is_none",
10238 deserialize_with = "double_option"
10239 )]
10240 pub retention_type: Option<Option<String>>,
10241 #[serde(default, skip_serializing_if = "Option::is_none")]
10242 pub retention_length: Option<PostRetentionLength>,
10243 #[serde(
10244 default,
10245 skip_serializing_if = "Option::is_none",
10246 deserialize_with = "double_option"
10247 )]
10248 pub status: Option<Option<String>>,
10249 #[serde(
10250 default,
10251 skip_serializing_if = "Option::is_none",
10252 deserialize_with = "double_option"
10253 )]
10254 pub can_owner_extend_retention: Option<Option<bool>>,
10255 #[serde(default, skip_serializing_if = "Option::is_none")]
10256 pub max_extension_length: Option<RetentionPolicyMaxExtensionLengthRequest>,
10257 #[serde(
10258 default,
10259 skip_serializing_if = "Option::is_none",
10260 deserialize_with = "double_option"
10261 )]
10262 pub are_owners_notified: Option<Option<bool>>,
10263 #[serde(
10264 default,
10265 skip_serializing_if = "Option::is_none",
10266 deserialize_with = "double_option"
10267 )]
10268 pub custom_notification_recipients: Option<Option<Vec<UserBase>>>,
10269}
10270
10271#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
10272#[serde(transparent)]
10273pub struct AssignToType(pub String);
10274
10275impl AssignToType {
10276 pub const ENTERPRISE: &'static str = "enterprise";
10277 pub const FOLDER: &'static str = "folder";
10278 pub const METADATA_TEMPLATE: &'static str = "metadata_template";
10279}
10280
10281#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10282pub struct PostAssignTo2 {
10283 pub r#type: AssignToType,
10284 #[serde(
10285 default,
10286 skip_serializing_if = "Option::is_none",
10287 deserialize_with = "double_option"
10288 )]
10289 pub id: Option<Option<String>>,
10290}
10291
10292#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10293pub struct PostFilterFields {
10294 #[serde(default, skip_serializing_if = "Option::is_none")]
10295 pub field: Option<String>,
10296 #[serde(default, skip_serializing_if = "Option::is_none")]
10297 pub value: Option<String>,
10298}
10299
10300#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10301pub struct RetentionPolicyAssignmentCreateRequest {
10302 pub policy_id: String,
10303 pub assign_to: PostAssignTo2,
10304 #[serde(default, skip_serializing_if = "Option::is_none")]
10305 pub filter_fields: Option<Vec<PostFilterFields>>,
10306 #[serde(default, skip_serializing_if = "Option::is_none")]
10307 pub start_date_field: Option<String>,
10308}
10309
10310#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10311pub struct LegalHoldPolicyCreateRequest {
10312 pub policy_name: String,
10313 #[serde(default, skip_serializing_if = "Option::is_none")]
10314 pub description: Option<String>,
10315 #[serde(default, skip_serializing_if = "Option::is_none")]
10316 pub filter_started_at: Option<chrono::DateTime<chrono::Utc>>,
10317 #[serde(default, skip_serializing_if = "Option::is_none")]
10318 pub filter_ended_at: Option<chrono::DateTime<chrono::Utc>>,
10319 #[serde(default, skip_serializing_if = "Option::is_none")]
10320 pub is_ongoing: Option<bool>,
10321}
10322
10323#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10324pub struct LegalHoldPolicyUpdateRequest {
10325 #[serde(default, skip_serializing_if = "Option::is_none")]
10326 pub policy_name: Option<String>,
10327 #[serde(default, skip_serializing_if = "Option::is_none")]
10328 pub description: Option<String>,
10329 #[serde(default, skip_serializing_if = "Option::is_none")]
10330 pub release_notes: Option<String>,
10331}
10332
10333#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10334pub struct PostAssignTo3 {
10335 pub r#type: LegalHoldPolicyAssignedItemType,
10336 pub id: String,
10337}
10338
10339#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10340pub struct LegalHoldPolicyAssignmentCreateRequest {
10341 pub policy_id: String,
10342 pub assign_to: PostAssignTo3,
10343}
10344
10345#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
10346#[serde(transparent)]
10347pub struct PostChangeStatusStatus(pub String);
10348
10349impl PostChangeStatusStatus {
10350 pub const PENDING: &'static str = "pending";
10351 pub const DISABLED: &'static str = "disabled";
10352}
10353
10354#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10355pub struct ChangeStatusCreateRequest {
10356 pub id: String,
10357 pub status: PostChangeStatusStatus,
10358}
10359
10360#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10361pub struct ShieldInformationBarrierCreateRequest {
10362 pub enterprise: EnterpriseBase,
10363}
10364
10365#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10366pub struct ShieldInformationBarrierSegmentUpdateRequest {
10367 #[serde(default, skip_serializing_if = "Option::is_none")]
10368 pub name: Option<String>,
10369 #[serde(
10370 default,
10371 skip_serializing_if = "Option::is_none",
10372 deserialize_with = "double_option"
10373 )]
10374 pub description: Option<Option<String>>,
10375}
10376
10377#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10378pub struct ShieldInformationBarrierSegmentCreateRequest {
10379 pub shield_information_barrier: ShieldInformationBarrierBase,
10380 pub name: String,
10381 #[serde(default, skip_serializing_if = "Option::is_none")]
10382 pub description: Option<String>,
10383}
10384
10385#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10386pub struct ShieldInformationBarrierSegmentMemberCreateRequest {
10387 #[serde(default, skip_serializing_if = "Option::is_none")]
10388 pub r#type: Option<ShieldInformationBarrierSegmentMemberType>,
10389 #[serde(default, skip_serializing_if = "Option::is_none")]
10390 pub shield_information_barrier: Option<ShieldInformationBarrierBase>,
10391 pub shield_information_barrier_segment:
10392 ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment,
10393 pub user: UserBase,
10394}
10395
10396#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10397pub struct ShieldInformationBarrierSegmentRestrictionCreateRequest {
10398 pub r#type: ShieldInformationBarrierSegmentRestrictionType,
10399 #[serde(default, skip_serializing_if = "Option::is_none")]
10400 pub shield_information_barrier: Option<ShieldInformationBarrierBase>,
10401 pub shield_information_barrier_segment:
10402 ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment,
10403 pub restricted_segment: ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment,
10404}
10405
10406#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
10407#[serde(transparent)]
10408pub struct GetTosType(pub String);
10409
10410impl GetTosType {
10411 pub const EXTERNAL: &'static str = "external";
10412 pub const MANAGED: &'static str = "managed";
10413}
10414
10415#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10416pub struct TermsOfServiceCreateRequest {
10417 pub status: TermsOfServiceStatus,
10418 #[serde(default, skip_serializing_if = "Option::is_none")]
10419 pub tos_type: Option<GetTosType>,
10420 pub text: String,
10421}
10422
10423#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10424pub struct TermsOfServiceUpdateRequest {
10425 pub status: TermsOfServiceStatus,
10426 pub text: String,
10427}
10428
10429#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10430pub struct PostTos {
10431 pub r#type: TermsOfServiceType,
10432 pub id: String,
10433}
10434
10435#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10436pub struct TermsOfServiceUserStatuseCreateRequest {
10437 pub tos: PostTos,
10438 pub user: CollaboratorVariableVariableValue,
10439 pub is_accepted: bool,
10440}
10441
10442#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10443pub struct TermsOfServiceUserStatuseUpdateRequest {
10444 pub is_accepted: bool,
10445}
10446
10447#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10448pub struct CollaborationWhitelistEntriesCreateRequest {
10449 pub domain: String,
10450 pub direction: CollaborationAllowlistEntryDirection,
10451}
10452
10453#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10454pub struct CollaborationWhitelistExemptTargetsCreateRequest {
10455 pub user: AttributesParent,
10456}
10457
10458#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
10459#[serde(transparent)]
10460pub struct GetResolvedForType(pub String);
10461
10462impl GetResolvedForType {
10463 pub const USER: &'static str = "user";
10464 pub const ENTERPRISE: &'static str = "enterprise";
10465}
10466
10467#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10468pub struct PostStoragePolicy {
10469 pub r#type: StoragePolicyType,
10470 pub id: String,
10471}
10472
10473#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10474pub struct PostAssignedTo {
10475 pub r#type: GetResolvedForType,
10476 pub id: String,
10477}
10478
10479#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10480pub struct StoragePolicyAssignmentCreateRequest {
10481 pub storage_policy: PostStoragePolicy,
10482 pub assigned_to: PostAssignedTo,
10483}
10484
10485#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10486pub struct StoragePolicyAssignmentUpdateRequest {
10487 pub storage_policy: PostStoragePolicy,
10488}
10489
10490#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
10491#[serde(transparent)]
10492pub struct PostIdStartType(pub String);
10493
10494impl PostIdStartType {
10495 pub const WORKFLOW_PARAMETERS: &'static str = "workflow_parameters";
10496}
10497
10498#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10499pub struct PostIdStartFlow {
10500 #[serde(default, skip_serializing_if = "Option::is_none")]
10501 pub r#type: Option<String>,
10502 #[serde(default, skip_serializing_if = "Option::is_none")]
10503 pub id: Option<String>,
10504}
10505
10506#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10507pub struct WorkflowStartRequest {
10508 #[serde(default, skip_serializing_if = "Option::is_none")]
10509 pub r#type: Option<PostIdStartType>,
10510 pub flow: PostIdStartFlow,
10511 pub files: Vec<PutSkillInvocationIdFile>,
10512 pub folder: MetadataCascadePolicyParent,
10513 #[serde(default, skip_serializing_if = "Option::is_none")]
10514 pub outcomes: Option<Vec<Outcome>>,
10515}
10516
10517#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10518pub struct SlackUpdateRequest {
10519 #[serde(default, skip_serializing_if = "Option::is_none")]
10520 pub box_item: Option<IntegrationMappingBoxItemSlack>,
10521 #[serde(default, skip_serializing_if = "Option::is_none")]
10522 pub options: Option<IntegrationMappingSlackOptions>,
10523}
10524
10525#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10526pub struct TeamUpdateRequest {
10527 #[serde(default, skip_serializing_if = "Option::is_none")]
10528 pub box_item: Option<FolderReference>,
10529}
10530
10531#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
10532#[serde(transparent)]
10533pub struct GetAgentDefaultMode(pub String);
10534
10535impl GetAgentDefaultMode {
10536 pub const ASK: &'static str = "ask";
10537 pub const TEXT_GEN: &'static str = "text_gen";
10538 pub const EXTRACT: &'static str = "extract";
10539 pub const EXTRACT_STRUCTURED: &'static str = "extract_structured";
10540}
10541
10542#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10543pub struct MetadataTaxonomyCreateRequest {
10544 #[serde(default, skip_serializing_if = "Option::is_none")]
10545 pub key: Option<String>,
10546 #[serde(rename = "displayName")]
10547 pub display_name: String,
10548 pub namespace: String,
10549}
10550
10551#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10552pub struct MetadataTaxonomyUpdateRequest {
10553 #[serde(rename = "displayName")]
10554 pub display_name: String,
10555}
10556
10557#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10558pub struct LevelUpdateRequest {
10559 #[serde(rename = "displayName")]
10560 pub display_name: String,
10561 #[serde(default, skip_serializing_if = "Option::is_none")]
10562 pub description: Option<String>,
10563}
10564
10565#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10566pub struct NodesCreateRequest {
10567 #[serde(rename = "displayName")]
10568 pub display_name: String,
10569 pub level: i64,
10570 #[serde(rename = "parentId", default, skip_serializing_if = "Option::is_none")]
10571 pub parent_id: Option<String>,
10572}
10573
10574#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10575pub struct NodeUpdateRequest {
10576 #[serde(
10577 rename = "displayName",
10578 default,
10579 skip_serializing_if = "Option::is_none"
10580 )]
10581 pub display_name: Option<String>,
10582}
10583
10584#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10585pub struct Archive {
10586 pub id: String,
10587 pub r#type: ArchiveType,
10588 pub name: String,
10589 pub size: i64,
10590 #[serde(
10591 default,
10592 skip_serializing_if = "Option::is_none",
10593 deserialize_with = "double_option"
10594 )]
10595 pub description: Option<Option<String>>,
10596 #[serde(default, skip_serializing_if = "Option::is_none")]
10597 pub owned_by: Option<ArchiveOwnedBy>,
10598}
10599
10600#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10601pub struct Archives {
10602 #[serde(default, skip_serializing_if = "Option::is_none")]
10603 pub entries: Option<Vec<Archive>>,
10604 #[serde(default, skip_serializing_if = "Option::is_none")]
10605 pub limit: Option<i64>,
10606 #[serde(
10607 default,
10608 skip_serializing_if = "Option::is_none",
10609 deserialize_with = "double_option"
10610 )]
10611 pub next_marker: Option<Option<String>>,
10612}
10613
10614#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10615pub struct CollaborationPermissions {
10616 #[serde(default, skip_serializing_if = "Option::is_none")]
10617 pub is_co_owner_role_enabled: Option<bool>,
10618 #[serde(default, skip_serializing_if = "Option::is_none")]
10619 pub is_editor_role_enabled: Option<bool>,
10620 #[serde(default, skip_serializing_if = "Option::is_none")]
10621 pub is_previewer_role_enabled: Option<bool>,
10622 #[serde(default, skip_serializing_if = "Option::is_none")]
10623 pub is_previewer_uploader_role_enabled: Option<bool>,
10624 #[serde(default, skip_serializing_if = "Option::is_none")]
10625 pub is_uploader_role_enabled: Option<bool>,
10626 #[serde(default, skip_serializing_if = "Option::is_none")]
10627 pub is_viewer_role_enabled: Option<bool>,
10628 #[serde(default, skip_serializing_if = "Option::is_none")]
10629 pub is_viewer_uploader_role_enabled: Option<bool>,
10630}
10631
10632#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10633pub struct CustomSessionDurationGroupItem {
10634 #[serde(default, skip_serializing_if = "Option::is_none")]
10635 pub id: Option<String>,
10636 #[serde(default, skip_serializing_if = "Option::is_none")]
10637 pub name: Option<String>,
10638}
10639
10640#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10641pub struct DocGenBatchBase {
10642 pub id: String,
10643 pub r#type: DocGenBatchBaseType,
10644}
10645
10646#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10647pub struct DocGenBatchCreateRequest {
10648 pub file: FileReference,
10649 #[serde(default, skip_serializing_if = "Option::is_none")]
10650 pub file_version: Option<FileVersionBase>,
10651 pub input_source: String,
10652 pub destination_folder: DocGenBatchCreateRequestDestinationFolder,
10653 pub output_type: String,
10654 pub document_generation_data: Vec<DocGenDocumentGenerationData>,
10655}
10656
10657#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10658pub struct DocGenDocumentGenerationData {
10659 pub generated_file_name: String,
10660 pub user_input: std::collections::HashMap<String, serde_json::Value>,
10661}
10662
10663#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10664pub struct DocGenJob {
10665 pub id: String,
10666 pub r#type: DocGenJobType,
10667 pub batch: DocGenBatchBase,
10668 pub template_file: FileReference,
10669 pub template_file_version: FileVersionBase,
10670 #[serde(default, skip_serializing_if = "Option::is_none")]
10671 pub output_file: Option<DocGenJobOutputFile>,
10672 #[serde(default, skip_serializing_if = "Option::is_none")]
10673 pub output_file_version: Option<DocGenJobOutputFileVersion>,
10674 pub status: DocGenJobStatus,
10675 pub output_type: String,
10676 #[serde(
10677 default,
10678 skip_serializing_if = "Option::is_none",
10679 deserialize_with = "double_option"
10680 )]
10681 pub failures: Option<Option<DocGenJobFailures>>,
10682}
10683
10684#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10685pub struct DocGenJobBase {
10686 pub id: String,
10687 pub r#type: DocGenJobType,
10688}
10689
10690#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10691pub struct DocGenJobFull {
10692 pub id: String,
10693 pub r#type: DocGenJobType,
10694 pub batch: DocGenBatchBase,
10695 pub template_file: FileReference,
10696 pub template_file_version: FileVersionBase,
10697 #[serde(default, skip_serializing_if = "Option::is_none")]
10698 pub output_file: Option<DocGenJobOutputFile>,
10699 #[serde(default, skip_serializing_if = "Option::is_none")]
10700 pub output_file_version: Option<DocGenJobOutputFileVersion>,
10701 pub status: DocGenJobStatus,
10702 pub output_type: String,
10703 #[serde(
10704 default,
10705 skip_serializing_if = "Option::is_none",
10706 deserialize_with = "double_option"
10707 )]
10708 pub failures: Option<Option<DocGenJobFailures>>,
10709 #[serde(default, skip_serializing_if = "Option::is_none")]
10710 pub created_at: Option<String>,
10711 pub created_by: UserBase,
10712 pub enterprise: EnterpriseReference,
10713 pub source: String,
10714}
10715
10716#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10717pub struct DocGenJobs {
10718 #[serde(default, skip_serializing_if = "Option::is_none")]
10719 pub limit: Option<i64>,
10720 #[serde(
10721 default,
10722 skip_serializing_if = "Option::is_none",
10723 deserialize_with = "double_option"
10724 )]
10725 pub next_marker: Option<Option<String>>,
10726 #[serde(
10727 default,
10728 skip_serializing_if = "Option::is_none",
10729 deserialize_with = "double_option"
10730 )]
10731 pub prev_marker: Option<Option<String>>,
10732 #[serde(default, skip_serializing_if = "Option::is_none")]
10733 pub entries: Option<Vec<DocGenJob>>,
10734}
10735
10736#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10737pub struct DocGenJobsFull {
10738 #[serde(default, skip_serializing_if = "Option::is_none")]
10739 pub limit: Option<i64>,
10740 #[serde(
10741 default,
10742 skip_serializing_if = "Option::is_none",
10743 deserialize_with = "double_option"
10744 )]
10745 pub next_marker: Option<Option<String>>,
10746 #[serde(
10747 default,
10748 skip_serializing_if = "Option::is_none",
10749 deserialize_with = "double_option"
10750 )]
10751 pub prev_marker: Option<Option<String>>,
10752 #[serde(default, skip_serializing_if = "Option::is_none")]
10753 pub entries: Option<Vec<DocGenJobFull>>,
10754}
10755
10756#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10757pub struct DocGenTag {
10758 pub tag_content: String,
10759 pub tag_type: DocGenTagTagType,
10760 pub json_paths: Vec<String>,
10761}
10762
10763#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10764pub struct DocGenTags {
10765 #[serde(default, skip_serializing_if = "Option::is_none")]
10766 pub limit: Option<i64>,
10767 #[serde(
10768 default,
10769 skip_serializing_if = "Option::is_none",
10770 deserialize_with = "double_option"
10771 )]
10772 pub next_marker: Option<Option<String>>,
10773 #[serde(
10774 default,
10775 skip_serializing_if = "Option::is_none",
10776 deserialize_with = "double_option"
10777 )]
10778 pub prev_marker: Option<Option<String>>,
10779 #[serde(default, skip_serializing_if = "Option::is_none")]
10780 pub entries: Option<Vec<DocGenTag>>,
10781}
10782
10783#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10784pub struct DocGenTagsProcessingMessage {
10785 pub message: String,
10786}
10787
10788#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10789pub struct DocGenTemplate {
10790 #[serde(default, skip_serializing_if = "Option::is_none")]
10791 pub file: Option<FileReference>,
10792 #[serde(
10793 default,
10794 skip_serializing_if = "Option::is_none",
10795 deserialize_with = "double_option"
10796 )]
10797 pub file_name: Option<Option<String>>,
10798}
10799
10800#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10801pub struct DocGenTemplateBase {
10802 #[serde(default, skip_serializing_if = "Option::is_none")]
10803 pub file: Option<FileReference>,
10804}
10805
10806#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10807pub struct DocGenTemplateCreateRequest {
10808 pub file: FileReference,
10809}
10810
10811#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10812pub struct DocGenTemplates {
10813 #[serde(default, skip_serializing_if = "Option::is_none")]
10814 pub limit: Option<i64>,
10815 #[serde(
10816 default,
10817 skip_serializing_if = "Option::is_none",
10818 deserialize_with = "double_option"
10819 )]
10820 pub next_marker: Option<Option<String>>,
10821 #[serde(
10822 default,
10823 skip_serializing_if = "Option::is_none",
10824 deserialize_with = "double_option"
10825 )]
10826 pub prev_marker: Option<Option<String>>,
10827 #[serde(default, skip_serializing_if = "Option::is_none")]
10828 pub entries: Option<Vec<DocGenTemplate>>,
10829}
10830
10831#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10832pub struct EnterpriseConfiguration {
10833 #[serde(default, skip_serializing_if = "Option::is_none")]
10834 pub id: Option<String>,
10835 #[serde(default, skip_serializing_if = "Option::is_none")]
10836 pub r#type: Option<EnterpriseConfigurationType>,
10837 #[serde(default, skip_serializing_if = "Option::is_none")]
10838 pub security: Option<EnterpriseConfigurationSecurity2>,
10839 #[serde(default, skip_serializing_if = "Option::is_none")]
10840 pub content_and_sharing: Option<EnterpriseConfigurationContentAndSharing2>,
10841 #[serde(default, skip_serializing_if = "Option::is_none")]
10842 pub user_settings: Option<EnterpriseConfigurationUserSettings2>,
10843 #[serde(default, skip_serializing_if = "Option::is_none")]
10844 pub shield: Option<EnterpriseConfigurationShield2>,
10845}
10846
10847#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10848pub struct EnterpriseConfigurationContentAndSharing {
10849 #[serde(default, skip_serializing_if = "Option::is_none")]
10850 pub enterprise_feature_settings: Option<Vec<EnterpriseFeatureSettingsItem>>,
10851 #[serde(default, skip_serializing_if = "Option::is_none")]
10852 pub sharing_item_type: Option<EnterpriseConfigurationItemString>,
10853 #[serde(default, skip_serializing_if = "Option::is_none")]
10854 pub shared_link_company_definition: Option<EnterpriseConfigurationItemString>,
10855 #[serde(default, skip_serializing_if = "Option::is_none")]
10856 pub shared_link_access: Option<EnterpriseConfigurationItemString>,
10857 #[serde(default, skip_serializing_if = "Option::is_none")]
10858 pub shared_link_default_access: Option<EnterpriseConfigurationItemString>,
10859 #[serde(default, skip_serializing_if = "Option::is_none")]
10860 pub shared_link_default_permissions_selected:
10861 Option<EnterpriseConfigurationContentAndSharingSharedLinkDefaultPermissionsSelected>,
10862 #[serde(default, skip_serializing_if = "Option::is_none")]
10863 pub is_open_custom_urls_disabled: Option<EnterpriseConfigurationItemBoolean>,
10864 #[serde(default, skip_serializing_if = "Option::is_none")]
10865 pub is_custom_domain_hidden_in_shared_link: Option<EnterpriseConfigurationItemBoolean>,
10866 #[serde(default, skip_serializing_if = "Option::is_none")]
10867 pub collaboration_permissions:
10868 Option<EnterpriseConfigurationContentAndSharingCollaborationPermissions>,
10869 #[serde(default, skip_serializing_if = "Option::is_none")]
10870 pub default_collaboration_role: Option<EnterpriseConfigurationItemString>,
10871 #[serde(default, skip_serializing_if = "Option::is_none")]
10872 pub is_invite_privilege_restricted: Option<EnterpriseConfigurationItemBoolean>,
10873 #[serde(default, skip_serializing_if = "Option::is_none")]
10874 pub collaboration_restrictions:
10875 Option<EnterpriseConfigurationContentAndSharingCollaborationRestrictions>,
10876 #[serde(default, skip_serializing_if = "Option::is_none")]
10877 pub is_collaborator_invite_links_disabled: Option<EnterpriseConfigurationItemBoolean>,
10878 #[serde(default, skip_serializing_if = "Option::is_none")]
10879 pub is_invite_group_collaborator_disabled: Option<EnterpriseConfigurationItemBoolean>,
10880 #[serde(default, skip_serializing_if = "Option::is_none")]
10881 pub is_ownership_transfer_restricted: Option<EnterpriseConfigurationItemBoolean>,
10882 #[serde(default, skip_serializing_if = "Option::is_none")]
10883 pub external_collaboration_status:
10884 Option<EnterpriseConfigurationContentAndSharingExternalCollaborationStatus>,
10885 #[serde(default, skip_serializing_if = "Option::is_none")]
10886 pub external_collaboration_allowlist_users:
10887 Option<EnterpriseConfigurationContentAndSharingExternalCollaborationAllowlistUsers>,
10888 #[serde(default, skip_serializing_if = "Option::is_none")]
10889 pub is_watermarking_enterprise_feature_enabled: Option<EnterpriseConfigurationItemBoolean>,
10890 #[serde(default, skip_serializing_if = "Option::is_none")]
10891 pub is_root_content_creation_restricted: Option<EnterpriseConfigurationItemBoolean>,
10892 #[serde(default, skip_serializing_if = "Option::is_none")]
10893 pub is_tag_creation_restricted: Option<EnterpriseConfigurationItemBoolean>,
10894 #[serde(default, skip_serializing_if = "Option::is_none")]
10895 pub tag_creation_restriction: Option<EnterpriseConfigurationItemString>,
10896 #[serde(default, skip_serializing_if = "Option::is_none")]
10897 pub is_email_uploads_enabled: Option<EnterpriseConfigurationItemBoolean>,
10898 #[serde(default, skip_serializing_if = "Option::is_none")]
10899 pub is_custom_settings_enabled: Option<EnterpriseConfigurationItemBoolean>,
10900 #[serde(default, skip_serializing_if = "Option::is_none")]
10901 pub is_forms_login_required: Option<EnterpriseConfigurationItemBoolean>,
10902 #[serde(default, skip_serializing_if = "Option::is_none")]
10903 pub is_forms_branding_default_enabled: Option<EnterpriseConfigurationItemBoolean>,
10904 #[serde(default, skip_serializing_if = "Option::is_none")]
10905 pub is_cc_free_trial_active: Option<EnterpriseConfigurationItemBoolean>,
10906 #[serde(default, skip_serializing_if = "Option::is_none")]
10907 pub is_file_request_editors_allowed: Option<EnterpriseConfigurationItemBoolean>,
10908 #[serde(default, skip_serializing_if = "Option::is_none")]
10909 pub is_file_request_branding_default_enabled: Option<EnterpriseConfigurationItemBoolean>,
10910 #[serde(default, skip_serializing_if = "Option::is_none")]
10911 pub is_file_request_login_required: Option<EnterpriseConfigurationItemBoolean>,
10912 #[serde(default, skip_serializing_if = "Option::is_none")]
10913 pub is_shared_links_expiration_enabled: Option<EnterpriseConfigurationItemBoolean>,
10914 #[serde(default, skip_serializing_if = "Option::is_none")]
10915 pub shared_links_expiration_days: Option<EnterpriseConfigurationItemInteger>,
10916 #[serde(default, skip_serializing_if = "Option::is_none")]
10917 pub is_public_shared_links_expiration_enabled: Option<EnterpriseConfigurationItemBoolean>,
10918 #[serde(default, skip_serializing_if = "Option::is_none")]
10919 pub public_shared_links_expiration_days: Option<EnterpriseConfigurationItemInteger>,
10920 #[serde(default, skip_serializing_if = "Option::is_none")]
10921 pub shared_expiration_target: Option<EnterpriseConfigurationItemString>,
10922 #[serde(default, skip_serializing_if = "Option::is_none")]
10923 pub is_shared_links_expiration_notification_enabled: Option<EnterpriseConfigurationItemBoolean>,
10924 #[serde(default, skip_serializing_if = "Option::is_none")]
10925 pub shared_links_expiration_notification_days: Option<EnterpriseConfigurationItemInteger>,
10926 #[serde(default, skip_serializing_if = "Option::is_none")]
10927 pub is_shared_links_expiration_notification_prevented:
10928 Option<EnterpriseConfigurationItemBoolean>,
10929 #[serde(default, skip_serializing_if = "Option::is_none")]
10930 pub is_auto_delete_enabled: Option<EnterpriseConfigurationItemBoolean>,
10931 #[serde(default, skip_serializing_if = "Option::is_none")]
10932 pub auto_delete_days: Option<EnterpriseConfigurationItemInteger>,
10933 #[serde(default, skip_serializing_if = "Option::is_none")]
10934 pub is_auto_delete_expiration_modification_prevented:
10935 Option<EnterpriseConfigurationItemBoolean>,
10936 #[serde(default, skip_serializing_if = "Option::is_none")]
10937 pub auto_delete_target: Option<EnterpriseConfigurationItemString>,
10938 #[serde(default, skip_serializing_if = "Option::is_none")]
10939 pub is_collaboration_expiration_enabled: Option<EnterpriseConfigurationItemBoolean>,
10940 #[serde(default, skip_serializing_if = "Option::is_none")]
10941 pub collaboration_expiration_days: Option<EnterpriseConfigurationItemInteger>,
10942 #[serde(default, skip_serializing_if = "Option::is_none")]
10943 pub is_collaboration_expiration_modification_prevented:
10944 Option<EnterpriseConfigurationItemBoolean>,
10945 #[serde(default, skip_serializing_if = "Option::is_none")]
10946 pub is_collaboration_expiration_notification_enabled:
10947 Option<EnterpriseConfigurationItemBoolean>,
10948 #[serde(default, skip_serializing_if = "Option::is_none")]
10949 pub collaboration_expiration_target: Option<EnterpriseConfigurationItemString>,
10950 #[serde(default, skip_serializing_if = "Option::is_none")]
10951 pub trash_auto_clear_time: Option<EnterpriseConfigurationItemInteger>,
10952 #[serde(default, skip_serializing_if = "Option::is_none")]
10953 pub permanent_deletion_access: Option<EnterpriseConfigurationItemString>,
10954 #[serde(default, skip_serializing_if = "Option::is_none")]
10955 pub permanent_deletion_allowlist_users:
10956 Option<EnterpriseConfigurationContentAndSharingExternalCollaborationAllowlistUsers>,
10957}
10958
10959#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10960pub struct EnterpriseConfigurationItem {
10961 #[serde(default, skip_serializing_if = "Option::is_none")]
10962 pub is_used: Option<bool>,
10963}
10964
10965#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10966pub struct EnterpriseConfigurationItemBoolean {
10967 #[serde(default, skip_serializing_if = "Option::is_none")]
10968 pub is_used: Option<bool>,
10969 #[serde(
10970 default,
10971 skip_serializing_if = "Option::is_none",
10972 deserialize_with = "double_option"
10973 )]
10974 pub value: Option<Option<bool>>,
10975}
10976
10977#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10978pub struct EnterpriseConfigurationItemInteger {
10979 #[serde(default, skip_serializing_if = "Option::is_none")]
10980 pub is_used: Option<bool>,
10981 #[serde(
10982 default,
10983 skip_serializing_if = "Option::is_none",
10984 deserialize_with = "double_option"
10985 )]
10986 pub value: Option<Option<i64>>,
10987}
10988
10989#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
10990pub struct EnterpriseConfigurationItemString {
10991 #[serde(default, skip_serializing_if = "Option::is_none")]
10992 pub is_used: Option<bool>,
10993 #[serde(
10994 default,
10995 skip_serializing_if = "Option::is_none",
10996 deserialize_with = "double_option"
10997 )]
10998 pub value: Option<Option<String>>,
10999}
11000
11001#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11002pub struct EnterpriseConfigurationSecurity {
11003 #[serde(default, skip_serializing_if = "Option::is_none")]
11004 pub is_managed_user_signup_enabled: Option<EnterpriseConfigurationItemBoolean>,
11005 #[serde(default, skip_serializing_if = "Option::is_none")]
11006 pub is_managed_user_signup_notification_enabled: Option<EnterpriseConfigurationItemBoolean>,
11007 #[serde(default, skip_serializing_if = "Option::is_none")]
11008 pub is_managed_user_signup_corporate_email_enabled: Option<EnterpriseConfigurationItemBoolean>,
11009 #[serde(default, skip_serializing_if = "Option::is_none")]
11010 pub is_new_user_notification_daily_digest_enabled: Option<EnterpriseConfigurationItemBoolean>,
11011 #[serde(default, skip_serializing_if = "Option::is_none")]
11012 pub is_managed_user_email_change_disabled: Option<EnterpriseConfigurationItemBoolean>,
11013 #[serde(default, skip_serializing_if = "Option::is_none")]
11014 pub is_multi_factor_auth_required: Option<EnterpriseConfigurationItemBoolean>,
11015 #[serde(default, skip_serializing_if = "Option::is_none")]
11016 pub is_weak_password_prevention_enabled: Option<EnterpriseConfigurationItemBoolean>,
11017 #[serde(default, skip_serializing_if = "Option::is_none")]
11018 pub is_password_leak_detection_enabled: Option<EnterpriseConfigurationItemBoolean>,
11019 #[serde(default, skip_serializing_if = "Option::is_none")]
11020 pub last_password_reset_at: Option<EnterpriseConfigurationSecurityLastPasswordResetAt>,
11021 #[serde(default, skip_serializing_if = "Option::is_none")]
11022 pub is_password_request_notification_enabled: Option<EnterpriseConfigurationItemBoolean>,
11023 #[serde(default, skip_serializing_if = "Option::is_none")]
11024 pub is_password_change_notification_enabled: Option<EnterpriseConfigurationItemBoolean>,
11025 #[serde(default, skip_serializing_if = "Option::is_none")]
11026 pub is_strong_password_for_ext_collab_enabled: Option<EnterpriseConfigurationItemBoolean>,
11027 #[serde(default, skip_serializing_if = "Option::is_none")]
11028 pub is_managed_user_migration_disabled: Option<EnterpriseConfigurationItemBoolean>,
11029 #[serde(default, skip_serializing_if = "Option::is_none")]
11030 pub join_link: Option<EnterpriseConfigurationItemString>,
11031 #[serde(default, skip_serializing_if = "Option::is_none")]
11032 pub join_url: Option<EnterpriseConfigurationItemString>,
11033 #[serde(default, skip_serializing_if = "Option::is_none")]
11034 pub failed_login_attempts_to_trigger_admin_notification:
11035 Option<EnterpriseConfigurationItemInteger>,
11036 #[serde(default, skip_serializing_if = "Option::is_none")]
11037 pub password_min_length: Option<EnterpriseConfigurationItemInteger>,
11038 #[serde(default, skip_serializing_if = "Option::is_none")]
11039 pub password_min_uppercase_characters: Option<EnterpriseConfigurationItemInteger>,
11040 #[serde(default, skip_serializing_if = "Option::is_none")]
11041 pub password_min_numeric_characters: Option<EnterpriseConfigurationItemInteger>,
11042 #[serde(default, skip_serializing_if = "Option::is_none")]
11043 pub password_min_special_characters: Option<EnterpriseConfigurationItemInteger>,
11044 #[serde(default, skip_serializing_if = "Option::is_none")]
11045 pub password_reset_frequency: Option<EnterpriseConfigurationItemString>,
11046 #[serde(default, skip_serializing_if = "Option::is_none")]
11047 pub previous_password_reuse_limit: Option<EnterpriseConfigurationItemString>,
11048 #[serde(default, skip_serializing_if = "Option::is_none")]
11049 pub session_duration: Option<EnterpriseConfigurationItemString>,
11050 #[serde(default, skip_serializing_if = "Option::is_none")]
11051 pub external_collab_multi_factor_auth_settings:
11052 Option<EnterpriseConfigurationSecurityExternalCollabMultiFactorAuthSettings>,
11053 #[serde(default, skip_serializing_if = "Option::is_none")]
11054 pub keysafe: Option<EnterpriseConfigurationSecurityKeysafe>,
11055 #[serde(default, skip_serializing_if = "Option::is_none")]
11056 pub is_custom_session_duration_enabled: Option<EnterpriseConfigurationItemBoolean>,
11057 #[serde(default, skip_serializing_if = "Option::is_none")]
11058 pub custom_session_duration_value: Option<EnterpriseConfigurationItemString>,
11059 #[serde(default, skip_serializing_if = "Option::is_none")]
11060 pub custom_session_duration_groups:
11061 Option<EnterpriseConfigurationSecurityCustomSessionDurationGroups>,
11062 #[serde(default, skip_serializing_if = "Option::is_none")]
11063 pub multi_factor_auth_type: Option<EnterpriseConfigurationItemString>,
11064 #[serde(default, skip_serializing_if = "Option::is_none")]
11065 pub enforced_mfa_frequency: Option<EnterpriseConfigurationSecurityEnforcedMfaFrequency>,
11066}
11067
11068#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11069pub struct EnterpriseConfigurationShield {
11070 #[serde(default, skip_serializing_if = "Option::is_none")]
11071 pub shield_rules: Option<Vec<ShieldRuleItem>>,
11072}
11073
11074#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11075pub struct EnterpriseConfigurationUserSettings {
11076 #[serde(default, skip_serializing_if = "Option::is_none")]
11077 pub enterprise_feature_settings: Option<Vec<EnterpriseFeatureSettingsItem>>,
11078 #[serde(default, skip_serializing_if = "Option::is_none")]
11079 pub user_invites_expiration_time_frame: Option<EnterpriseConfigurationItemString>,
11080 #[serde(default, skip_serializing_if = "Option::is_none")]
11081 pub is_username_change_restricted: Option<EnterpriseConfigurationItemBoolean>,
11082 #[serde(default, skip_serializing_if = "Option::is_none")]
11083 pub is_box_sync_restricted_for_new_users: Option<EnterpriseConfigurationItemBoolean>,
11084 #[serde(default, skip_serializing_if = "Option::is_none")]
11085 pub is_view_all_users_enabled_for_new_users: Option<EnterpriseConfigurationItemBoolean>,
11086 #[serde(default, skip_serializing_if = "Option::is_none")]
11087 pub is_device_limit_exemption_enabled_for_new_users: Option<EnterpriseConfigurationItemBoolean>,
11088 #[serde(default, skip_serializing_if = "Option::is_none")]
11089 pub is_external_collaboration_restricted_for_new_users:
11090 Option<EnterpriseConfigurationItemBoolean>,
11091 #[serde(default, skip_serializing_if = "Option::is_none")]
11092 pub is_unlimited_storage_enabled_for_new_users: Option<EnterpriseConfigurationItemBoolean>,
11093 #[serde(default, skip_serializing_if = "Option::is_none")]
11094 pub new_user_default_storage_limit: Option<EnterpriseConfigurationItemInteger>,
11095 #[serde(default, skip_serializing_if = "Option::is_none")]
11096 pub new_user_default_timezone: Option<EnterpriseConfigurationItemString>,
11097 #[serde(default, skip_serializing_if = "Option::is_none")]
11098 pub new_user_default_language: Option<EnterpriseConfigurationItemString>,
11099 #[serde(default, skip_serializing_if = "Option::is_none")]
11100 pub is_enterprise_sso_required: Option<EnterpriseConfigurationItemBoolean>,
11101 #[serde(default, skip_serializing_if = "Option::is_none")]
11102 pub is_enterprise_sso_in_testing: Option<EnterpriseConfigurationItemBoolean>,
11103 #[serde(default, skip_serializing_if = "Option::is_none")]
11104 pub is_sso_auto_add_groups_enabled: Option<EnterpriseConfigurationItemBoolean>,
11105 #[serde(default, skip_serializing_if = "Option::is_none")]
11106 pub is_sso_auto_add_user_to_groups_enabled: Option<EnterpriseConfigurationItemBoolean>,
11107 #[serde(default, skip_serializing_if = "Option::is_none")]
11108 pub is_sso_auto_remove_user_from_groups_enabled: Option<EnterpriseConfigurationItemBoolean>,
11109 #[serde(default, skip_serializing_if = "Option::is_none")]
11110 pub user_tracking_codes: Option<EnterpriseConfigurationUserSettingsUserTrackingCodes>,
11111 #[serde(default, skip_serializing_if = "Option::is_none")]
11112 pub number_of_user_tracking_codes_remaining: Option<EnterpriseConfigurationItemInteger>,
11113 #[serde(default, skip_serializing_if = "Option::is_none")]
11114 pub is_instant_login_restricted: Option<EnterpriseConfigurationItemBoolean>,
11115}
11116
11117#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11118pub struct EnterpriseFeatureSetting {
11119 #[serde(
11120 default,
11121 skip_serializing_if = "Option::is_none",
11122 deserialize_with = "double_option"
11123 )]
11124 pub id: Option<Option<String>>,
11125 #[serde(default, skip_serializing_if = "Option::is_none")]
11126 pub feature: Option<EnterpriseFeatureSettingFeature>,
11127 #[serde(
11128 default,
11129 skip_serializing_if = "Option::is_none",
11130 deserialize_with = "double_option"
11131 )]
11132 pub state: Option<Option<String>>,
11133 #[serde(
11134 default,
11135 skip_serializing_if = "Option::is_none",
11136 deserialize_with = "double_option"
11137 )]
11138 pub can_configure: Option<Option<bool>>,
11139 #[serde(
11140 default,
11141 skip_serializing_if = "Option::is_none",
11142 deserialize_with = "double_option"
11143 )]
11144 pub is_configured: Option<Option<bool>>,
11145 #[serde(
11146 default,
11147 skip_serializing_if = "Option::is_none",
11148 deserialize_with = "double_option"
11149 )]
11150 pub allowlist: Option<Option<Vec<UserOrGroupReference>>>,
11151 #[serde(
11152 default,
11153 skip_serializing_if = "Option::is_none",
11154 deserialize_with = "double_option"
11155 )]
11156 pub denylist: Option<Option<Vec<UserOrGroupReference>>>,
11157}
11158
11159#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11160pub struct EnterpriseFeatureSettingsItem {
11161 #[serde(default, skip_serializing_if = "Option::is_none")]
11162 pub is_used: Option<bool>,
11163 #[serde(default, skip_serializing_if = "Option::is_none")]
11164 pub value: Option<EnterpriseFeatureSetting>,
11165}
11166
11167#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11168pub struct EnterpriseReference {
11169 #[serde(default, skip_serializing_if = "Option::is_none")]
11170 pub id: Option<String>,
11171 #[serde(default, skip_serializing_if = "Option::is_none")]
11172 pub r#type: Option<EnterpriseReferenceType>,
11173}
11174
11175#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11176pub struct ExternalCollabSecuritySettings {
11177 #[serde(default, skip_serializing_if = "Option::is_none")]
11178 pub denylist_domains: Option<Vec<String>>,
11179 #[serde(default, skip_serializing_if = "Option::is_none")]
11180 pub denylist_emails: Option<Vec<String>>,
11181 #[serde(default, skip_serializing_if = "Option::is_none")]
11182 pub allowlist_domains: Option<Vec<String>>,
11183 #[serde(default, skip_serializing_if = "Option::is_none")]
11184 pub allowlist_emails: Option<Vec<String>>,
11185 #[serde(
11186 default,
11187 skip_serializing_if = "Option::is_none",
11188 deserialize_with = "double_option"
11189 )]
11190 pub state: Option<Option<String>>,
11191 #[serde(
11192 default,
11193 skip_serializing_if = "Option::is_none",
11194 deserialize_with = "double_option"
11195 )]
11196 pub scheduled_status: Option<Option<String>>,
11197 #[serde(
11198 default,
11199 skip_serializing_if = "Option::is_none",
11200 deserialize_with = "double_option"
11201 )]
11202 pub scheduled_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
11203 #[serde(
11204 default,
11205 skip_serializing_if = "Option::is_none",
11206 deserialize_with = "double_option"
11207 )]
11208 pub factor_type_settings: Option<Option<String>>,
11209}
11210
11211#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11212pub struct ExternalUserDeletionResult {
11213 pub user_id: String,
11214 pub status: i64,
11215 #[serde(default, skip_serializing_if = "Option::is_none")]
11216 pub detail: Option<String>,
11217}
11218
11219#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11220pub struct ExternalUsersSubmitDeleteJobRequest {
11221 pub external_users: Vec<UserReference>,
11222}
11223
11224#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11225pub struct ExternalUsersSubmitDeleteJobResponse {
11226 pub entries: Vec<ExternalUserDeletionResult>,
11227}
11228
11229#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11230pub struct FileReference {
11231 pub r#type: FileReferenceType,
11232 pub id: String,
11233}
11234
11235#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11236pub struct Hub {
11237 pub id: String,
11238 pub r#type: HubType,
11239 #[serde(default, skip_serializing_if = "Option::is_none")]
11240 pub title: Option<String>,
11241 #[serde(default, skip_serializing_if = "Option::is_none")]
11242 pub description: Option<String>,
11243 #[serde(default, skip_serializing_if = "Option::is_none")]
11244 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
11245 #[serde(default, skip_serializing_if = "Option::is_none")]
11246 pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
11247 #[serde(default, skip_serializing_if = "Option::is_none")]
11248 pub created_by: Option<UserMini>,
11249 #[serde(default, skip_serializing_if = "Option::is_none")]
11250 pub updated_by: Option<UserMini>,
11251 #[serde(default, skip_serializing_if = "Option::is_none")]
11252 pub view_count: Option<i64>,
11253 #[serde(default, skip_serializing_if = "Option::is_none")]
11254 pub is_ai_enabled: Option<bool>,
11255 #[serde(default, skip_serializing_if = "Option::is_none")]
11256 pub is_collaboration_restricted_to_enterprise: Option<bool>,
11257 #[serde(default, skip_serializing_if = "Option::is_none")]
11258 pub can_non_owners_invite: Option<bool>,
11259 #[serde(default, skip_serializing_if = "Option::is_none")]
11260 pub can_shared_link_be_created: Option<bool>,
11261 #[serde(default, skip_serializing_if = "Option::is_none")]
11262 pub can_public_shared_link_be_created: Option<bool>,
11263 #[serde(default, skip_serializing_if = "Option::is_none")]
11264 pub copy_hub_access: Option<HubCopyHubAccess>,
11265}
11266
11267#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11268pub struct HubBase {
11269 pub id: String,
11270 pub r#type: HubType,
11271}
11272
11273#[derive(Clone, Debug, PartialEq)]
11274pub enum HubAccessGrantee {
11275 User(HubCollaborationUser),
11276 Group(GroupMini),
11277 Unknown(serde_json::Value),
11279}
11280
11281impl serde::Serialize for HubAccessGrantee {
11282 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
11283 match self {
11284 Self::User(inner) => inner.serialize(serializer),
11285 Self::Group(inner) => inner.serialize(serializer),
11286 Self::Unknown(inner) => inner.serialize(serializer),
11287 }
11288 }
11289}
11290
11291impl<'de> serde::Deserialize<'de> for HubAccessGrantee {
11292 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
11293 let value = serde_json::Value::deserialize(deserializer)?;
11294 let tag = value
11295 .get("type")
11296 .and_then(serde_json::Value::as_str)
11297 .map(str::to_owned);
11298 match tag.as_deref() {
11299 Some("user") => Ok(Self::User(
11300 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11301 )),
11302 Some("group") => Ok(Self::Group(
11303 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11304 )),
11305 _ => Ok(Self::Unknown(value)),
11306 }
11307 }
11308}
11309
11310#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11311pub struct HubCalloutBoxTextBlock {
11312 pub id: String,
11313 #[serde(
11314 default,
11315 skip_serializing_if = "Option::is_none",
11316 deserialize_with = "double_option"
11317 )]
11318 pub parent_id: Option<Option<String>>,
11319 pub r#type: HubCalloutBoxTextBlockType,
11320 pub fragment: String,
11321}
11322
11323#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11324pub struct HubCollaboration {
11325 pub id: String,
11326 pub r#type: HubCollaborationType,
11327 #[serde(default, skip_serializing_if = "Option::is_none")]
11328 pub hub: Option<HubBase>,
11329 #[serde(default, skip_serializing_if = "Option::is_none")]
11330 pub accessible_by: Option<HubAccessGrantee>,
11331 #[serde(default, skip_serializing_if = "Option::is_none")]
11332 pub role: Option<String>,
11333 #[serde(default, skip_serializing_if = "Option::is_none")]
11334 pub status: Option<HubCollaborationStatus>,
11335 #[serde(default, skip_serializing_if = "Option::is_none")]
11336 pub acceptance_requirements_status: Option<HubCollaborationAcceptanceRequirementsStatus>,
11337}
11338
11339#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11340pub struct HubCollaborationCreateRequest {
11341 pub hub: HubCollaborationCreateRequestHub,
11342 pub accessible_by: HubCollaborationCreateRequestAccessibleBy,
11343 pub role: String,
11344}
11345
11346#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11347pub struct HubCollaborations {
11348 #[serde(default, skip_serializing_if = "Option::is_none")]
11349 pub entries: Option<Vec<HubCollaboration>>,
11350 #[serde(default, skip_serializing_if = "Option::is_none")]
11351 pub limit: Option<i64>,
11352 #[serde(
11353 default,
11354 skip_serializing_if = "Option::is_none",
11355 deserialize_with = "double_option"
11356 )]
11357 pub next_marker: Option<Option<String>>,
11358}
11359
11360#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11361pub struct HubCollaborationUpdateRequest {
11362 #[serde(default, skip_serializing_if = "Option::is_none")]
11363 pub role: Option<String>,
11364}
11365
11366#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11367pub struct HubCollaborationUser {
11368 pub id: String,
11369 pub r#type: HubCollaborationUserType,
11370 #[serde(default, skip_serializing_if = "Option::is_none")]
11371 pub name: Option<String>,
11372 #[serde(default, skip_serializing_if = "Option::is_none")]
11373 pub login: Option<String>,
11374}
11375
11376#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11377pub struct HubCopyRequest {
11378 #[serde(default, skip_serializing_if = "Option::is_none")]
11379 pub title: Option<String>,
11380 #[serde(default, skip_serializing_if = "Option::is_none")]
11381 pub description: Option<String>,
11382 #[serde(default, skip_serializing_if = "Option::is_none")]
11383 pub include_items: Option<bool>,
11384}
11385
11386#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11387pub struct HubCreateRequest {
11388 pub title: String,
11389 #[serde(default, skip_serializing_if = "Option::is_none")]
11390 pub description: Option<String>,
11391}
11392
11393#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11394pub struct HubDividerBlock {
11395 pub id: String,
11396 #[serde(
11397 default,
11398 skip_serializing_if = "Option::is_none",
11399 deserialize_with = "double_option"
11400 )]
11401 pub parent_id: Option<Option<String>>,
11402 pub r#type: HubDividerBlockType,
11403}
11404
11405#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11406pub struct HubDocumentBlock {
11407 pub id: String,
11408 #[serde(
11409 default,
11410 skip_serializing_if = "Option::is_none",
11411 deserialize_with = "double_option"
11412 )]
11413 pub parent_id: Option<Option<String>>,
11414}
11415
11416#[derive(Clone, Debug, PartialEq)]
11417pub enum HubDocumentBlockEntry {
11418 Paragraph(HubParagraphTextBlock),
11419 SectionTitle(HubSectionTitleTextBlock),
11420 CalloutBox(HubCalloutBoxTextBlock),
11421 ItemList(HubItemListBlock),
11422 Divider(HubDividerBlock),
11423 Unknown(serde_json::Value),
11425}
11426
11427impl serde::Serialize for HubDocumentBlockEntry {
11428 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
11429 match self {
11430 Self::Paragraph(inner) => inner.serialize(serializer),
11431 Self::SectionTitle(inner) => inner.serialize(serializer),
11432 Self::CalloutBox(inner) => inner.serialize(serializer),
11433 Self::ItemList(inner) => inner.serialize(serializer),
11434 Self::Divider(inner) => inner.serialize(serializer),
11435 Self::Unknown(inner) => inner.serialize(serializer),
11436 }
11437 }
11438}
11439
11440impl<'de> serde::Deserialize<'de> for HubDocumentBlockEntry {
11441 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
11442 let value = serde_json::Value::deserialize(deserializer)?;
11443 let tag = value
11444 .get("type")
11445 .and_then(serde_json::Value::as_str)
11446 .map(str::to_owned);
11447 match tag.as_deref() {
11448 Some("paragraph") => Ok(Self::Paragraph(
11449 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11450 )),
11451 Some("section_title") => Ok(Self::SectionTitle(
11452 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11453 )),
11454 Some("callout_box") => Ok(Self::CalloutBox(
11455 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11456 )),
11457 Some("item_list") => Ok(Self::ItemList(
11458 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11459 )),
11460 Some("divider") => Ok(Self::Divider(
11461 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11462 )),
11463 _ => Ok(Self::Unknown(value)),
11464 }
11465 }
11466}
11467
11468#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11469pub struct HubDocumentBlocks {
11470 pub entries: Vec<HubDocumentBlockEntry>,
11471 pub r#type: HubDocumentBlocksType,
11472 #[serde(default, skip_serializing_if = "Option::is_none")]
11473 pub limit: Option<i64>,
11474 #[serde(
11475 default,
11476 skip_serializing_if = "Option::is_none",
11477 deserialize_with = "double_option"
11478 )]
11479 pub next_marker: Option<Option<String>>,
11480}
11481
11482#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11483pub struct HubDocumentPage {
11484 pub id: String,
11485 pub r#type: String,
11486 #[serde(
11487 default,
11488 skip_serializing_if = "Option::is_none",
11489 deserialize_with = "double_option"
11490 )]
11491 pub parent_id: Option<Option<String>>,
11492 pub title_fragment: String,
11493}
11494
11495#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11496pub struct HubDocumentPages {
11497 pub entries: Vec<HubDocumentPage>,
11498 pub r#type: HubDocumentPagesType,
11499 #[serde(default, skip_serializing_if = "Option::is_none")]
11500 pub limit: Option<i64>,
11501 #[serde(
11502 default,
11503 skip_serializing_if = "Option::is_none",
11504 deserialize_with = "double_option"
11505 )]
11506 pub next_marker: Option<Option<String>>,
11507}
11508
11509#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11510pub struct HubItem {
11511 pub id: String,
11512 pub r#type: HubItemType,
11513 pub name: String,
11514}
11515
11516#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11517pub struct HubItemListBlock {
11518 pub id: String,
11519 #[serde(
11520 default,
11521 skip_serializing_if = "Option::is_none",
11522 deserialize_with = "double_option"
11523 )]
11524 pub parent_id: Option<Option<String>>,
11525 pub r#type: HubItemListBlockType,
11526}
11527
11528#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11529pub struct HubItemOperation {
11530 pub action: HubItemOperationAction,
11531 pub item: HubItemReference,
11532 #[serde(default, skip_serializing_if = "Option::is_none")]
11533 pub parent_id: Option<String>,
11534}
11535
11536#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11537pub struct HubItemOperationResult {
11538 #[serde(default, skip_serializing_if = "Option::is_none")]
11539 pub action: Option<String>,
11540 #[serde(default, skip_serializing_if = "Option::is_none")]
11541 pub item: Option<HubItemReference>,
11542 #[serde(default, skip_serializing_if = "Option::is_none")]
11543 pub parent_id: Option<String>,
11544 #[serde(default, skip_serializing_if = "Option::is_none")]
11545 pub status: Option<i64>,
11546 #[serde(default, skip_serializing_if = "Option::is_none")]
11547 pub error: Option<String>,
11548}
11549
11550#[derive(Clone, Debug, PartialEq)]
11551pub enum HubItemReference {
11552 File(FileReference),
11553 Folder(FolderReference),
11554 WebLink(WeblinkReference),
11555 Unknown(serde_json::Value),
11557}
11558
11559impl serde::Serialize for HubItemReference {
11560 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
11561 match self {
11562 Self::File(inner) => inner.serialize(serializer),
11563 Self::Folder(inner) => inner.serialize(serializer),
11564 Self::WebLink(inner) => inner.serialize(serializer),
11565 Self::Unknown(inner) => inner.serialize(serializer),
11566 }
11567 }
11568}
11569
11570impl<'de> serde::Deserialize<'de> for HubItemReference {
11571 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
11572 let value = serde_json::Value::deserialize(deserializer)?;
11573 let tag = value
11574 .get("type")
11575 .and_then(serde_json::Value::as_str)
11576 .map(str::to_owned);
11577 match tag.as_deref() {
11578 Some("file") => Ok(Self::File(
11579 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11580 )),
11581 Some("folder") => Ok(Self::Folder(
11582 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11583 )),
11584 Some("web_link") => Ok(Self::WebLink(
11585 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11586 )),
11587 _ => Ok(Self::Unknown(value)),
11588 }
11589 }
11590}
11591
11592#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11593pub struct HubItems {
11594 #[serde(default, skip_serializing_if = "Option::is_none")]
11595 pub entries: Option<Vec<HubItem>>,
11596 #[serde(default, skip_serializing_if = "Option::is_none")]
11597 pub limit: Option<i64>,
11598 #[serde(
11599 default,
11600 skip_serializing_if = "Option::is_none",
11601 deserialize_with = "double_option"
11602 )]
11603 pub next_marker: Option<Option<String>>,
11604}
11605
11606#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11607pub struct HubItemsManageRequest {
11608 #[serde(default, skip_serializing_if = "Option::is_none")]
11609 pub operations: Option<Vec<HubItemOperation>>,
11610}
11611
11612#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11613pub struct HubItemsManageResponse {
11614 pub operations: Vec<HubItemOperationResult>,
11615}
11616
11617#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11618pub struct HubParagraphTextBlock {
11619 pub id: String,
11620 #[serde(
11621 default,
11622 skip_serializing_if = "Option::is_none",
11623 deserialize_with = "double_option"
11624 )]
11625 pub parent_id: Option<Option<String>>,
11626 pub r#type: HubParagraphTextBlockType,
11627 pub fragment: String,
11628}
11629
11630#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11631pub struct Hubs {
11632 #[serde(default, skip_serializing_if = "Option::is_none")]
11633 pub entries: Option<Vec<Hub>>,
11634 #[serde(default, skip_serializing_if = "Option::is_none")]
11635 pub limit: Option<i64>,
11636 #[serde(
11637 default,
11638 skip_serializing_if = "Option::is_none",
11639 deserialize_with = "double_option"
11640 )]
11641 pub next_marker: Option<Option<String>>,
11642}
11643
11644#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11645pub struct HubSectionTitleTextBlock {
11646 pub id: String,
11647 #[serde(
11648 default,
11649 skip_serializing_if = "Option::is_none",
11650 deserialize_with = "double_option"
11651 )]
11652 pub parent_id: Option<Option<String>>,
11653 pub r#type: HubSectionTitleTextBlockType,
11654 pub fragment: String,
11655}
11656
11657#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11658pub struct HubUpdateRequest {
11659 #[serde(default, skip_serializing_if = "Option::is_none")]
11660 pub title: Option<String>,
11661 #[serde(default, skip_serializing_if = "Option::is_none")]
11662 pub description: Option<String>,
11663 #[serde(default, skip_serializing_if = "Option::is_none")]
11664 pub is_ai_enabled: Option<bool>,
11665 #[serde(default, skip_serializing_if = "Option::is_none")]
11666 pub is_collaboration_restricted_to_enterprise: Option<bool>,
11667 #[serde(default, skip_serializing_if = "Option::is_none")]
11668 pub can_non_owners_invite: Option<bool>,
11669 #[serde(default, skip_serializing_if = "Option::is_none")]
11670 pub can_shared_link_be_created: Option<bool>,
11671 #[serde(default, skip_serializing_if = "Option::is_none")]
11672 pub can_public_shared_link_be_created: Option<bool>,
11673 #[serde(default, skip_serializing_if = "Option::is_none")]
11674 pub copy_hub_access: Option<HubCopyHubAccess>,
11675}
11676
11677#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11678pub struct KeysafeSettings {
11679 #[serde(default, skip_serializing_if = "Option::is_none")]
11680 pub keysafe_enabled: Option<bool>,
11681 #[serde(
11682 default,
11683 skip_serializing_if = "Option::is_none",
11684 deserialize_with = "double_option"
11685 )]
11686 pub cloud_provider: Option<Option<String>>,
11687 #[serde(
11688 default,
11689 skip_serializing_if = "Option::is_none",
11690 deserialize_with = "double_option"
11691 )]
11692 pub key_id: Option<Option<String>>,
11693 #[serde(
11694 default,
11695 skip_serializing_if = "Option::is_none",
11696 deserialize_with = "double_option"
11697 )]
11698 pub account_id: Option<Option<String>>,
11699 #[serde(
11700 default,
11701 skip_serializing_if = "Option::is_none",
11702 deserialize_with = "double_option"
11703 )]
11704 pub location_id: Option<Option<String>>,
11705 #[serde(
11706 default,
11707 skip_serializing_if = "Option::is_none",
11708 deserialize_with = "double_option"
11709 )]
11710 pub project_id: Option<Option<String>>,
11711 #[serde(
11712 default,
11713 skip_serializing_if = "Option::is_none",
11714 deserialize_with = "double_option"
11715 )]
11716 pub keyring_id: Option<Option<String>>,
11717}
11718
11719#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11720pub struct ListUser {
11721 #[serde(
11722 default,
11723 skip_serializing_if = "Option::is_none",
11724 deserialize_with = "double_option"
11725 )]
11726 pub id: Option<Option<i64>>,
11727 #[serde(
11728 default,
11729 skip_serializing_if = "Option::is_none",
11730 deserialize_with = "double_option"
11731 )]
11732 pub name: Option<Option<String>>,
11733 #[serde(
11734 default,
11735 skip_serializing_if = "Option::is_none",
11736 deserialize_with = "double_option"
11737 )]
11738 pub email: Option<Option<String>>,
11739}
11740
11741#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11742pub struct ShieldList {
11743 pub id: String,
11744 pub r#type: String,
11745 pub name: String,
11746 pub enterprise: EnterpriseReference,
11747 #[serde(default, skip_serializing_if = "Option::is_none")]
11748 pub description: Option<String>,
11749 pub created_at: chrono::DateTime<chrono::Utc>,
11750 pub updated_at: chrono::DateTime<chrono::Utc>,
11751 pub content: ShieldListContent,
11752}
11753
11754#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11755pub struct ShieldListMini {
11756 pub id: String,
11757 pub r#type: ShieldListMiniType,
11758 pub name: String,
11759 pub content: ShieldListMiniContent,
11760}
11761
11762#[derive(Clone, Debug, PartialEq)]
11763pub enum ShieldListContent {
11764 Country(ShieldListContentCountry),
11765 Domain(ShieldListContentDomain),
11766 Email(ShieldListContentEmail),
11767 Ip(ShieldListContentIp),
11768 Integration(ShieldListContentIntegration),
11769 Unknown(serde_json::Value),
11771}
11772
11773impl serde::Serialize for ShieldListContent {
11774 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
11775 match self {
11776 Self::Country(inner) => inner.serialize(serializer),
11777 Self::Domain(inner) => inner.serialize(serializer),
11778 Self::Email(inner) => inner.serialize(serializer),
11779 Self::Ip(inner) => inner.serialize(serializer),
11780 Self::Integration(inner) => inner.serialize(serializer),
11781 Self::Unknown(inner) => inner.serialize(serializer),
11782 }
11783 }
11784}
11785
11786impl<'de> serde::Deserialize<'de> for ShieldListContent {
11787 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
11788 let value = serde_json::Value::deserialize(deserializer)?;
11789 let tag = value
11790 .get("type")
11791 .and_then(serde_json::Value::as_str)
11792 .map(str::to_owned);
11793 match tag.as_deref() {
11794 Some("country") => Ok(Self::Country(
11795 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11796 )),
11797 Some("domain") => Ok(Self::Domain(
11798 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11799 )),
11800 Some("email") => Ok(Self::Email(
11801 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11802 )),
11803 Some("ip") => Ok(Self::Ip(
11804 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11805 )),
11806 Some("integration") => Ok(Self::Integration(
11807 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11808 )),
11809 _ => Ok(Self::Unknown(value)),
11810 }
11811 }
11812}
11813
11814#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11815pub struct ShieldListContentCountry {
11816 pub r#type: ShieldListContentCountryType,
11817 pub country_codes: Vec<String>,
11818}
11819
11820#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11821pub struct ShieldListContentDomain {
11822 pub r#type: ShieldListContentDomainType,
11823 pub domains: Vec<String>,
11824}
11825
11826#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11827pub struct ShieldListContentEmail {
11828 pub r#type: ShieldListContentEmailType,
11829 pub email_addresses: Vec<String>,
11830}
11831
11832#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11833pub struct ShieldListContentIntegration {
11834 pub r#type: ShieldListContentIntegrationType,
11835 pub integrations: Vec<ShieldListContentIntegrationIntegrations>,
11836}
11837
11838#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11839pub struct ShieldListContentIp {
11840 pub r#type: ShieldListContentIpType,
11841 pub ip_addresses: Vec<String>,
11842}
11843
11844#[derive(Clone, Debug, PartialEq)]
11845pub enum ShieldListContentRequest {
11846 Country(ShieldListContentCountry),
11847 Domain(ShieldListContentDomain),
11848 Email(ShieldListContentEmail),
11849 Ip(ShieldListContentIp),
11850 Unknown(serde_json::Value),
11852}
11853
11854impl serde::Serialize for ShieldListContentRequest {
11855 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
11856 match self {
11857 Self::Country(inner) => inner.serialize(serializer),
11858 Self::Domain(inner) => inner.serialize(serializer),
11859 Self::Email(inner) => inner.serialize(serializer),
11860 Self::Ip(inner) => inner.serialize(serializer),
11861 Self::Unknown(inner) => inner.serialize(serializer),
11862 }
11863 }
11864}
11865
11866impl<'de> serde::Deserialize<'de> for ShieldListContentRequest {
11867 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
11868 let value = serde_json::Value::deserialize(deserializer)?;
11869 let tag = value
11870 .get("type")
11871 .and_then(serde_json::Value::as_str)
11872 .map(str::to_owned);
11873 match tag.as_deref() {
11874 Some("country") => Ok(Self::Country(
11875 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11876 )),
11877 Some("domain") => Ok(Self::Domain(
11878 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11879 )),
11880 Some("email") => Ok(Self::Email(
11881 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11882 )),
11883 Some("ip") => Ok(Self::Ip(
11884 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11885 )),
11886 _ => Ok(Self::Unknown(value)),
11887 }
11888 }
11889}
11890
11891#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11892pub struct ShieldLists {
11893 #[serde(default, skip_serializing_if = "Option::is_none")]
11894 pub entries: Option<Vec<ShieldListMini>>,
11895}
11896
11897#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11898pub struct ShieldListsCreate {
11899 pub name: String,
11900 #[serde(default, skip_serializing_if = "Option::is_none")]
11901 pub description: Option<String>,
11902 pub content: ShieldListContentRequest,
11903}
11904
11905#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11906pub struct ShieldListsUpdate {
11907 pub name: String,
11908 #[serde(default, skip_serializing_if = "Option::is_none")]
11909 pub description: Option<String>,
11910 pub content: ShieldListContentRequest,
11911}
11912
11913#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11914pub struct ShieldRuleItem {
11915 #[serde(default, skip_serializing_if = "Option::is_none")]
11916 pub id: Option<String>,
11917 #[serde(default, skip_serializing_if = "Option::is_none")]
11918 pub r#type: Option<ShieldRuleItemType>,
11919 #[serde(default, skip_serializing_if = "Option::is_none")]
11920 pub rule_category: Option<String>,
11921 #[serde(default, skip_serializing_if = "Option::is_none")]
11922 pub name: Option<String>,
11923 #[serde(default, skip_serializing_if = "Option::is_none")]
11924 pub description: Option<String>,
11925 #[serde(default, skip_serializing_if = "Option::is_none")]
11926 pub priority: Option<ShieldRuleItemPriority>,
11927 #[serde(default, skip_serializing_if = "Option::is_none")]
11928 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
11929 #[serde(default, skip_serializing_if = "Option::is_none")]
11930 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
11931}
11932
11933#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11934pub struct UserOrGroupReference {
11935 #[serde(default, skip_serializing_if = "Option::is_none")]
11936 pub r#type: Option<UserOrGroupReferenceType>,
11937 #[serde(default, skip_serializing_if = "Option::is_none")]
11938 pub id: Option<String>,
11939}
11940
11941#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11942pub struct UserReference {
11943 pub r#type: HubCollaborationUserType,
11944 pub id: String,
11945}
11946
11947#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11948pub struct UserTrackingCode {
11949 #[serde(
11950 default,
11951 skip_serializing_if = "Option::is_none",
11952 deserialize_with = "double_option"
11953 )]
11954 pub id: Option<Option<i64>>,
11955 #[serde(
11956 default,
11957 skip_serializing_if = "Option::is_none",
11958 deserialize_with = "double_option"
11959 )]
11960 pub name: Option<Option<String>>,
11961}
11962
11963#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11964pub struct WeblinkReference {
11965 pub r#type: WeblinkReferenceType,
11966 pub id: String,
11967}
11968
11969#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
11970#[serde(transparent)]
11971pub struct ArchiveType(pub String);
11972
11973impl ArchiveType {
11974 pub const ARCHIVE: &'static str = "archive";
11975}
11976
11977#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
11978pub struct ArchiveOwnedBy {
11979 pub id: String,
11980 pub r#type: String,
11981}
11982
11983#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
11984#[serde(transparent)]
11985pub struct DocGenBatchBaseType(pub String);
11986
11987impl DocGenBatchBaseType {
11988 pub const DOCGEN_BATCH: &'static str = "docgen_batch";
11989}
11990
11991#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
11992#[serde(transparent)]
11993pub struct DestinationFolderType(pub String);
11994
11995impl DestinationFolderType {
11996 pub const FOLDER: &'static str = "folder";
11997}
11998
11999#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12000pub struct DocGenBatchCreateRequestDestinationFolder {
12001 pub r#type: DestinationFolderType,
12002 pub id: String,
12003}
12004
12005#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12006#[serde(transparent)]
12007pub struct DocGenJobType(pub String);
12008
12009impl DocGenJobType {
12010 pub const DOCGEN_JOB: &'static str = "docgen_job";
12011}
12012
12013#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12014#[serde(transparent)]
12015pub struct DocGenJobOutputFile(pub serde_json::Value);
12016
12017#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12018#[serde(transparent)]
12019pub struct DocGenJobOutputFileVersion(pub serde_json::Value);
12020
12021#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12022#[serde(transparent)]
12023pub struct DocGenJobStatus(pub String);
12024
12025impl DocGenJobStatus {
12026 pub const SUBMITTED: &'static str = "submitted";
12027 pub const COMPLETED: &'static str = "completed";
12028 pub const FAILED: &'static str = "failed";
12029 pub const COMPLETED_WITH_ERROR: &'static str = "completed_with_error";
12030 pub const PENDING: &'static str = "pending";
12031}
12032
12033#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12034pub struct DocGenJobFailures {
12035 pub errors: Vec<String>,
12036 pub warnings: Vec<String>,
12037}
12038
12039#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12040#[serde(transparent)]
12041pub struct DocGenTagTagType(pub String);
12042
12043impl DocGenTagTagType {
12044 pub const TEXT: &'static str = "text";
12045 pub const ARITHMETIC: &'static str = "arithmetic";
12046 pub const CONDITIONAL: &'static str = "conditional";
12047 pub const FOR_LOOP: &'static str = "for-loop";
12048 pub const TABLE_LOOP: &'static str = "table-loop";
12049 pub const IMAGE: &'static str = "image";
12050}
12051
12052#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12053#[serde(transparent)]
12054pub struct EnterpriseConfigurationType(pub String);
12055
12056impl EnterpriseConfigurationType {
12057 pub const ENTERPRISE_CONFIGURATION: &'static str = "enterprise_configuration";
12058}
12059
12060#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12061#[serde(transparent)]
12062pub struct EnterpriseConfigurationSecurity2(pub serde_json::Value);
12063
12064#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12065#[serde(transparent)]
12066pub struct EnterpriseConfigurationContentAndSharing2(pub serde_json::Value);
12067
12068#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12069#[serde(transparent)]
12070pub struct EnterpriseConfigurationUserSettings2(pub serde_json::Value);
12071
12072#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12073#[serde(transparent)]
12074pub struct EnterpriseConfigurationShield2(pub serde_json::Value);
12075
12076#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12077pub struct EnterpriseConfigurationContentAndSharingSharedLinkDefaultPermissionsSelected {
12078 #[serde(default, skip_serializing_if = "Option::is_none")]
12079 pub is_used: Option<bool>,
12080 #[serde(default, skip_serializing_if = "Option::is_none")]
12081 pub value: Option<SharedLinkPermissions>,
12082}
12083
12084#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12085pub struct EnterpriseConfigurationContentAndSharingCollaborationPermissions {
12086 #[serde(default, skip_serializing_if = "Option::is_none")]
12087 pub is_used: Option<bool>,
12088 #[serde(default, skip_serializing_if = "Option::is_none")]
12089 pub value: Option<CollaborationPermissions>,
12090}
12091
12092#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12093pub struct EnterpriseConfigurationContentAndSharingCollaborationRestrictions {
12094 #[serde(default, skip_serializing_if = "Option::is_none")]
12095 pub is_used: Option<bool>,
12096 #[serde(default, skip_serializing_if = "Option::is_none")]
12097 pub value: Option<Vec<String>>,
12098}
12099
12100#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12101pub struct EnterpriseConfigurationContentAndSharingExternalCollaborationStatus {
12102 #[serde(default, skip_serializing_if = "Option::is_none")]
12103 pub is_used: Option<bool>,
12104 #[serde(
12105 default,
12106 skip_serializing_if = "Option::is_none",
12107 deserialize_with = "double_option"
12108 )]
12109 pub value: Option<Option<String>>,
12110}
12111
12112#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12113pub struct EnterpriseConfigurationContentAndSharingExternalCollaborationAllowlistUsers {
12114 #[serde(default, skip_serializing_if = "Option::is_none")]
12115 pub is_used: Option<bool>,
12116 #[serde(default, skip_serializing_if = "Option::is_none")]
12117 pub value: Option<Vec<ListUser>>,
12118}
12119
12120#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12121pub struct EnterpriseConfigurationSecurityLastPasswordResetAt {
12122 #[serde(default, skip_serializing_if = "Option::is_none")]
12123 pub is_used: Option<bool>,
12124 #[serde(
12125 default,
12126 skip_serializing_if = "Option::is_none",
12127 deserialize_with = "double_option"
12128 )]
12129 pub value: Option<Option<chrono::DateTime<chrono::Utc>>>,
12130}
12131
12132#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12133#[serde(transparent)]
12134pub struct ExternalCollabMultiFactorAuthSettingsValue(pub serde_json::Value);
12135
12136#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12137pub struct EnterpriseConfigurationSecurityExternalCollabMultiFactorAuthSettings {
12138 #[serde(default, skip_serializing_if = "Option::is_none")]
12139 pub is_used: Option<bool>,
12140 #[serde(default, skip_serializing_if = "Option::is_none")]
12141 pub value: Option<ExternalCollabMultiFactorAuthSettingsValue>,
12142}
12143
12144#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12145#[serde(transparent)]
12146pub struct KeysafeValue(pub serde_json::Value);
12147
12148#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12149pub struct EnterpriseConfigurationSecurityKeysafe {
12150 #[serde(default, skip_serializing_if = "Option::is_none")]
12151 pub is_used: Option<bool>,
12152 #[serde(default, skip_serializing_if = "Option::is_none")]
12153 pub value: Option<KeysafeValue>,
12154}
12155
12156#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12157pub struct EnterpriseConfigurationSecurityCustomSessionDurationGroups {
12158 #[serde(default, skip_serializing_if = "Option::is_none")]
12159 pub is_used: Option<bool>,
12160 #[serde(default, skip_serializing_if = "Option::is_none")]
12161 pub value: Option<Vec<CustomSessionDurationGroupItem>>,
12162}
12163
12164#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12165pub struct EnforcedMfaFrequencyValue {
12166 #[serde(
12167 default,
12168 skip_serializing_if = "Option::is_none",
12169 deserialize_with = "double_option"
12170 )]
12171 pub days: Option<Option<i64>>,
12172 #[serde(
12173 default,
12174 skip_serializing_if = "Option::is_none",
12175 deserialize_with = "double_option"
12176 )]
12177 pub hours: Option<Option<i64>>,
12178}
12179
12180#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12181pub struct EnterpriseConfigurationSecurityEnforcedMfaFrequency {
12182 #[serde(default, skip_serializing_if = "Option::is_none")]
12183 pub is_used: Option<bool>,
12184 #[serde(default, skip_serializing_if = "Option::is_none")]
12185 pub value: Option<EnforcedMfaFrequencyValue>,
12186}
12187
12188#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12189pub struct EnterpriseConfigurationUserSettingsUserTrackingCodes {
12190 #[serde(default, skip_serializing_if = "Option::is_none")]
12191 pub is_used: Option<bool>,
12192 #[serde(default, skip_serializing_if = "Option::is_none")]
12193 pub value: Option<Vec<UserTrackingCode>>,
12194}
12195
12196#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12197pub struct EnterpriseFeatureSettingFeature {
12198 #[serde(
12199 default,
12200 skip_serializing_if = "Option::is_none",
12201 deserialize_with = "double_option"
12202 )]
12203 pub id: Option<Option<String>>,
12204}
12205
12206#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12207#[serde(transparent)]
12208pub struct EnterpriseReferenceType(pub String);
12209
12210impl EnterpriseReferenceType {
12211 pub const ENTERPRISE: &'static str = "enterprise";
12212}
12213
12214#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12215#[serde(transparent)]
12216pub struct FileReferenceType(pub String);
12217
12218impl FileReferenceType {
12219 pub const FILE: &'static str = "file";
12220}
12221
12222#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12223#[serde(transparent)]
12224pub struct FileVersionBaseType(pub String);
12225
12226impl FileVersionBaseType {
12227 pub const FILE_VERSION: &'static str = "file_version";
12228}
12229
12230#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12231#[serde(transparent)]
12232pub struct GroupBaseType(pub String);
12233
12234impl GroupBaseType {
12235 pub const GROUP: &'static str = "group";
12236}
12237
12238#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12239#[serde(transparent)]
12240pub struct GroupMiniGroupType(pub String);
12241
12242impl GroupMiniGroupType {
12243 pub const MANAGED_GROUP: &'static str = "managed_group";
12244 pub const ALL_USERS_GROUP: &'static str = "all_users_group";
12245}
12246
12247#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12248#[serde(transparent)]
12249pub struct HubType(pub String);
12250
12251impl HubType {
12252 pub const HUBS: &'static str = "hubs";
12253}
12254
12255#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12256#[serde(transparent)]
12257pub struct HubCopyHubAccess(pub String);
12258
12259impl HubCopyHubAccess {
12260 pub const ALL: &'static str = "all";
12261 pub const COMPANY: &'static str = "company";
12262 pub const NONE: &'static str = "none";
12263}
12264
12265#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12266#[serde(transparent)]
12267pub struct HubCalloutBoxTextBlockType(pub String);
12268
12269impl HubCalloutBoxTextBlockType {
12270 pub const CALLOUT_BOX: &'static str = "callout_box";
12271}
12272
12273#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12274#[serde(transparent)]
12275pub struct HubCollaborationType(pub String);
12276
12277impl HubCollaborationType {
12278 pub const HUB_COLLABORATION: &'static str = "hub_collaboration";
12279}
12280
12281#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12282#[serde(transparent)]
12283pub struct HubCollaborationStatus(pub String);
12284
12285impl HubCollaborationStatus {
12286 pub const ACCEPTED: &'static str = "accepted";
12287 pub const PENDING: &'static str = "pending";
12288 pub const REJECTED: &'static str = "rejected";
12289}
12290
12291#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12292pub struct HubCollaborationAcceptanceRequirementsStatus {
12293 #[serde(default, skip_serializing_if = "Option::is_none")]
12294 pub terms_of_service_requirement: Option<AcceptanceRequirementsStatusTermsOfServiceRequirement>,
12295 #[serde(default, skip_serializing_if = "Option::is_none")]
12296 pub strong_password_requirement: Option<AcceptanceRequirementsStatusStrongPasswordRequirement>,
12297 #[serde(default, skip_serializing_if = "Option::is_none")]
12298 pub two_factor_authentication_requirement:
12299 Option<AcceptanceRequirementsStatusTwoFactorAuthenticationRequirement>,
12300}
12301
12302#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12303pub struct HubCollaborationCreateRequestHub {
12304 pub r#type: HubType,
12305 pub id: String,
12306}
12307
12308#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12309pub struct HubCollaborationCreateRequestAccessibleBy {
12310 pub r#type: String,
12311 #[serde(default, skip_serializing_if = "Option::is_none")]
12312 pub id: Option<String>,
12313 #[serde(default, skip_serializing_if = "Option::is_none")]
12314 pub login: Option<String>,
12315}
12316
12317#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12318#[serde(transparent)]
12319pub struct HubCollaborationUserType(pub String);
12320
12321impl HubCollaborationUserType {
12322 pub const USER: &'static str = "user";
12323}
12324
12325#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12326#[serde(transparent)]
12327pub struct HubDividerBlockType(pub String);
12328
12329impl HubDividerBlockType {
12330 pub const DIVIDER: &'static str = "divider";
12331}
12332
12333#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12334#[serde(transparent)]
12335pub struct HubDocumentBlocksType(pub String);
12336
12337impl HubDocumentBlocksType {
12338 pub const DOCUMENT_BLOCKS: &'static str = "document_blocks";
12339}
12340
12341#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12342#[serde(transparent)]
12343pub struct HubDocumentPagesType(pub String);
12344
12345impl HubDocumentPagesType {
12346 pub const DOCUMENT_PAGES: &'static str = "document_pages";
12347}
12348
12349#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12350#[serde(transparent)]
12351pub struct HubItemType(pub String);
12352
12353impl HubItemType {
12354 pub const FILE: &'static str = "file";
12355 pub const FOLDER: &'static str = "folder";
12356 pub const WEB_LINK: &'static str = "web_link";
12357}
12358
12359#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12360#[serde(transparent)]
12361pub struct HubItemListBlockType(pub String);
12362
12363impl HubItemListBlockType {
12364 pub const ITEM_LIST: &'static str = "item_list";
12365}
12366
12367#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12368#[serde(transparent)]
12369pub struct HubItemOperationAction(pub String);
12370
12371impl HubItemOperationAction {
12372 pub const ADD: &'static str = "add";
12373 pub const REMOVE: &'static str = "remove";
12374}
12375
12376#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12377#[serde(transparent)]
12378pub struct HubParagraphTextBlockType(pub String);
12379
12380impl HubParagraphTextBlockType {
12381 pub const PARAGRAPH: &'static str = "paragraph";
12382}
12383
12384#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12385#[serde(transparent)]
12386pub struct HubSectionTitleTextBlockType(pub String);
12387
12388impl HubSectionTitleTextBlockType {
12389 pub const SECTION_TITLE: &'static str = "section_title";
12390}
12391
12392#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12393#[serde(transparent)]
12394pub struct ShieldListMiniType(pub String);
12395
12396impl ShieldListMiniType {
12397 pub const SHIELD_LIST: &'static str = "shield_list";
12398}
12399
12400#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12401pub struct ShieldListMiniContent {
12402 #[serde(default, skip_serializing_if = "Option::is_none")]
12403 pub r#type: Option<String>,
12404}
12405
12406#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12407#[serde(transparent)]
12408pub struct ShieldListContentCountryType(pub String);
12409
12410impl ShieldListContentCountryType {
12411 pub const COUNTRY: &'static str = "country";
12412}
12413
12414#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12415#[serde(transparent)]
12416pub struct ShieldListContentDomainType(pub String);
12417
12418impl ShieldListContentDomainType {
12419 pub const DOMAIN: &'static str = "domain";
12420}
12421
12422#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12423#[serde(transparent)]
12424pub struct ShieldListContentEmailType(pub String);
12425
12426impl ShieldListContentEmailType {
12427 pub const EMAIL: &'static str = "email";
12428}
12429
12430#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12431#[serde(transparent)]
12432pub struct ShieldListContentIntegrationType(pub String);
12433
12434impl ShieldListContentIntegrationType {
12435 pub const INTEGRATION: &'static str = "integration";
12436}
12437
12438#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12439pub struct ShieldListContentIntegrationIntegrations {
12440 #[serde(default, skip_serializing_if = "Option::is_none")]
12441 pub id: Option<String>,
12442}
12443
12444#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12445#[serde(transparent)]
12446pub struct ShieldListContentIpType(pub String);
12447
12448impl ShieldListContentIpType {
12449 pub const IP: &'static str = "ip";
12450}
12451
12452#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12453#[serde(transparent)]
12454pub struct ShieldRuleItemType(pub String);
12455
12456impl ShieldRuleItemType {
12457 pub const SHIELD_RULE: &'static str = "shield_rule";
12458}
12459
12460#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12461#[serde(transparent)]
12462pub struct ShieldRuleItemPriority(pub String);
12463
12464impl ShieldRuleItemPriority {
12465 pub const INFORMATIONAL: &'static str = "informational";
12466 pub const LOW: &'static str = "low";
12467 pub const MEDIUM: &'static str = "medium";
12468 pub const HIGH: &'static str = "high";
12469 pub const CRITICAL: &'static str = "critical";
12470}
12471
12472#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12473#[serde(transparent)]
12474pub struct TermsOfServiceBaseType(pub String);
12475
12476impl TermsOfServiceBaseType {
12477 pub const TERMS_OF_SERVICE: &'static str = "terms_of_service";
12478}
12479
12480#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12481#[serde(transparent)]
12482pub struct UserOrGroupReferenceType(pub String);
12483
12484impl UserOrGroupReferenceType {
12485 pub const USER: &'static str = "user";
12486 pub const GROUP: &'static str = "group";
12487}
12488
12489#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12490#[serde(transparent)]
12491pub struct WeblinkReferenceType(pub String);
12492
12493impl WeblinkReferenceType {
12494 pub const WEB_LINK: &'static str = "web_link";
12495}
12496
12497#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12498pub struct ArchiveCreateRequest {
12499 pub name: String,
12500 #[serde(default, skip_serializing_if = "Option::is_none")]
12501 pub description: Option<String>,
12502 #[serde(default, skip_serializing_if = "Option::is_none")]
12503 pub storage_policy_id: Option<String>,
12504}
12505
12506#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12507pub struct ArchiveUpdateRequest {
12508 #[serde(default, skip_serializing_if = "Option::is_none")]
12509 pub name: Option<String>,
12510 #[serde(default, skip_serializing_if = "Option::is_none")]
12511 pub description: Option<String>,
12512}
12513
12514#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12515pub struct AutomateWorkflowAction {
12516 pub id: String,
12517 pub r#type: AutomateWorkflowActionType,
12518 pub action_type: AutomateWorkflowActionActionType,
12519 #[serde(default, skip_serializing_if = "Option::is_none")]
12520 pub description: Option<String>,
12521 #[serde(default, skip_serializing_if = "Option::is_none")]
12522 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
12523 #[serde(default, skip_serializing_if = "Option::is_none")]
12524 pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
12525 #[serde(default, skip_serializing_if = "Option::is_none")]
12526 pub created_by: Option<UserMini>,
12527 #[serde(default, skip_serializing_if = "Option::is_none")]
12528 pub updated_by: Option<UserMini>,
12529 pub workflow: AutomateWorkflowReference,
12530}
12531
12532#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12533pub struct AutomateWorkflowReference {
12534 pub id: String,
12535 pub r#type: AutomateWorkflowReferenceType,
12536 #[serde(default, skip_serializing_if = "Option::is_none")]
12537 pub name: Option<String>,
12538}
12539
12540#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12541pub struct AutomateWorkflows {
12542 #[serde(default, skip_serializing_if = "Option::is_none")]
12543 pub entries: Option<Vec<AutomateWorkflowAction>>,
12544 #[serde(default, skip_serializing_if = "Option::is_none")]
12545 pub limit: Option<i64>,
12546 #[serde(
12547 default,
12548 skip_serializing_if = "Option::is_none",
12549 deserialize_with = "double_option"
12550 )]
12551 pub next_marker: Option<Option<String>>,
12552}
12553
12554#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12555pub struct AutomateWorkflowStartRequest {
12556 pub workflow_action_id: String,
12557 pub file_ids: Vec<String>,
12558}
12559
12560#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12561pub struct NotesConvertRequestBody {
12562 pub content: String,
12563 pub content_format: NotesConvertRequestBodyContentFormat,
12564 pub parent: FolderReference,
12565 pub name: String,
12566}
12567
12568#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
12569pub struct NotesConvertResponse {
12570 pub r#type: NotesConvertResponseType,
12571 pub id: String,
12572}
12573
12574#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12575#[serde(transparent)]
12576pub struct AutomateWorkflowActionType(pub String);
12577
12578impl AutomateWorkflowActionType {
12579 pub const WORKFLOW_ACTION: &'static str = "workflow_action";
12580}
12581
12582#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12583#[serde(transparent)]
12584pub struct AutomateWorkflowActionActionType(pub String);
12585
12586impl AutomateWorkflowActionActionType {
12587 pub const RUN_WORKFLOW: &'static str = "run_workflow";
12588}
12589
12590#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12591#[serde(transparent)]
12592pub struct AutomateWorkflowReferenceType(pub String);
12593
12594impl AutomateWorkflowReferenceType {
12595 pub const WORKFLOW: &'static str = "workflow";
12596}
12597
12598#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12599#[serde(transparent)]
12600pub struct FolderReferenceType(pub String);
12601
12602impl FolderReferenceType {
12603 pub const FOLDER: &'static str = "folder";
12604}
12605
12606#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12607#[serde(transparent)]
12608pub struct NotesConvertRequestBodyContentFormat(pub String);
12609
12610impl NotesConvertRequestBodyContentFormat {
12611 pub const MARKDOWN: &'static str = "markdown";
12612}
12613
12614#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12615#[serde(transparent)]
12616pub struct NotesConvertResponseType(pub String);
12617
12618impl NotesConvertResponseType {
12619 pub const FILE: &'static str = "file";
12620}
12621
12622#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12623#[serde(transparent)]
12624pub struct UserBaseType(pub String);
12625
12626impl UserBaseType {
12627 pub const USER: &'static str = "user";
12628}