1use crate::serde_helpers::double_option;
4
5#[derive(Clone, Debug, Default, 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 Default for AiAgent {
32 fn default() -> Self {
33 Self::Unknown(Default::default())
34 }
35}
36
37impl serde::Serialize for AiAgent {
38 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
39 match self {
40 Self::AiAgentAsk(inner) => inner.serialize(serializer),
41 Self::AiAgentTextGen(inner) => inner.serialize(serializer),
42 Self::AiAgentExtract(inner) => inner.serialize(serializer),
43 Self::AiAgentExtractStructured(inner) => inner.serialize(serializer),
44 Self::Unknown(inner) => inner.serialize(serializer),
45 }
46 }
47}
48
49impl<'de> serde::Deserialize<'de> for AiAgent {
50 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
51 let value = serde_json::Value::deserialize(deserializer)?;
52 let tag = value
53 .get("type")
54 .and_then(serde_json::Value::as_str)
55 .map(str::to_owned);
56 match tag.as_deref() {
57 Some("ai_agent_ask") => Ok(Self::AiAgentAsk(
58 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
59 )),
60 Some("ai_agent_text_gen") => Ok(Self::AiAgentTextGen(
61 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
62 )),
63 Some("ai_agent_extract") => Ok(Self::AiAgentExtract(
64 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
65 )),
66 Some("ai_agent_extract_structured") => Ok(Self::AiAgentExtractStructured(
67 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
68 )),
69 _ => Ok(Self::Unknown(value)),
70 }
71 }
72}
73
74#[derive(Clone, Debug, PartialEq)]
75pub enum AiAgentAllowedEntity {
76 User(UserBase),
77 Group(GroupBase),
78 Unknown(serde_json::Value),
80}
81
82impl Default for AiAgentAllowedEntity {
83 fn default() -> Self {
84 Self::Unknown(Default::default())
85 }
86}
87
88impl serde::Serialize for AiAgentAllowedEntity {
89 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
90 match self {
91 Self::User(inner) => inner.serialize(serializer),
92 Self::Group(inner) => inner.serialize(serializer),
93 Self::Unknown(inner) => inner.serialize(serializer),
94 }
95 }
96}
97
98impl<'de> serde::Deserialize<'de> for AiAgentAllowedEntity {
99 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
100 let value = serde_json::Value::deserialize(deserializer)?;
101 let tag = value
102 .get("type")
103 .and_then(serde_json::Value::as_str)
104 .map(str::to_owned);
105 match tag.as_deref() {
106 Some("user") => Ok(Self::User(
107 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
108 )),
109 Some("group") => Ok(Self::Group(
110 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
111 )),
112 _ => Ok(Self::Unknown(value)),
113 }
114 }
115}
116
117#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
118pub struct AiAgentAsk {
119 pub r#type: AiAgentAskType,
120 #[serde(default, skip_serializing_if = "Option::is_none")]
121 pub long_text: Option<AiAgentLongTextTool>,
122 #[serde(default, skip_serializing_if = "Option::is_none")]
123 pub basic_text: Option<AiAgentBasicTextTool>,
124 #[serde(default, skip_serializing_if = "Option::is_none")]
125 pub spreadsheet: Option<AiAgentSpreadsheetTool>,
126 #[serde(default, skip_serializing_if = "Option::is_none")]
127 pub long_text_multi: Option<AiAgentLongTextTool>,
128 #[serde(default, skip_serializing_if = "Option::is_none")]
129 pub basic_text_multi: Option<AiAgentBasicTextTool>,
130 #[serde(default, skip_serializing_if = "Option::is_none")]
131 pub basic_image: Option<AiAgentBasicTextTool>,
132 #[serde(default, skip_serializing_if = "Option::is_none")]
133 pub basic_image_multi: Option<AiAgentBasicTextTool>,
134}
135
136#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
137pub struct AiAgentBasicGenTool {
138 #[serde(default, skip_serializing_if = "Option::is_none")]
139 pub model: Option<String>,
140 #[serde(default, skip_serializing_if = "Option::is_none")]
141 pub num_tokens_for_completion: Option<i64>,
142 #[serde(default, skip_serializing_if = "Option::is_none")]
143 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
144 #[serde(default, skip_serializing_if = "Option::is_none")]
145 pub system_message: Option<String>,
146 #[serde(default, skip_serializing_if = "Option::is_none")]
147 pub prompt_template: Option<String>,
148 #[serde(default, skip_serializing_if = "Option::is_none")]
149 pub embeddings: Option<AiAgentBasicGenToolEmbeddings>,
150 #[serde(default, skip_serializing_if = "Option::is_none")]
151 pub content_template: Option<String>,
152}
153
154#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
155pub struct AiAgentBasicTextTool {
156 #[serde(default, skip_serializing_if = "Option::is_none")]
157 pub model: Option<String>,
158 #[serde(default, skip_serializing_if = "Option::is_none")]
159 pub num_tokens_for_completion: Option<i64>,
160 #[serde(default, skip_serializing_if = "Option::is_none")]
161 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
162 #[serde(default, skip_serializing_if = "Option::is_none")]
163 pub system_message: Option<String>,
164 #[serde(default, skip_serializing_if = "Option::is_none")]
165 pub prompt_template: Option<String>,
166}
167
168#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
169pub struct AiAgentBasicTextToolBase {
170 #[serde(default, skip_serializing_if = "Option::is_none")]
171 pub model: Option<String>,
172 #[serde(default, skip_serializing_if = "Option::is_none")]
173 pub num_tokens_for_completion: Option<i64>,
174 #[serde(default, skip_serializing_if = "Option::is_none")]
175 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
176}
177
178#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
179pub struct AiAgentBasicTextToolTextGen {
180 #[serde(default, skip_serializing_if = "Option::is_none")]
181 pub model: Option<String>,
182 #[serde(default, skip_serializing_if = "Option::is_none")]
183 pub num_tokens_for_completion: Option<i64>,
184 #[serde(default, skip_serializing_if = "Option::is_none")]
185 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
186 #[serde(default, skip_serializing_if = "Option::is_none")]
187 pub system_message: Option<String>,
188 #[serde(default, skip_serializing_if = "Option::is_none")]
189 pub prompt_template: Option<String>,
190}
191
192#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
193pub struct AiAgentExtract {
194 pub r#type: AiAgentExtractType,
195 #[serde(default, skip_serializing_if = "Option::is_none")]
196 pub long_text: Option<AiAgentLongTextTool>,
197 #[serde(default, skip_serializing_if = "Option::is_none")]
198 pub basic_text: Option<AiAgentBasicTextTool>,
199 #[serde(default, skip_serializing_if = "Option::is_none")]
200 pub basic_image: Option<AiAgentBasicTextTool>,
201}
202
203#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
204pub struct AiAgentExtractStructured {
205 pub r#type: AiAgentExtractStructuredType,
206 #[serde(default, skip_serializing_if = "Option::is_none")]
207 pub long_text: Option<AiAgentLongTextTool>,
208 #[serde(default, skip_serializing_if = "Option::is_none")]
209 pub basic_text: Option<AiAgentBasicTextTool>,
210 #[serde(default, skip_serializing_if = "Option::is_none")]
211 pub basic_image: Option<AiAgentBasicTextTool>,
212}
213
214#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
215pub struct AiAgentInfo {
216 #[serde(default, skip_serializing_if = "Option::is_none")]
217 pub models: Option<Vec<AiAgentInfoModels>>,
218 #[serde(default, skip_serializing_if = "Option::is_none")]
219 pub processor: Option<String>,
220}
221
222#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
223pub struct AiAgentLongTextTool {
224 #[serde(default, skip_serializing_if = "Option::is_none")]
225 pub model: Option<String>,
226 #[serde(default, skip_serializing_if = "Option::is_none")]
227 pub num_tokens_for_completion: Option<i64>,
228 #[serde(default, skip_serializing_if = "Option::is_none")]
229 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
230 #[serde(default, skip_serializing_if = "Option::is_none")]
231 pub system_message: Option<String>,
232 #[serde(default, skip_serializing_if = "Option::is_none")]
233 pub prompt_template: Option<String>,
234 #[serde(default, skip_serializing_if = "Option::is_none")]
235 pub embeddings: Option<AiAgentBasicGenToolEmbeddings>,
236}
237
238#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
239pub struct AiAgentLongTextToolTextGen {
240 #[serde(default, skip_serializing_if = "Option::is_none")]
241 pub model: Option<String>,
242 #[serde(default, skip_serializing_if = "Option::is_none")]
243 pub num_tokens_for_completion: Option<i64>,
244 #[serde(default, skip_serializing_if = "Option::is_none")]
245 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
246 #[serde(default, skip_serializing_if = "Option::is_none")]
247 pub system_message: Option<String>,
248 #[serde(default, skip_serializing_if = "Option::is_none")]
249 pub prompt_template: Option<String>,
250 #[serde(default, skip_serializing_if = "Option::is_none")]
251 pub embeddings: Option<AiAgentBasicGenToolEmbeddings>,
252}
253
254#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
255pub struct AiAgentReference {
256 pub r#type: AiAgentReferenceType,
257 pub id: String,
258}
259
260#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
261pub struct AiAgentSpreadsheetTool {
262 #[serde(default, skip_serializing_if = "Option::is_none")]
263 pub model: Option<String>,
264 #[serde(default, skip_serializing_if = "Option::is_none")]
265 pub num_tokens_for_completion: Option<i64>,
266 #[serde(default, skip_serializing_if = "Option::is_none")]
267 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
268}
269
270#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
271pub struct AiAgentTextGen {
272 pub r#type: AiAgentTextGenType,
273 #[serde(default, skip_serializing_if = "Option::is_none")]
274 pub basic_gen: Option<AiAgentBasicGenTool>,
275}
276
277#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
278pub struct AiAsk {
279 pub mode: AiAskMode,
280 pub prompt: String,
281 pub items: Vec<AiItemAsk>,
282 #[serde(default, skip_serializing_if = "Option::is_none")]
283 pub dialogue_history: Option<Vec<AiDialogueHistory>>,
284 #[serde(default, skip_serializing_if = "Option::is_none")]
285 pub include_citations: Option<bool>,
286 #[serde(default, skip_serializing_if = "Option::is_none")]
287 pub ai_agent: Option<AiAskAgent>,
288}
289
290#[derive(Clone, Debug, PartialEq)]
291pub enum AiAskAgent {
292 AiAgentId(AiAgentReference),
293 AiAgentAsk(AiAgentAsk),
294 Unknown(serde_json::Value),
296}
297
298impl Default for AiAskAgent {
299 fn default() -> Self {
300 Self::Unknown(Default::default())
301 }
302}
303
304impl serde::Serialize for AiAskAgent {
305 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
306 match self {
307 Self::AiAgentId(inner) => inner.serialize(serializer),
308 Self::AiAgentAsk(inner) => inner.serialize(serializer),
309 Self::Unknown(inner) => inner.serialize(serializer),
310 }
311 }
312}
313
314impl<'de> serde::Deserialize<'de> for AiAskAgent {
315 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
316 let value = serde_json::Value::deserialize(deserializer)?;
317 let tag = value
318 .get("type")
319 .and_then(serde_json::Value::as_str)
320 .map(str::to_owned);
321 match tag.as_deref() {
322 Some("ai_agent_id") => Ok(Self::AiAgentId(
323 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
324 )),
325 Some("ai_agent_ask") => Ok(Self::AiAgentAsk(
326 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
327 )),
328 _ => Ok(Self::Unknown(value)),
329 }
330 }
331}
332
333#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
334pub struct AiCitation {
335 #[serde(default, skip_serializing_if = "Option::is_none")]
336 pub content: Option<String>,
337 #[serde(default, skip_serializing_if = "Option::is_none")]
338 pub id: Option<String>,
339 #[serde(default, skip_serializing_if = "Option::is_none")]
340 pub r#type: Option<AiCitationType>,
341 #[serde(default, skip_serializing_if = "Option::is_none")]
342 pub name: Option<String>,
343}
344
345#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
346pub struct AiDialogueHistory {
347 #[serde(default, skip_serializing_if = "Option::is_none")]
348 pub prompt: Option<String>,
349 #[serde(default, skip_serializing_if = "Option::is_none")]
350 pub answer: Option<String>,
351 #[serde(default, skip_serializing_if = "Option::is_none")]
352 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
353}
354
355#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
356pub struct AiExtract {
357 pub prompt: String,
358 pub items: Vec<AiItemBase>,
359 #[serde(default, skip_serializing_if = "Option::is_none")]
360 pub ai_agent: Option<AiExtractAgent>,
361}
362
363#[derive(Clone, Debug, PartialEq)]
364pub enum AiExtractAgent {
365 AiAgentId(AiAgentReference),
366 AiAgentExtract(AiAgentExtract),
367 Unknown(serde_json::Value),
369}
370
371impl Default for AiExtractAgent {
372 fn default() -> Self {
373 Self::Unknown(Default::default())
374 }
375}
376
377impl serde::Serialize for AiExtractAgent {
378 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
379 match self {
380 Self::AiAgentId(inner) => inner.serialize(serializer),
381 Self::AiAgentExtract(inner) => inner.serialize(serializer),
382 Self::Unknown(inner) => inner.serialize(serializer),
383 }
384 }
385}
386
387impl<'de> serde::Deserialize<'de> for AiExtractAgent {
388 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
389 let value = serde_json::Value::deserialize(deserializer)?;
390 let tag = value
391 .get("type")
392 .and_then(serde_json::Value::as_str)
393 .map(str::to_owned);
394 match tag.as_deref() {
395 Some("ai_agent_id") => Ok(Self::AiAgentId(
396 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
397 )),
398 Some("ai_agent_extract") => Ok(Self::AiAgentExtract(
399 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
400 )),
401 _ => Ok(Self::Unknown(value)),
402 }
403 }
404}
405
406#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
407pub struct AiExtractFieldOption {
408 pub key: String,
409}
410
411#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
412pub struct AiExtractResponse {}
413
414#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
415pub struct AiExtractStructured {
416 pub items: Vec<AiItemBase>,
417 #[serde(default, skip_serializing_if = "Option::is_none")]
418 pub metadata_template: Option<AiExtractStructuredMetadataTemplate>,
419 #[serde(default, skip_serializing_if = "Option::is_none")]
420 pub fields: Option<Vec<AiExtractStructuredFields>>,
421 #[serde(default, skip_serializing_if = "Option::is_none")]
422 pub ai_agent: Option<AiExtractStructuredAgent>,
423 #[serde(default, skip_serializing_if = "Option::is_none")]
424 pub include_confidence_score: Option<bool>,
425 #[serde(default, skip_serializing_if = "Option::is_none")]
426 pub include_reference: Option<bool>,
427 #[serde(default, skip_serializing_if = "Option::is_none")]
428 pub taxonomy_sources: Option<Vec<AiTaxonomySource>>,
429}
430
431#[derive(Clone, Debug, PartialEq)]
432pub enum AiExtractStructuredAgent {
433 AiAgentId(AiAgentReference),
434 AiAgentExtractStructured(AiAgentExtractStructured),
435 Unknown(serde_json::Value),
437}
438
439impl Default for AiExtractStructuredAgent {
440 fn default() -> Self {
441 Self::Unknown(Default::default())
442 }
443}
444
445impl serde::Serialize for AiExtractStructuredAgent {
446 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
447 match self {
448 Self::AiAgentId(inner) => inner.serialize(serializer),
449 Self::AiAgentExtractStructured(inner) => inner.serialize(serializer),
450 Self::Unknown(inner) => inner.serialize(serializer),
451 }
452 }
453}
454
455impl<'de> serde::Deserialize<'de> for AiExtractStructuredAgent {
456 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
457 let value = serde_json::Value::deserialize(deserializer)?;
458 let tag = value
459 .get("type")
460 .and_then(serde_json::Value::as_str)
461 .map(str::to_owned);
462 match tag.as_deref() {
463 Some("ai_agent_id") => Ok(Self::AiAgentId(
464 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
465 )),
466 Some("ai_agent_extract_structured") => Ok(Self::AiAgentExtractStructured(
467 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
468 )),
469 _ => Ok(Self::Unknown(value)),
470 }
471 }
472}
473
474#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
475pub struct AiExtractStructuredResponse {
476 pub answer: AiExtractResponse,
477 pub created_at: chrono::DateTime<chrono::Utc>,
478 #[serde(default, skip_serializing_if = "Option::is_none")]
479 pub completion_reason: Option<String>,
480 #[serde(default, skip_serializing_if = "Option::is_none")]
481 pub confidence_score: Option<std::collections::HashMap<String, serde_json::Value>>,
482 #[serde(default, skip_serializing_if = "Option::is_none")]
483 pub reference: Option<std::collections::HashMap<String, serde_json::Value>>,
484 #[serde(default, skip_serializing_if = "Option::is_none")]
485 pub ai_agent_info: Option<AiAgentInfo>,
486}
487
488#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
489pub struct AiExtractSubField {
490 pub key: String,
491 #[serde(default, skip_serializing_if = "Option::is_none")]
492 pub description: Option<String>,
493 #[serde(
494 rename = "displayName",
495 default,
496 skip_serializing_if = "Option::is_none"
497 )]
498 pub display_name: Option<String>,
499 #[serde(default, skip_serializing_if = "Option::is_none")]
500 pub prompt: Option<String>,
501 #[serde(default, skip_serializing_if = "Option::is_none")]
502 pub r#type: Option<String>,
503 #[serde(default, skip_serializing_if = "Option::is_none")]
504 pub options: Option<Vec<AiExtractFieldOption>>,
505}
506
507#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
508pub struct AiItemBase {
509 pub id: String,
510 pub r#type: AiCitationType,
511 #[serde(default, skip_serializing_if = "Option::is_none")]
512 pub content: Option<String>,
513}
514
515#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
516pub struct AiItemAsk {
517 pub id: String,
518 pub r#type: AiItemAskType,
519 #[serde(default, skip_serializing_if = "Option::is_none")]
520 pub content: Option<String>,
521}
522
523#[derive(Clone, Debug, PartialEq)]
524pub enum AiLlmEndpointParams {
525 OpenaiParams(AiLlmEndpointParamsOpenAi),
526 GoogleParams(AiLlmEndpointParamsGoogle),
527 AwsParams(AiLlmEndpointParamsAWS),
528 IbmParams(AiLlmEndpointParamsIBM),
529 Unknown(serde_json::Value),
531}
532
533impl Default for AiLlmEndpointParams {
534 fn default() -> Self {
535 Self::Unknown(Default::default())
536 }
537}
538
539impl serde::Serialize for AiLlmEndpointParams {
540 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
541 match self {
542 Self::OpenaiParams(inner) => inner.serialize(serializer),
543 Self::GoogleParams(inner) => inner.serialize(serializer),
544 Self::AwsParams(inner) => inner.serialize(serializer),
545 Self::IbmParams(inner) => inner.serialize(serializer),
546 Self::Unknown(inner) => inner.serialize(serializer),
547 }
548 }
549}
550
551impl<'de> serde::Deserialize<'de> for AiLlmEndpointParams {
552 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
553 let value = serde_json::Value::deserialize(deserializer)?;
554 let tag = value
555 .get("type")
556 .and_then(serde_json::Value::as_str)
557 .map(str::to_owned);
558 match tag.as_deref() {
559 Some("openai_params") => Ok(Self::OpenaiParams(
560 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
561 )),
562 Some("google_params") => Ok(Self::GoogleParams(
563 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
564 )),
565 Some("aws_params") => Ok(Self::AwsParams(
566 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
567 )),
568 Some("ibm_params") => Ok(Self::IbmParams(
569 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
570 )),
571 _ => Ok(Self::Unknown(value)),
572 }
573 }
574}
575
576#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
577pub struct AiLlmEndpointParamsAWS {
578 pub r#type: AiLlmEndpointParamsAWSType,
579 #[serde(
580 default,
581 skip_serializing_if = "Option::is_none",
582 deserialize_with = "double_option"
583 )]
584 pub temperature: Option<Option<f64>>,
585 #[serde(
586 default,
587 skip_serializing_if = "Option::is_none",
588 deserialize_with = "double_option"
589 )]
590 pub top_p: Option<Option<f64>>,
591}
592
593#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
594pub struct AiLlmEndpointParamsGoogle {
595 pub r#type: AiLlmEndpointParamsGoogleType,
596 #[serde(
597 default,
598 skip_serializing_if = "Option::is_none",
599 deserialize_with = "double_option"
600 )]
601 pub temperature: Option<Option<f64>>,
602 #[serde(
603 default,
604 skip_serializing_if = "Option::is_none",
605 deserialize_with = "double_option"
606 )]
607 pub top_p: Option<Option<f64>>,
608 #[serde(
609 default,
610 skip_serializing_if = "Option::is_none",
611 deserialize_with = "double_option"
612 )]
613 pub top_k: Option<Option<f64>>,
614}
615
616#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
617pub struct AiLlmEndpointParamsIBM {
618 pub r#type: AiLlmEndpointParamsIBMType,
619 #[serde(
620 default,
621 skip_serializing_if = "Option::is_none",
622 deserialize_with = "double_option"
623 )]
624 pub temperature: Option<Option<f64>>,
625 #[serde(
626 default,
627 skip_serializing_if = "Option::is_none",
628 deserialize_with = "double_option"
629 )]
630 pub top_p: Option<Option<f64>>,
631 #[serde(
632 default,
633 skip_serializing_if = "Option::is_none",
634 deserialize_with = "double_option"
635 )]
636 pub top_k: Option<Option<f64>>,
637}
638
639#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
640pub struct AiLlmEndpointParamsOpenAi {
641 pub r#type: AiLlmEndpointParamsOpenAiType,
642 #[serde(
643 default,
644 skip_serializing_if = "Option::is_none",
645 deserialize_with = "double_option"
646 )]
647 pub temperature: Option<Option<f64>>,
648 #[serde(
649 default,
650 skip_serializing_if = "Option::is_none",
651 deserialize_with = "double_option"
652 )]
653 pub top_p: Option<Option<f64>>,
654 #[serde(
655 default,
656 skip_serializing_if = "Option::is_none",
657 deserialize_with = "double_option"
658 )]
659 pub frequency_penalty: Option<Option<f64>>,
660 #[serde(
661 default,
662 skip_serializing_if = "Option::is_none",
663 deserialize_with = "double_option"
664 )]
665 pub presence_penalty: Option<Option<f64>>,
666 #[serde(
667 default,
668 skip_serializing_if = "Option::is_none",
669 deserialize_with = "double_option"
670 )]
671 pub stop: Option<Option<String>>,
672}
673
674#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
675pub struct AiMultipleAgentResponse {
676 #[serde(default, skip_serializing_if = "Option::is_none")]
677 pub limit: Option<i64>,
678 #[serde(
679 default,
680 skip_serializing_if = "Option::is_none",
681 deserialize_with = "double_option"
682 )]
683 pub next_marker: Option<Option<String>>,
684 #[serde(
685 default,
686 skip_serializing_if = "Option::is_none",
687 deserialize_with = "double_option"
688 )]
689 pub prev_marker: Option<Option<String>>,
690 pub entries: Vec<AiSingleAgentResponseFull>,
691}
692
693#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
694pub struct AiOptionsRules {
695 #[serde(default, skip_serializing_if = "Option::is_none")]
696 pub multi_select: Option<bool>,
697 #[serde(default, skip_serializing_if = "Option::is_none")]
698 pub selectable_levels: Option<Vec<i64>>,
699}
700
701#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
702pub struct AiResponse {
703 pub answer: String,
704 pub created_at: chrono::DateTime<chrono::Utc>,
705 #[serde(default, skip_serializing_if = "Option::is_none")]
706 pub completion_reason: Option<String>,
707 #[serde(default, skip_serializing_if = "Option::is_none")]
708 pub ai_agent_info: Option<AiAgentInfo>,
709}
710
711#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
712pub struct AiResponseFull {
713 pub answer: String,
714 pub created_at: chrono::DateTime<chrono::Utc>,
715 #[serde(default, skip_serializing_if = "Option::is_none")]
716 pub completion_reason: Option<String>,
717 #[serde(default, skip_serializing_if = "Option::is_none")]
718 pub ai_agent_info: Option<AiAgentInfo>,
719 #[serde(default, skip_serializing_if = "Option::is_none")]
720 pub citations: Option<Vec<AiCitation>>,
721}
722
723#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
724pub struct AiSingleAgentResponse {
725 pub id: String,
726 #[serde(default, skip_serializing_if = "Option::is_none")]
727 pub r#type: Option<AiSingleAgentResponseType>,
728 pub origin: String,
729 pub name: String,
730 pub access_state: String,
731 #[serde(default, skip_serializing_if = "Option::is_none")]
732 pub created_by: Option<UserBase>,
733 #[serde(default, skip_serializing_if = "Option::is_none")]
734 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
735 #[serde(default, skip_serializing_if = "Option::is_none")]
736 pub modified_by: Option<UserBase>,
737 #[serde(default, skip_serializing_if = "Option::is_none")]
738 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
739 #[serde(default, skip_serializing_if = "Option::is_none")]
740 pub icon_reference: Option<String>,
741 #[serde(default, skip_serializing_if = "Option::is_none")]
742 pub allowed_entities: Option<Vec<AiAgentAllowedEntity>>,
743}
744
745#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
746pub struct AiSingleAgentResponseFull {
747 pub id: String,
748 #[serde(default, skip_serializing_if = "Option::is_none")]
749 pub r#type: Option<AiSingleAgentResponseType>,
750 pub origin: String,
751 pub name: String,
752 pub access_state: String,
753 #[serde(default, skip_serializing_if = "Option::is_none")]
754 pub created_by: Option<UserBase>,
755 #[serde(default, skip_serializing_if = "Option::is_none")]
756 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
757 #[serde(default, skip_serializing_if = "Option::is_none")]
758 pub modified_by: Option<UserBase>,
759 #[serde(default, skip_serializing_if = "Option::is_none")]
760 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
761 #[serde(default, skip_serializing_if = "Option::is_none")]
762 pub icon_reference: Option<String>,
763 #[serde(default, skip_serializing_if = "Option::is_none")]
764 pub allowed_entities: Option<Vec<AiAgentAllowedEntity>>,
765 #[serde(default, skip_serializing_if = "Option::is_none")]
766 pub ask: Option<AiStudioAgentAskResponse>,
767 #[serde(default, skip_serializing_if = "Option::is_none")]
768 pub text_gen: Option<AiStudioAgentTextGenResponse>,
769 #[serde(default, skip_serializing_if = "Option::is_none")]
770 pub extract: Option<AiStudioAgentExtractResponse>,
771}
772
773#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
774pub struct AiStudioAgentAsk {
775 pub r#type: AiAgentAskType,
776 pub access_state: String,
777 pub description: String,
778 #[serde(
779 default,
780 skip_serializing_if = "Option::is_none",
781 deserialize_with = "double_option"
782 )]
783 pub custom_instructions: Option<Option<String>>,
784 #[serde(default, skip_serializing_if = "Option::is_none")]
785 pub suggested_questions: Option<Vec<String>>,
786 #[serde(default, skip_serializing_if = "Option::is_none")]
787 pub long_text: Option<AiStudioAgentLongTextTool>,
788 #[serde(default, skip_serializing_if = "Option::is_none")]
789 pub basic_text: Option<AiStudioAgentBasicTextTool>,
790 #[serde(default, skip_serializing_if = "Option::is_none")]
791 pub basic_image: Option<AiStudioAgentBasicTextTool>,
792 #[serde(default, skip_serializing_if = "Option::is_none")]
793 pub spreadsheet: Option<AiStudioAgentSpreadsheetTool>,
794 #[serde(default, skip_serializing_if = "Option::is_none")]
795 pub long_text_multi: Option<AiStudioAgentLongTextTool>,
796 #[serde(default, skip_serializing_if = "Option::is_none")]
797 pub basic_text_multi: Option<AiStudioAgentBasicTextTool>,
798 #[serde(default, skip_serializing_if = "Option::is_none")]
799 pub basic_image_multi: Option<AiStudioAgentBasicTextTool>,
800}
801
802#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
803pub struct AiStudioAgentAskResponse {
804 pub r#type: AiAgentAskType,
805 pub access_state: String,
806 pub description: String,
807 #[serde(
808 default,
809 skip_serializing_if = "Option::is_none",
810 deserialize_with = "double_option"
811 )]
812 pub custom_instructions: Option<Option<String>>,
813 #[serde(default, skip_serializing_if = "Option::is_none")]
814 pub suggested_questions: Option<Vec<String>>,
815 #[serde(default, skip_serializing_if = "Option::is_none")]
816 pub long_text: Option<AiStudioAgentLongTextToolResponse>,
817 #[serde(default, skip_serializing_if = "Option::is_none")]
818 pub basic_text: Option<AiStudioAgentBasicTextToolResponse>,
819 #[serde(default, skip_serializing_if = "Option::is_none")]
820 pub basic_image: Option<AiStudioAgentBasicTextToolResponse>,
821 #[serde(default, skip_serializing_if = "Option::is_none")]
822 pub spreadsheet: Option<AiStudioAgentSpreadsheetToolResponse>,
823 #[serde(default, skip_serializing_if = "Option::is_none")]
824 pub long_text_multi: Option<AiStudioAgentLongTextToolResponse>,
825 #[serde(default, skip_serializing_if = "Option::is_none")]
826 pub basic_text_multi: Option<AiStudioAgentBasicTextToolResponse>,
827 #[serde(default, skip_serializing_if = "Option::is_none")]
828 pub basic_image_multi: Option<AiStudioAgentBasicTextToolResponse>,
829}
830
831#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
832pub struct AiStudioAgentBasicGenTool {
833 #[serde(default, skip_serializing_if = "Option::is_none")]
834 pub model: Option<String>,
835 #[serde(default, skip_serializing_if = "Option::is_none")]
836 pub num_tokens_for_completion: Option<i64>,
837 #[serde(default, skip_serializing_if = "Option::is_none")]
838 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
839 #[serde(default, skip_serializing_if = "Option::is_none")]
840 pub system_message: Option<String>,
841 #[serde(default, skip_serializing_if = "Option::is_none")]
842 pub prompt_template: Option<String>,
843 #[serde(default, skip_serializing_if = "Option::is_none")]
844 pub embeddings: Option<AiAgentBasicGenToolEmbeddings>,
845 #[serde(default, skip_serializing_if = "Option::is_none")]
846 pub content_template: Option<String>,
847 #[serde(default, skip_serializing_if = "Option::is_none")]
848 pub is_custom_instructions_included: Option<bool>,
849}
850
851#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
852pub struct AiStudioAgentBasicGenToolResponse {
853 #[serde(default, skip_serializing_if = "Option::is_none")]
854 pub model: Option<String>,
855 #[serde(default, skip_serializing_if = "Option::is_none")]
856 pub num_tokens_for_completion: Option<i64>,
857 #[serde(default, skip_serializing_if = "Option::is_none")]
858 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
859 #[serde(default, skip_serializing_if = "Option::is_none")]
860 pub system_message: Option<String>,
861 #[serde(default, skip_serializing_if = "Option::is_none")]
862 pub prompt_template: Option<String>,
863 #[serde(default, skip_serializing_if = "Option::is_none")]
864 pub embeddings: Option<AiAgentBasicGenToolEmbeddings>,
865 #[serde(default, skip_serializing_if = "Option::is_none")]
866 pub content_template: Option<String>,
867 #[serde(default, skip_serializing_if = "Option::is_none")]
868 pub is_custom_instructions_included: Option<bool>,
869 #[serde(default, skip_serializing_if = "Option::is_none")]
870 pub warnings: Option<Vec<String>>,
871}
872
873#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
874pub struct AiStudioAgentBasicTextTool {
875 #[serde(default, skip_serializing_if = "Option::is_none")]
876 pub model: Option<String>,
877 #[serde(default, skip_serializing_if = "Option::is_none")]
878 pub num_tokens_for_completion: Option<i64>,
879 #[serde(default, skip_serializing_if = "Option::is_none")]
880 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
881 #[serde(default, skip_serializing_if = "Option::is_none")]
882 pub system_message: Option<String>,
883 #[serde(default, skip_serializing_if = "Option::is_none")]
884 pub prompt_template: Option<String>,
885 #[serde(default, skip_serializing_if = "Option::is_none")]
886 pub is_custom_instructions_included: Option<bool>,
887}
888
889#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
890pub struct AiStudioAgentBasicTextToolResponse {
891 #[serde(default, skip_serializing_if = "Option::is_none")]
892 pub model: Option<String>,
893 #[serde(default, skip_serializing_if = "Option::is_none")]
894 pub num_tokens_for_completion: Option<i64>,
895 #[serde(default, skip_serializing_if = "Option::is_none")]
896 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
897 #[serde(default, skip_serializing_if = "Option::is_none")]
898 pub system_message: Option<String>,
899 #[serde(default, skip_serializing_if = "Option::is_none")]
900 pub prompt_template: Option<String>,
901 #[serde(default, skip_serializing_if = "Option::is_none")]
902 pub is_custom_instructions_included: Option<bool>,
903 #[serde(default, skip_serializing_if = "Option::is_none")]
904 pub warnings: Option<Vec<String>>,
905}
906
907#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
908pub struct AiStudioAgentExtract {
909 pub r#type: AiAgentExtractType,
910 pub access_state: String,
911 pub description: String,
912 #[serde(
913 default,
914 skip_serializing_if = "Option::is_none",
915 deserialize_with = "double_option"
916 )]
917 pub custom_instructions: Option<Option<String>>,
918 #[serde(default, skip_serializing_if = "Option::is_none")]
919 pub long_text: Option<AiStudioAgentLongTextTool>,
920 #[serde(default, skip_serializing_if = "Option::is_none")]
921 pub basic_text: Option<AiStudioAgentBasicTextTool>,
922 #[serde(default, skip_serializing_if = "Option::is_none")]
923 pub basic_image: Option<AiStudioAgentBasicTextTool>,
924}
925
926#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
927pub struct AiStudioAgentExtractResponse {
928 pub r#type: AiAgentExtractType,
929 pub access_state: String,
930 pub description: String,
931 #[serde(
932 default,
933 skip_serializing_if = "Option::is_none",
934 deserialize_with = "double_option"
935 )]
936 pub custom_instructions: Option<Option<String>>,
937 #[serde(default, skip_serializing_if = "Option::is_none")]
938 pub long_text: Option<AiStudioAgentLongTextToolResponse>,
939 #[serde(default, skip_serializing_if = "Option::is_none")]
940 pub basic_text: Option<AiStudioAgentBasicTextToolResponse>,
941 #[serde(default, skip_serializing_if = "Option::is_none")]
942 pub basic_image: Option<AiStudioAgentBasicTextToolResponse>,
943}
944
945#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
946pub struct AiStudioAgentLongTextTool {
947 #[serde(default, skip_serializing_if = "Option::is_none")]
948 pub model: Option<String>,
949 #[serde(default, skip_serializing_if = "Option::is_none")]
950 pub num_tokens_for_completion: Option<i64>,
951 #[serde(default, skip_serializing_if = "Option::is_none")]
952 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
953 #[serde(default, skip_serializing_if = "Option::is_none")]
954 pub system_message: Option<String>,
955 #[serde(default, skip_serializing_if = "Option::is_none")]
956 pub prompt_template: Option<String>,
957 #[serde(default, skip_serializing_if = "Option::is_none")]
958 pub embeddings: Option<AiAgentBasicGenToolEmbeddings>,
959 #[serde(default, skip_serializing_if = "Option::is_none")]
960 pub is_custom_instructions_included: Option<bool>,
961}
962
963#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
964pub struct AiStudioAgentLongTextToolResponse {
965 #[serde(default, skip_serializing_if = "Option::is_none")]
966 pub model: Option<String>,
967 #[serde(default, skip_serializing_if = "Option::is_none")]
968 pub num_tokens_for_completion: Option<i64>,
969 #[serde(default, skip_serializing_if = "Option::is_none")]
970 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
971 #[serde(default, skip_serializing_if = "Option::is_none")]
972 pub system_message: Option<String>,
973 #[serde(default, skip_serializing_if = "Option::is_none")]
974 pub prompt_template: Option<String>,
975 #[serde(default, skip_serializing_if = "Option::is_none")]
976 pub embeddings: Option<AiAgentBasicGenToolEmbeddings>,
977 #[serde(default, skip_serializing_if = "Option::is_none")]
978 pub is_custom_instructions_included: Option<bool>,
979 #[serde(default, skip_serializing_if = "Option::is_none")]
980 pub warnings: Option<Vec<String>>,
981}
982
983pub type AiStudioAgentSpreadsheetTool = AiAgentSpreadsheetTool;
984
985#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
986pub struct AiStudioAgentSpreadsheetToolResponse {
987 #[serde(default, skip_serializing_if = "Option::is_none")]
988 pub model: Option<String>,
989 #[serde(default, skip_serializing_if = "Option::is_none")]
990 pub num_tokens_for_completion: Option<i64>,
991 #[serde(default, skip_serializing_if = "Option::is_none")]
992 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
993 #[serde(default, skip_serializing_if = "Option::is_none")]
994 pub warnings: Option<Vec<String>>,
995}
996
997#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
998pub struct AiStudioAgentTextGen {
999 pub r#type: AiAgentTextGenType,
1000 pub access_state: String,
1001 pub description: String,
1002 #[serde(
1003 default,
1004 skip_serializing_if = "Option::is_none",
1005 deserialize_with = "double_option"
1006 )]
1007 pub custom_instructions: Option<Option<String>>,
1008 #[serde(default, skip_serializing_if = "Option::is_none")]
1009 pub suggested_questions: Option<Vec<String>>,
1010 #[serde(default, skip_serializing_if = "Option::is_none")]
1011 pub basic_gen: Option<AiStudioAgentBasicGenTool>,
1012}
1013
1014#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1015pub struct AiStudioAgentTextGenResponse {
1016 pub r#type: AiAgentTextGenType,
1017 pub access_state: String,
1018 pub description: String,
1019 #[serde(
1020 default,
1021 skip_serializing_if = "Option::is_none",
1022 deserialize_with = "double_option"
1023 )]
1024 pub custom_instructions: Option<Option<String>>,
1025 #[serde(default, skip_serializing_if = "Option::is_none")]
1026 pub suggested_questions: Option<Vec<String>>,
1027 #[serde(default, skip_serializing_if = "Option::is_none")]
1028 pub basic_gen: Option<AiStudioAgentBasicGenToolResponse>,
1029}
1030
1031#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1032pub struct AiTaxonomyFileReference {
1033 #[serde(default, skip_serializing_if = "Option::is_none")]
1034 pub r#type: Option<AiCitationType>,
1035 #[serde(default, skip_serializing_if = "Option::is_none")]
1036 pub taxonomy_key: Option<String>,
1037 #[serde(default, skip_serializing_if = "Option::is_none")]
1038 pub id: Option<String>,
1039}
1040
1041#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1042pub struct AiTaxonomyReference {
1043 #[serde(default, skip_serializing_if = "Option::is_none")]
1044 pub r#type: Option<AiTaxonomyReferenceType>,
1045 #[serde(default, skip_serializing_if = "Option::is_none")]
1046 pub taxonomy_key: Option<String>,
1047 #[serde(default, skip_serializing_if = "Option::is_none")]
1048 pub namespace: Option<String>,
1049}
1050
1051#[derive(Clone, Debug, PartialEq)]
1052pub enum AiTaxonomySource {
1053 Taxonomy(AiTaxonomyReference),
1054 File(AiTaxonomyFileReference),
1055 Unknown(serde_json::Value),
1057}
1058
1059impl Default for AiTaxonomySource {
1060 fn default() -> Self {
1061 Self::Unknown(Default::default())
1062 }
1063}
1064
1065impl serde::Serialize for AiTaxonomySource {
1066 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1067 match self {
1068 Self::Taxonomy(inner) => inner.serialize(serializer),
1069 Self::File(inner) => inner.serialize(serializer),
1070 Self::Unknown(inner) => inner.serialize(serializer),
1071 }
1072 }
1073}
1074
1075impl<'de> serde::Deserialize<'de> for AiTaxonomySource {
1076 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1077 let value = serde_json::Value::deserialize(deserializer)?;
1078 let tag = value
1079 .get("type")
1080 .and_then(serde_json::Value::as_str)
1081 .map(str::to_owned);
1082 match tag.as_deref() {
1083 Some("taxonomy") => Ok(Self::Taxonomy(
1084 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1085 )),
1086 Some("file") => Ok(Self::File(
1087 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1088 )),
1089 _ => Ok(Self::Unknown(value)),
1090 }
1091 }
1092}
1093
1094#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1095pub struct AiTextGen {
1096 pub prompt: String,
1097 pub items: Vec<AiTextGenItems>,
1098 #[serde(default, skip_serializing_if = "Option::is_none")]
1099 pub dialogue_history: Option<Vec<AiDialogueHistory>>,
1100 #[serde(default, skip_serializing_if = "Option::is_none")]
1101 pub ai_agent: Option<AiTextGenAgent>,
1102}
1103
1104#[derive(Clone, Debug, PartialEq)]
1105pub enum AiTextGenAgent {
1106 AiAgentId(AiAgentReference),
1107 AiAgentTextGen(AiAgentTextGen),
1108 Unknown(serde_json::Value),
1110}
1111
1112impl Default for AiTextGenAgent {
1113 fn default() -> Self {
1114 Self::Unknown(Default::default())
1115 }
1116}
1117
1118impl serde::Serialize for AiTextGenAgent {
1119 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1120 match self {
1121 Self::AiAgentId(inner) => inner.serialize(serializer),
1122 Self::AiAgentTextGen(inner) => inner.serialize(serializer),
1123 Self::Unknown(inner) => inner.serialize(serializer),
1124 }
1125 }
1126}
1127
1128impl<'de> serde::Deserialize<'de> for AiTextGenAgent {
1129 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1130 let value = serde_json::Value::deserialize(deserializer)?;
1131 let tag = value
1132 .get("type")
1133 .and_then(serde_json::Value::as_str)
1134 .map(str::to_owned);
1135 match tag.as_deref() {
1136 Some("ai_agent_id") => Ok(Self::AiAgentId(
1137 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1138 )),
1139 Some("ai_agent_text_gen") => Ok(Self::AiAgentTextGen(
1140 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1141 )),
1142 _ => Ok(Self::Unknown(value)),
1143 }
1144 }
1145}
1146
1147#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1148pub struct AppItem {
1149 pub id: String,
1150 pub r#type: AppItemType,
1151 pub application_type: String,
1152}
1153
1154#[derive(Clone, Debug, PartialEq)]
1155pub enum AppItemAssociatedItem {
1156 File(FileBase),
1157 Folder(FolderBase),
1158 WebLink(WebLinkBase),
1159 Unknown(serde_json::Value),
1161}
1162
1163impl Default for AppItemAssociatedItem {
1164 fn default() -> Self {
1165 Self::Unknown(Default::default())
1166 }
1167}
1168
1169impl serde::Serialize for AppItemAssociatedItem {
1170 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1171 match self {
1172 Self::File(inner) => inner.serialize(serializer),
1173 Self::Folder(inner) => inner.serialize(serializer),
1174 Self::WebLink(inner) => inner.serialize(serializer),
1175 Self::Unknown(inner) => inner.serialize(serializer),
1176 }
1177 }
1178}
1179
1180impl<'de> serde::Deserialize<'de> for AppItemAssociatedItem {
1181 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1182 let value = serde_json::Value::deserialize(deserializer)?;
1183 let tag = value
1184 .get("type")
1185 .and_then(serde_json::Value::as_str)
1186 .map(str::to_owned);
1187 match tag.as_deref() {
1188 Some("file") => Ok(Self::File(
1189 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1190 )),
1191 Some("folder") => Ok(Self::Folder(
1192 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1193 )),
1194 Some("web_link") => Ok(Self::WebLink(
1195 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1196 )),
1197 _ => Ok(Self::Unknown(value)),
1198 }
1199 }
1200}
1201
1202#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1203pub struct AppItemAssociation {
1204 pub id: String,
1205 pub r#type: AppItemAssociationType,
1206 pub app_item: AppItem,
1207 pub item: AppItemAssociatedItem,
1208}
1209
1210#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1211pub struct AppItemAssociations {
1212 #[serde(default, skip_serializing_if = "Option::is_none")]
1213 pub limit: Option<i64>,
1214 #[serde(
1215 default,
1216 skip_serializing_if = "Option::is_none",
1217 deserialize_with = "double_option"
1218 )]
1219 pub next_marker: Option<Option<String>>,
1220 #[serde(
1221 default,
1222 skip_serializing_if = "Option::is_none",
1223 deserialize_with = "double_option"
1224 )]
1225 pub prev_marker: Option<Option<String>>,
1226 #[serde(default, skip_serializing_if = "Option::is_none")]
1227 pub entries: Option<Vec<AppItemAssociation>>,
1228}
1229
1230#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1231pub struct AppItemEventSource {
1232 pub id: String,
1233 pub r#type: AppItemType,
1234 pub app_item_type: String,
1235 #[serde(default, skip_serializing_if = "Option::is_none")]
1236 pub user: Option<UserMini>,
1237 #[serde(default, skip_serializing_if = "Option::is_none")]
1238 pub group: Option<GroupMini>,
1239}
1240
1241#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1242pub struct Classification {
1243 #[serde(
1244 rename = "Box__Security__Classification__Key",
1245 default,
1246 skip_serializing_if = "Option::is_none"
1247 )]
1248 pub box_security_classification_key: Option<String>,
1249 #[serde(rename = "$parent", default, skip_serializing_if = "Option::is_none")]
1250 pub parent: Option<String>,
1251 #[serde(rename = "$template", default, skip_serializing_if = "Option::is_none")]
1252 pub template: Option<ClassificationTemplate2>,
1253 #[serde(rename = "$scope", default, skip_serializing_if = "Option::is_none")]
1254 pub scope: Option<String>,
1255 #[serde(rename = "$version", default, skip_serializing_if = "Option::is_none")]
1256 pub version: Option<i64>,
1257 #[serde(rename = "$type", default, skip_serializing_if = "Option::is_none")]
1258 pub r#type: Option<String>,
1259 #[serde(
1260 rename = "$typeVersion",
1261 default,
1262 skip_serializing_if = "Option::is_none"
1263 )]
1264 pub type_version: Option<f64>,
1265 #[serde(rename = "$canEdit", default, skip_serializing_if = "Option::is_none")]
1266 pub can_edit: Option<bool>,
1267}
1268
1269#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1270pub struct ClassificationTemplate {
1271 pub id: String,
1272 pub r#type: MetadataTemplateType,
1273 pub scope: String,
1274 #[serde(rename = "templateKey")]
1275 pub template_key: ClassificationTemplate2,
1276 #[serde(rename = "displayName")]
1277 pub display_name: ClassificationTemplateDisplayName,
1278 #[serde(default, skip_serializing_if = "Option::is_none")]
1279 pub hidden: Option<bool>,
1280 #[serde(
1281 rename = "copyInstanceOnItemCopy",
1282 default,
1283 skip_serializing_if = "Option::is_none"
1284 )]
1285 pub copy_instance_on_item_copy: Option<bool>,
1286 pub fields: Vec<ClassificationTemplateFields>,
1287}
1288
1289#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1290pub struct ClientError {
1291 #[serde(default, skip_serializing_if = "Option::is_none")]
1292 pub r#type: Option<ClientErrorType>,
1293 #[serde(default, skip_serializing_if = "Option::is_none")]
1294 pub status: Option<i64>,
1295 #[serde(default, skip_serializing_if = "Option::is_none")]
1296 pub code: Option<ClientErrorCode>,
1297 #[serde(default, skip_serializing_if = "Option::is_none")]
1298 pub message: Option<String>,
1299 #[serde(
1300 default,
1301 skip_serializing_if = "Option::is_none",
1302 deserialize_with = "double_option"
1303 )]
1304 pub context_info: Option<Option<std::collections::HashMap<String, serde_json::Value>>>,
1305 #[serde(default, skip_serializing_if = "Option::is_none")]
1306 pub help_url: Option<String>,
1307 #[serde(default, skip_serializing_if = "Option::is_none")]
1308 pub request_id: Option<String>,
1309}
1310
1311#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1312pub struct Collaboration {
1313 pub id: String,
1314 pub r#type: CollaborationType,
1315 #[serde(
1316 default,
1317 skip_serializing_if = "Option::is_none",
1318 deserialize_with = "double_option"
1319 )]
1320 pub item: Option<Option<CollaborationItem>>,
1321 #[serde(
1322 default,
1323 skip_serializing_if = "Option::is_none",
1324 deserialize_with = "double_option"
1325 )]
1326 pub app_item: Option<Option<AppItem>>,
1327 #[serde(default, skip_serializing_if = "Option::is_none")]
1328 pub accessible_by: Option<CollaborationAccessGrantee>,
1329 #[serde(
1330 default,
1331 skip_serializing_if = "Option::is_none",
1332 deserialize_with = "double_option"
1333 )]
1334 pub invite_email: Option<Option<String>>,
1335 #[serde(default, skip_serializing_if = "Option::is_none")]
1336 pub role: Option<CollaborationRole>,
1337 #[serde(
1338 default,
1339 skip_serializing_if = "Option::is_none",
1340 deserialize_with = "double_option"
1341 )]
1342 pub expires_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1343 #[serde(default, skip_serializing_if = "Option::is_none")]
1344 pub is_access_only: Option<bool>,
1345 #[serde(default, skip_serializing_if = "Option::is_none")]
1346 pub status: Option<CollaborationStatus>,
1347 #[serde(default, skip_serializing_if = "Option::is_none")]
1348 pub acknowledged_at: Option<chrono::DateTime<chrono::Utc>>,
1349 #[serde(default, skip_serializing_if = "Option::is_none")]
1350 pub created_by: Option<UserCollaborations>,
1351 #[serde(default, skip_serializing_if = "Option::is_none")]
1352 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1353 #[serde(default, skip_serializing_if = "Option::is_none")]
1354 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
1355 #[serde(default, skip_serializing_if = "Option::is_none")]
1356 pub acceptance_requirements_status: Option<CollaborationAcceptanceRequirementsStatus>,
1357}
1358
1359#[derive(Clone, Debug, PartialEq)]
1360pub enum CollaborationAccessGrantee {
1361 User(UserCollaborations),
1362 Group(GroupMini),
1363 Unknown(serde_json::Value),
1365}
1366
1367impl Default for CollaborationAccessGrantee {
1368 fn default() -> Self {
1369 Self::Unknown(Default::default())
1370 }
1371}
1372
1373impl serde::Serialize for CollaborationAccessGrantee {
1374 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1375 match self {
1376 Self::User(inner) => inner.serialize(serializer),
1377 Self::Group(inner) => inner.serialize(serializer),
1378 Self::Unknown(inner) => inner.serialize(serializer),
1379 }
1380 }
1381}
1382
1383impl<'de> serde::Deserialize<'de> for CollaborationAccessGrantee {
1384 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1385 let value = serde_json::Value::deserialize(deserializer)?;
1386 let tag = value
1387 .get("type")
1388 .and_then(serde_json::Value::as_str)
1389 .map(str::to_owned);
1390 match tag.as_deref() {
1391 Some("user") => Ok(Self::User(
1392 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1393 )),
1394 Some("group") => Ok(Self::Group(
1395 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1396 )),
1397 _ => Ok(Self::Unknown(value)),
1398 }
1399 }
1400}
1401
1402#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1403pub struct CollaborationAllowlistEntries {
1404 #[serde(default, skip_serializing_if = "Option::is_none")]
1405 pub limit: Option<i64>,
1406 #[serde(
1407 default,
1408 skip_serializing_if = "Option::is_none",
1409 deserialize_with = "double_option"
1410 )]
1411 pub next_marker: Option<Option<String>>,
1412 #[serde(
1413 default,
1414 skip_serializing_if = "Option::is_none",
1415 deserialize_with = "double_option"
1416 )]
1417 pub prev_marker: Option<Option<String>>,
1418 #[serde(default, skip_serializing_if = "Option::is_none")]
1419 pub entries: Option<Vec<CollaborationAllowlistEntry>>,
1420}
1421
1422#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1423pub struct CollaborationAllowlistEntry {
1424 #[serde(default, skip_serializing_if = "Option::is_none")]
1425 pub id: Option<String>,
1426 #[serde(default, skip_serializing_if = "Option::is_none")]
1427 pub r#type: Option<CollaborationAllowlistEntryType>,
1428 #[serde(default, skip_serializing_if = "Option::is_none")]
1429 pub domain: Option<String>,
1430 #[serde(default, skip_serializing_if = "Option::is_none")]
1431 pub direction: Option<CollaborationAllowlistEntryDirection>,
1432 #[serde(default, skip_serializing_if = "Option::is_none")]
1433 pub enterprise: Option<CollaborationAllowlistEntryEnterprise>,
1434 #[serde(default, skip_serializing_if = "Option::is_none")]
1435 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1436}
1437
1438#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1439pub struct CollaborationAllowlistExemptTarget {
1440 #[serde(default, skip_serializing_if = "Option::is_none")]
1441 pub id: Option<String>,
1442 #[serde(default, skip_serializing_if = "Option::is_none")]
1443 pub r#type: Option<CollaborationAllowlistExemptTargetType>,
1444 #[serde(default, skip_serializing_if = "Option::is_none")]
1445 pub enterprise: Option<CollaborationAllowlistEntryEnterprise>,
1446 #[serde(default, skip_serializing_if = "Option::is_none")]
1447 pub user: Option<UserMini>,
1448 #[serde(default, skip_serializing_if = "Option::is_none")]
1449 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1450 #[serde(default, skip_serializing_if = "Option::is_none")]
1451 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
1452}
1453
1454#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1455pub struct CollaborationAllowlistExemptTargets {
1456 #[serde(default, skip_serializing_if = "Option::is_none")]
1457 pub limit: Option<i64>,
1458 #[serde(
1459 default,
1460 skip_serializing_if = "Option::is_none",
1461 deserialize_with = "double_option"
1462 )]
1463 pub next_marker: Option<Option<String>>,
1464 #[serde(
1465 default,
1466 skip_serializing_if = "Option::is_none",
1467 deserialize_with = "double_option"
1468 )]
1469 pub prev_marker: Option<Option<String>>,
1470 #[serde(default, skip_serializing_if = "Option::is_none")]
1471 pub entries: Option<Vec<CollaborationAllowlistExemptTarget>>,
1472}
1473
1474#[derive(Clone, Debug, PartialEq)]
1475pub enum CollaborationItem {
1476 File(File),
1477 Folder(Folder),
1478 WebLink(WebLink),
1479 Unknown(serde_json::Value),
1481}
1482
1483impl Default for CollaborationItem {
1484 fn default() -> Self {
1485 Self::Unknown(Default::default())
1486 }
1487}
1488
1489impl serde::Serialize for CollaborationItem {
1490 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1491 match self {
1492 Self::File(inner) => inner.serialize(serializer),
1493 Self::Folder(inner) => inner.serialize(serializer),
1494 Self::WebLink(inner) => inner.serialize(serializer),
1495 Self::Unknown(inner) => inner.serialize(serializer),
1496 }
1497 }
1498}
1499
1500impl<'de> serde::Deserialize<'de> for CollaborationItem {
1501 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1502 let value = serde_json::Value::deserialize(deserializer)?;
1503 let tag = value
1504 .get("type")
1505 .and_then(serde_json::Value::as_str)
1506 .map(str::to_owned);
1507 match tag.as_deref() {
1508 Some("file") => Ok(Self::File(
1509 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1510 )),
1511 Some("folder") => Ok(Self::Folder(
1512 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1513 )),
1514 Some("web_link") => Ok(Self::WebLink(
1515 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1516 )),
1517 _ => Ok(Self::Unknown(value)),
1518 }
1519 }
1520}
1521
1522#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1523pub struct Collaborations {
1524 #[serde(default, skip_serializing_if = "Option::is_none")]
1525 pub limit: Option<i64>,
1526 #[serde(
1527 default,
1528 skip_serializing_if = "Option::is_none",
1529 deserialize_with = "double_option"
1530 )]
1531 pub next_marker: Option<Option<String>>,
1532 #[serde(
1533 default,
1534 skip_serializing_if = "Option::is_none",
1535 deserialize_with = "double_option"
1536 )]
1537 pub prev_marker: Option<Option<String>>,
1538 #[serde(default, skip_serializing_if = "Option::is_none")]
1539 pub entries: Option<Vec<Collaboration>>,
1540}
1541
1542#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1543pub struct CollaborationsOffsetPaginated {
1544 #[serde(default, skip_serializing_if = "Option::is_none")]
1545 pub total_count: Option<i64>,
1546 #[serde(default, skip_serializing_if = "Option::is_none")]
1547 pub limit: Option<i64>,
1548 #[serde(default, skip_serializing_if = "Option::is_none")]
1549 pub offset: Option<i64>,
1550 #[serde(default, skip_serializing_if = "Option::is_none")]
1551 pub entries: Option<Vec<Collaboration>>,
1552}
1553
1554#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1555pub struct CollaboratorVariable {
1556 pub r#type: CollaboratorVariableType,
1557 pub variable_type: CollaboratorVariableVariableType,
1558 pub variable_value: Vec<CollaboratorVariableVariableValue>,
1559}
1560
1561#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1562pub struct Collection {
1563 #[serde(default, skip_serializing_if = "Option::is_none")]
1564 pub id: Option<String>,
1565 #[serde(default, skip_serializing_if = "Option::is_none")]
1566 pub r#type: Option<CollectionType>,
1567 #[serde(default, skip_serializing_if = "Option::is_none")]
1568 pub name: Option<CollectionName>,
1569 #[serde(default, skip_serializing_if = "Option::is_none")]
1570 pub collection_type: Option<CollectionCollectionType>,
1571}
1572
1573#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1574pub struct Collections {
1575 #[serde(default, skip_serializing_if = "Option::is_none")]
1576 pub total_count: Option<i64>,
1577 #[serde(default, skip_serializing_if = "Option::is_none")]
1578 pub limit: Option<i64>,
1579 #[serde(default, skip_serializing_if = "Option::is_none")]
1580 pub offset: Option<i64>,
1581 #[serde(default, skip_serializing_if = "Option::is_none")]
1582 pub order: Option<Vec<CollectionsOrder>>,
1583 #[serde(default, skip_serializing_if = "Option::is_none")]
1584 pub entries: Option<Vec<Collection>>,
1585}
1586
1587#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1588pub struct Comment {
1589 #[serde(default, skip_serializing_if = "Option::is_none")]
1590 pub id: Option<String>,
1591 #[serde(default, skip_serializing_if = "Option::is_none")]
1592 pub r#type: Option<CommentType>,
1593 #[serde(default, skip_serializing_if = "Option::is_none")]
1594 pub is_reply_comment: Option<bool>,
1595 #[serde(default, skip_serializing_if = "Option::is_none")]
1596 pub message: Option<String>,
1597 #[serde(default, skip_serializing_if = "Option::is_none")]
1598 pub created_by: Option<UserMini>,
1599 #[serde(default, skip_serializing_if = "Option::is_none")]
1600 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1601 #[serde(default, skip_serializing_if = "Option::is_none")]
1602 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
1603 #[serde(default, skip_serializing_if = "Option::is_none")]
1604 pub item: Option<CommentItem>,
1605}
1606
1607#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1608pub struct CommentBase {
1609 #[serde(default, skip_serializing_if = "Option::is_none")]
1610 pub id: Option<String>,
1611 #[serde(default, skip_serializing_if = "Option::is_none")]
1612 pub r#type: Option<CommentType>,
1613}
1614
1615#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1616pub struct CommentFull {
1617 #[serde(default, skip_serializing_if = "Option::is_none")]
1618 pub id: Option<String>,
1619 #[serde(default, skip_serializing_if = "Option::is_none")]
1620 pub r#type: Option<CommentType>,
1621 #[serde(default, skip_serializing_if = "Option::is_none")]
1622 pub is_reply_comment: Option<bool>,
1623 #[serde(default, skip_serializing_if = "Option::is_none")]
1624 pub message: Option<String>,
1625 #[serde(default, skip_serializing_if = "Option::is_none")]
1626 pub created_by: Option<UserMini>,
1627 #[serde(default, skip_serializing_if = "Option::is_none")]
1628 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1629 #[serde(default, skip_serializing_if = "Option::is_none")]
1630 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
1631 #[serde(default, skip_serializing_if = "Option::is_none")]
1632 pub item: Option<CommentItem>,
1633 #[serde(default, skip_serializing_if = "Option::is_none")]
1634 pub tagged_message: Option<String>,
1635}
1636
1637#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1638pub struct Comments {
1639 #[serde(default, skip_serializing_if = "Option::is_none")]
1640 pub total_count: Option<i64>,
1641 #[serde(default, skip_serializing_if = "Option::is_none")]
1642 pub limit: Option<i64>,
1643 #[serde(default, skip_serializing_if = "Option::is_none")]
1644 pub offset: Option<i64>,
1645 #[serde(default, skip_serializing_if = "Option::is_none")]
1646 pub order: Option<Vec<CollectionsOrder>>,
1647 #[serde(default, skip_serializing_if = "Option::is_none")]
1648 pub entries: Option<Vec<CommentFull>>,
1649}
1650
1651#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1652pub struct CompletionRuleVariable {
1653 pub r#type: CollaboratorVariableType,
1654 pub variable_type: CompletionRuleVariableVariableType,
1655 pub variable_value: CompletionRuleVariableVariableValue,
1656}
1657
1658#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1659pub struct ConflictError {
1660 #[serde(default, skip_serializing_if = "Option::is_none")]
1661 pub r#type: Option<ClientErrorType>,
1662 #[serde(default, skip_serializing_if = "Option::is_none")]
1663 pub status: Option<i64>,
1664 #[serde(default, skip_serializing_if = "Option::is_none")]
1665 pub code: Option<ClientErrorCode>,
1666 #[serde(default, skip_serializing_if = "Option::is_none")]
1667 pub message: Option<String>,
1668 #[serde(default, skip_serializing_if = "Option::is_none")]
1669 pub context_info: Option<ConflictErrorContextInfo>,
1670 #[serde(default, skip_serializing_if = "Option::is_none")]
1671 pub help_url: Option<String>,
1672 #[serde(default, skip_serializing_if = "Option::is_none")]
1673 pub request_id: Option<String>,
1674}
1675
1676#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1677pub struct CreateAiAgent {
1678 pub r#type: AiSingleAgentResponseType,
1679 pub name: String,
1680 pub access_state: String,
1681 #[serde(default, skip_serializing_if = "Option::is_none")]
1682 pub icon_reference: Option<String>,
1683 #[serde(default, skip_serializing_if = "Option::is_none")]
1684 pub allowed_entities: Option<Vec<AiAgentAllowedEntity>>,
1685 #[serde(default, skip_serializing_if = "Option::is_none")]
1686 pub ask: Option<AiStudioAgentAsk>,
1687 #[serde(default, skip_serializing_if = "Option::is_none")]
1688 pub text_gen: Option<AiStudioAgentTextGen>,
1689 #[serde(default, skip_serializing_if = "Option::is_none")]
1690 pub extract: Option<AiStudioAgentExtract>,
1691}
1692
1693#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1694pub struct DevicePinner {
1695 #[serde(default, skip_serializing_if = "Option::is_none")]
1696 pub id: Option<String>,
1697 #[serde(default, skip_serializing_if = "Option::is_none")]
1698 pub r#type: Option<DevicePinnerType>,
1699 #[serde(default, skip_serializing_if = "Option::is_none")]
1700 pub owned_by: Option<UserMini>,
1701 #[serde(default, skip_serializing_if = "Option::is_none")]
1702 pub product_name: Option<String>,
1703}
1704
1705#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1706pub struct DevicePinners {
1707 #[serde(default, skip_serializing_if = "Option::is_none")]
1708 pub entries: Option<Vec<DevicePinner>>,
1709 #[serde(default, skip_serializing_if = "Option::is_none")]
1710 pub limit: Option<i64>,
1711 #[serde(default, skip_serializing_if = "Option::is_none")]
1712 pub next_marker: Option<i64>,
1713 #[serde(default, skip_serializing_if = "Option::is_none")]
1714 pub order: Option<Vec<DevicePinnersOrder>>,
1715}
1716
1717#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1718pub struct EmailAlias {
1719 #[serde(default, skip_serializing_if = "Option::is_none")]
1720 pub id: Option<String>,
1721 #[serde(default, skip_serializing_if = "Option::is_none")]
1722 pub r#type: Option<EmailAliasType>,
1723 #[serde(default, skip_serializing_if = "Option::is_none")]
1724 pub email: Option<String>,
1725 #[serde(default, skip_serializing_if = "Option::is_none")]
1726 pub is_confirmed: Option<bool>,
1727}
1728
1729#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1730pub struct EmailAliases {
1731 #[serde(default, skip_serializing_if = "Option::is_none")]
1732 pub total_count: Option<i64>,
1733 #[serde(default, skip_serializing_if = "Option::is_none")]
1734 pub entries: Option<Vec<EmailAlias>>,
1735}
1736
1737#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1738pub struct EnterpriseBase {
1739 #[serde(default, skip_serializing_if = "Option::is_none")]
1740 pub id: Option<String>,
1741 #[serde(default, skip_serializing_if = "Option::is_none")]
1742 pub r#type: Option<EnterpriseType>,
1743}
1744
1745#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1746pub struct Event {
1747 #[serde(default, skip_serializing_if = "Option::is_none")]
1748 pub r#type: Option<String>,
1749 #[serde(default, skip_serializing_if = "Option::is_none")]
1750 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1751 #[serde(default, skip_serializing_if = "Option::is_none")]
1752 pub recorded_at: Option<chrono::DateTime<chrono::Utc>>,
1753 #[serde(default, skip_serializing_if = "Option::is_none")]
1754 pub event_id: Option<String>,
1755 #[serde(default, skip_serializing_if = "Option::is_none")]
1756 pub created_by: Option<UserMini>,
1757 #[serde(default, skip_serializing_if = "Option::is_none")]
1758 pub event_type: Option<EventEventType>,
1759 #[serde(default, skip_serializing_if = "Option::is_none")]
1760 pub session_id: Option<String>,
1761 #[serde(default, skip_serializing_if = "Option::is_none")]
1762 pub source: Option<EventSourceResource>,
1763 #[serde(default, skip_serializing_if = "Option::is_none")]
1764 pub additional_details: Option<std::collections::HashMap<String, serde_json::Value>>,
1765}
1766
1767#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1768pub struct Events {
1769 #[serde(default, skip_serializing_if = "Option::is_none")]
1770 pub chunk_size: Option<i64>,
1771 #[serde(default, skip_serializing_if = "Option::is_none")]
1772 pub next_stream_position: Option<EventsNextStreamPosition>,
1773 #[serde(default, skip_serializing_if = "Option::is_none")]
1774 pub entries: Option<Vec<Event>>,
1775}
1776
1777#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1778pub struct EventSource {
1779 pub item_type: EventSourceItemType,
1780 pub item_id: String,
1781 pub item_name: String,
1782 #[serde(default, skip_serializing_if = "Option::is_none")]
1783 pub classification: Option<EventSourceClassification>,
1784 #[serde(
1785 default,
1786 skip_serializing_if = "Option::is_none",
1787 deserialize_with = "double_option"
1788 )]
1789 pub parent: Option<Option<FolderMini>>,
1790 #[serde(default, skip_serializing_if = "Option::is_none")]
1791 pub owned_by: Option<UserMini>,
1792}
1793
1794#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1795#[serde(transparent)]
1796pub struct EventSourceResource(pub serde_json::Value);
1797
1798#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1799pub struct File {
1800 pub id: String,
1801 #[serde(
1802 default,
1803 skip_serializing_if = "Option::is_none",
1804 deserialize_with = "double_option"
1805 )]
1806 pub etag: Option<Option<String>>,
1807 pub r#type: AiCitationType,
1808 #[serde(default, skip_serializing_if = "Option::is_none")]
1809 pub sequence_id: Option<String>,
1810 #[serde(default, skip_serializing_if = "Option::is_none")]
1811 pub name: Option<String>,
1812 #[serde(default, skip_serializing_if = "Option::is_none")]
1813 pub sha1: Option<String>,
1814 #[serde(default, skip_serializing_if = "Option::is_none")]
1815 pub file_version: Option<FileVersionMini>,
1816 #[serde(default, skip_serializing_if = "Option::is_none")]
1817 pub description: Option<String>,
1818 #[serde(default, skip_serializing_if = "Option::is_none")]
1819 pub size: Option<i64>,
1820 #[serde(default, skip_serializing_if = "Option::is_none")]
1821 pub path_collection: Option<FilePathCollection>,
1822 #[serde(default, skip_serializing_if = "Option::is_none")]
1823 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1824 #[serde(default, skip_serializing_if = "Option::is_none")]
1825 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
1826 #[serde(
1827 default,
1828 skip_serializing_if = "Option::is_none",
1829 deserialize_with = "double_option"
1830 )]
1831 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1832 #[serde(
1833 default,
1834 skip_serializing_if = "Option::is_none",
1835 deserialize_with = "double_option"
1836 )]
1837 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1838 #[serde(
1839 default,
1840 skip_serializing_if = "Option::is_none",
1841 deserialize_with = "double_option"
1842 )]
1843 pub content_created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1844 #[serde(
1845 default,
1846 skip_serializing_if = "Option::is_none",
1847 deserialize_with = "double_option"
1848 )]
1849 pub content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1850 #[serde(default, skip_serializing_if = "Option::is_none")]
1851 pub created_by: Option<UserMini>,
1852 #[serde(default, skip_serializing_if = "Option::is_none")]
1853 pub modified_by: Option<UserMini>,
1854 #[serde(default, skip_serializing_if = "Option::is_none")]
1855 pub owned_by: Option<UserMini>,
1856 #[serde(
1857 default,
1858 skip_serializing_if = "Option::is_none",
1859 deserialize_with = "double_option"
1860 )]
1861 pub shared_link: Option<Option<FileSharedLink>>,
1862 #[serde(
1863 default,
1864 skip_serializing_if = "Option::is_none",
1865 deserialize_with = "double_option"
1866 )]
1867 pub parent: Option<Option<FolderMini>>,
1868 #[serde(default, skip_serializing_if = "Option::is_none")]
1869 pub item_status: Option<FileItemStatus>,
1870}
1871
1872#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1873pub struct FileBase {
1874 pub id: String,
1875 #[serde(
1876 default,
1877 skip_serializing_if = "Option::is_none",
1878 deserialize_with = "double_option"
1879 )]
1880 pub etag: Option<Option<String>>,
1881 pub r#type: AiCitationType,
1882}
1883
1884#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1885pub struct FileFull {
1886 pub id: String,
1887 #[serde(
1888 default,
1889 skip_serializing_if = "Option::is_none",
1890 deserialize_with = "double_option"
1891 )]
1892 pub etag: Option<Option<String>>,
1893 pub r#type: AiCitationType,
1894 #[serde(default, skip_serializing_if = "Option::is_none")]
1895 pub sequence_id: Option<String>,
1896 #[serde(default, skip_serializing_if = "Option::is_none")]
1897 pub name: Option<String>,
1898 #[serde(default, skip_serializing_if = "Option::is_none")]
1899 pub sha1: Option<String>,
1900 #[serde(default, skip_serializing_if = "Option::is_none")]
1901 pub file_version: Option<FileVersionMini>,
1902 #[serde(default, skip_serializing_if = "Option::is_none")]
1903 pub description: Option<String>,
1904 #[serde(default, skip_serializing_if = "Option::is_none")]
1905 pub size: Option<i64>,
1906 #[serde(default, skip_serializing_if = "Option::is_none")]
1907 pub path_collection: Option<FilePathCollection>,
1908 #[serde(default, skip_serializing_if = "Option::is_none")]
1909 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1910 #[serde(default, skip_serializing_if = "Option::is_none")]
1911 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
1912 #[serde(
1913 default,
1914 skip_serializing_if = "Option::is_none",
1915 deserialize_with = "double_option"
1916 )]
1917 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1918 #[serde(
1919 default,
1920 skip_serializing_if = "Option::is_none",
1921 deserialize_with = "double_option"
1922 )]
1923 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1924 #[serde(
1925 default,
1926 skip_serializing_if = "Option::is_none",
1927 deserialize_with = "double_option"
1928 )]
1929 pub content_created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1930 #[serde(
1931 default,
1932 skip_serializing_if = "Option::is_none",
1933 deserialize_with = "double_option"
1934 )]
1935 pub content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1936 #[serde(default, skip_serializing_if = "Option::is_none")]
1937 pub created_by: Option<UserMini>,
1938 #[serde(default, skip_serializing_if = "Option::is_none")]
1939 pub modified_by: Option<UserMini>,
1940 #[serde(default, skip_serializing_if = "Option::is_none")]
1941 pub owned_by: Option<UserMini>,
1942 #[serde(
1943 default,
1944 skip_serializing_if = "Option::is_none",
1945 deserialize_with = "double_option"
1946 )]
1947 pub shared_link: Option<Option<FileSharedLink>>,
1948 #[serde(
1949 default,
1950 skip_serializing_if = "Option::is_none",
1951 deserialize_with = "double_option"
1952 )]
1953 pub parent: Option<Option<FolderMini>>,
1954 #[serde(default, skip_serializing_if = "Option::is_none")]
1955 pub item_status: Option<FileItemStatus>,
1956 #[serde(default, skip_serializing_if = "Option::is_none")]
1957 pub version_number: Option<String>,
1958 #[serde(default, skip_serializing_if = "Option::is_none")]
1959 pub comment_count: Option<i64>,
1960 #[serde(default, skip_serializing_if = "Option::is_none")]
1961 pub permissions: Option<FileFullPermissions>,
1962 #[serde(default, skip_serializing_if = "Option::is_none")]
1963 pub tags: Option<Vec<String>>,
1964 #[serde(
1965 default,
1966 skip_serializing_if = "Option::is_none",
1967 deserialize_with = "double_option"
1968 )]
1969 pub lock: Option<Option<FileFullLock>>,
1970 #[serde(default, skip_serializing_if = "Option::is_none")]
1971 pub extension: Option<String>,
1972 #[serde(default, skip_serializing_if = "Option::is_none")]
1973 pub is_package: Option<bool>,
1974 #[serde(default, skip_serializing_if = "Option::is_none")]
1975 pub expiring_embed_link: Option<FileFullExpiringEmbedLink>,
1976 #[serde(default, skip_serializing_if = "Option::is_none")]
1977 pub watermark_info: Option<FileFullWatermarkInfo>,
1978 #[serde(default, skip_serializing_if = "Option::is_none")]
1979 pub is_accessible_via_shared_link: Option<bool>,
1980 #[serde(default, skip_serializing_if = "Option::is_none")]
1981 pub allowed_invitee_roles: Option<Vec<FileFullAllowedInviteeRoles>>,
1982 #[serde(default, skip_serializing_if = "Option::is_none")]
1983 pub is_externally_owned: Option<bool>,
1984 #[serde(default, skip_serializing_if = "Option::is_none")]
1985 pub has_collaborations: Option<bool>,
1986 #[serde(default, skip_serializing_if = "Option::is_none")]
1987 pub metadata:
1988 Option<std::collections::HashMap<String, std::collections::HashMap<String, MetadataFull>>>,
1989 #[serde(
1990 default,
1991 skip_serializing_if = "Option::is_none",
1992 deserialize_with = "double_option"
1993 )]
1994 pub expires_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1995 #[serde(default, skip_serializing_if = "Option::is_none")]
1996 pub representations: Option<FileFullRepresentations>,
1997 #[serde(
1998 default,
1999 skip_serializing_if = "Option::is_none",
2000 deserialize_with = "double_option"
2001 )]
2002 pub classification: Option<Option<FileFullClassification>>,
2003 #[serde(default, skip_serializing_if = "Option::is_none")]
2004 pub uploader_display_name: Option<String>,
2005 #[serde(
2006 default,
2007 skip_serializing_if = "Option::is_none",
2008 deserialize_with = "double_option"
2009 )]
2010 pub disposition_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2011 #[serde(
2012 default,
2013 skip_serializing_if = "Option::is_none",
2014 deserialize_with = "double_option"
2015 )]
2016 pub shared_link_permission_options: Option<Option<Vec<FileFullSharedLinkPermissionOptions>>>,
2017 #[serde(default, skip_serializing_if = "Option::is_none")]
2018 pub is_associated_with_app_item: Option<bool>,
2019}
2020
2021#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2022pub struct FileMini {
2023 pub id: String,
2024 #[serde(
2025 default,
2026 skip_serializing_if = "Option::is_none",
2027 deserialize_with = "double_option"
2028 )]
2029 pub etag: Option<Option<String>>,
2030 pub r#type: AiCitationType,
2031 #[serde(default, skip_serializing_if = "Option::is_none")]
2032 pub sequence_id: Option<String>,
2033 #[serde(default, skip_serializing_if = "Option::is_none")]
2034 pub name: Option<String>,
2035 #[serde(default, skip_serializing_if = "Option::is_none")]
2036 pub sha1: Option<String>,
2037 #[serde(default, skip_serializing_if = "Option::is_none")]
2038 pub file_version: Option<FileVersionMini>,
2039}
2040
2041#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2042pub struct FileConflict {
2043 pub id: String,
2044 #[serde(
2045 default,
2046 skip_serializing_if = "Option::is_none",
2047 deserialize_with = "double_option"
2048 )]
2049 pub etag: Option<Option<String>>,
2050 pub r#type: AiCitationType,
2051 #[serde(default, skip_serializing_if = "Option::is_none")]
2052 pub sequence_id: Option<String>,
2053 #[serde(default, skip_serializing_if = "Option::is_none")]
2054 pub name: Option<String>,
2055 #[serde(default, skip_serializing_if = "Option::is_none")]
2056 pub sha1: Option<String>,
2057 #[serde(default, skip_serializing_if = "Option::is_none")]
2058 pub file_version: Option<FileVersionMini>,
2059}
2060
2061#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2062pub struct FileRequest {
2063 pub id: String,
2064 pub r#type: FileRequestType,
2065 #[serde(default, skip_serializing_if = "Option::is_none")]
2066 pub title: Option<String>,
2067 #[serde(
2068 default,
2069 skip_serializing_if = "Option::is_none",
2070 deserialize_with = "double_option"
2071 )]
2072 pub description: Option<Option<String>>,
2073 #[serde(default, skip_serializing_if = "Option::is_none")]
2074 pub status: Option<FileRequestStatus>,
2075 #[serde(default, skip_serializing_if = "Option::is_none")]
2076 pub is_email_required: Option<bool>,
2077 #[serde(default, skip_serializing_if = "Option::is_none")]
2078 pub is_description_required: Option<bool>,
2079 #[serde(default, skip_serializing_if = "Option::is_none")]
2080 pub expires_at: Option<chrono::DateTime<chrono::Utc>>,
2081 pub folder: FolderMini,
2082 #[serde(default, skip_serializing_if = "Option::is_none")]
2083 pub url: Option<String>,
2084 #[serde(
2085 default,
2086 skip_serializing_if = "Option::is_none",
2087 deserialize_with = "double_option"
2088 )]
2089 pub etag: Option<Option<String>>,
2090 #[serde(default, skip_serializing_if = "Option::is_none")]
2091 pub created_by: Option<UserMini>,
2092 pub created_at: chrono::DateTime<chrono::Utc>,
2093 #[serde(default, skip_serializing_if = "Option::is_none")]
2094 pub updated_by: Option<UserMini>,
2095 pub updated_at: chrono::DateTime<chrono::Utc>,
2096}
2097
2098#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2099pub struct FileRequestCopyRequest {
2100 #[serde(default, skip_serializing_if = "Option::is_none")]
2101 pub title: Option<String>,
2102 #[serde(default, skip_serializing_if = "Option::is_none")]
2103 pub description: Option<String>,
2104 #[serde(default, skip_serializing_if = "Option::is_none")]
2105 pub status: Option<FileRequestStatus>,
2106 #[serde(default, skip_serializing_if = "Option::is_none")]
2107 pub is_email_required: Option<bool>,
2108 #[serde(default, skip_serializing_if = "Option::is_none")]
2109 pub is_description_required: Option<bool>,
2110 #[serde(default, skip_serializing_if = "Option::is_none")]
2111 pub expires_at: Option<chrono::DateTime<chrono::Utc>>,
2112 pub folder: FileRequestCopyRequestFolder,
2113}
2114
2115#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2116pub struct FileRequestUpdateRequest {
2117 #[serde(default, skip_serializing_if = "Option::is_none")]
2118 pub title: Option<String>,
2119 #[serde(default, skip_serializing_if = "Option::is_none")]
2120 pub description: Option<String>,
2121 #[serde(default, skip_serializing_if = "Option::is_none")]
2122 pub status: Option<FileRequestStatus>,
2123 #[serde(default, skip_serializing_if = "Option::is_none")]
2124 pub is_email_required: Option<bool>,
2125 #[serde(default, skip_serializing_if = "Option::is_none")]
2126 pub is_description_required: Option<bool>,
2127 #[serde(default, skip_serializing_if = "Option::is_none")]
2128 pub expires_at: Option<chrono::DateTime<chrono::Utc>>,
2129}
2130
2131#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2132pub struct Files {
2133 #[serde(default, skip_serializing_if = "Option::is_none")]
2134 pub total_count: Option<i64>,
2135 #[serde(default, skip_serializing_if = "Option::is_none")]
2136 pub entries: Option<Vec<FileFull>>,
2137}
2138
2139#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2140pub struct FilesOnHold {
2141 #[serde(default, skip_serializing_if = "Option::is_none")]
2142 pub limit: Option<i64>,
2143 #[serde(
2144 default,
2145 skip_serializing_if = "Option::is_none",
2146 deserialize_with = "double_option"
2147 )]
2148 pub next_marker: Option<Option<String>>,
2149 #[serde(
2150 default,
2151 skip_serializing_if = "Option::is_none",
2152 deserialize_with = "double_option"
2153 )]
2154 pub prev_marker: Option<Option<String>>,
2155 #[serde(default, skip_serializing_if = "Option::is_none")]
2156 pub entries: Option<Vec<FileMini>>,
2157}
2158
2159#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2160pub struct FilesUnderRetention {
2161 #[serde(default, skip_serializing_if = "Option::is_none")]
2162 pub limit: Option<i64>,
2163 #[serde(
2164 default,
2165 skip_serializing_if = "Option::is_none",
2166 deserialize_with = "double_option"
2167 )]
2168 pub next_marker: Option<Option<String>>,
2169 #[serde(
2170 default,
2171 skip_serializing_if = "Option::is_none",
2172 deserialize_with = "double_option"
2173 )]
2174 pub prev_marker: Option<Option<String>>,
2175 #[serde(default, skip_serializing_if = "Option::is_none")]
2176 pub entries: Option<Vec<FileMini>>,
2177}
2178
2179#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2180pub struct FileVersion {
2181 pub id: String,
2182 pub r#type: FileVersionType,
2183 #[serde(default, skip_serializing_if = "Option::is_none")]
2184 pub sha1: Option<String>,
2185 #[serde(default, skip_serializing_if = "Option::is_none")]
2186 pub name: Option<String>,
2187 #[serde(default, skip_serializing_if = "Option::is_none")]
2188 pub size: Option<i64>,
2189 #[serde(default, skip_serializing_if = "Option::is_none")]
2190 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2191 #[serde(default, skip_serializing_if = "Option::is_none")]
2192 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
2193 #[serde(default, skip_serializing_if = "Option::is_none")]
2194 pub modified_by: Option<UserMini>,
2195 #[serde(
2196 default,
2197 skip_serializing_if = "Option::is_none",
2198 deserialize_with = "double_option"
2199 )]
2200 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2201 #[serde(default, skip_serializing_if = "Option::is_none")]
2202 pub trashed_by: Option<UserMini>,
2203 #[serde(
2204 default,
2205 skip_serializing_if = "Option::is_none",
2206 deserialize_with = "double_option"
2207 )]
2208 pub restored_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2209 #[serde(default, skip_serializing_if = "Option::is_none")]
2210 pub restored_by: Option<UserMini>,
2211 #[serde(
2212 default,
2213 skip_serializing_if = "Option::is_none",
2214 deserialize_with = "double_option"
2215 )]
2216 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2217 #[serde(default, skip_serializing_if = "Option::is_none")]
2218 pub uploader_display_name: Option<String>,
2219}
2220
2221#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2222pub struct FileVersionBase {
2223 pub id: String,
2224 pub r#type: FileVersionType,
2225}
2226
2227#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2228pub struct FileVersionFull {
2229 pub id: String,
2230 pub r#type: FileVersionType,
2231 #[serde(default, skip_serializing_if = "Option::is_none")]
2232 pub sha1: Option<String>,
2233 #[serde(default, skip_serializing_if = "Option::is_none")]
2234 pub name: Option<String>,
2235 #[serde(default, skip_serializing_if = "Option::is_none")]
2236 pub size: Option<i64>,
2237 #[serde(default, skip_serializing_if = "Option::is_none")]
2238 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2239 #[serde(default, skip_serializing_if = "Option::is_none")]
2240 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
2241 #[serde(default, skip_serializing_if = "Option::is_none")]
2242 pub modified_by: Option<UserMini>,
2243 #[serde(
2244 default,
2245 skip_serializing_if = "Option::is_none",
2246 deserialize_with = "double_option"
2247 )]
2248 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2249 #[serde(default, skip_serializing_if = "Option::is_none")]
2250 pub trashed_by: Option<UserMini>,
2251 #[serde(
2252 default,
2253 skip_serializing_if = "Option::is_none",
2254 deserialize_with = "double_option"
2255 )]
2256 pub restored_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2257 #[serde(default, skip_serializing_if = "Option::is_none")]
2258 pub restored_by: Option<UserMini>,
2259 #[serde(
2260 default,
2261 skip_serializing_if = "Option::is_none",
2262 deserialize_with = "double_option"
2263 )]
2264 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2265 #[serde(default, skip_serializing_if = "Option::is_none")]
2266 pub uploader_display_name: Option<String>,
2267 #[serde(default, skip_serializing_if = "Option::is_none")]
2268 pub version_number: Option<String>,
2269}
2270
2271#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2272pub struct FileVersionMini {
2273 pub id: String,
2274 pub r#type: FileVersionType,
2275 #[serde(default, skip_serializing_if = "Option::is_none")]
2276 pub sha1: Option<String>,
2277}
2278
2279#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2280pub struct FileVersionLegalHold {
2281 #[serde(default, skip_serializing_if = "Option::is_none")]
2282 pub id: Option<String>,
2283 #[serde(default, skip_serializing_if = "Option::is_none")]
2284 pub r#type: Option<FileVersionLegalHoldType>,
2285 #[serde(default, skip_serializing_if = "Option::is_none")]
2286 pub file_version: Option<FileVersionMini>,
2287 #[serde(default, skip_serializing_if = "Option::is_none")]
2288 pub file: Option<FileMini>,
2289 #[serde(default, skip_serializing_if = "Option::is_none")]
2290 pub legal_hold_policy_assignments: Option<Vec<LegalHoldPolicyAssignment>>,
2291 #[serde(default, skip_serializing_if = "Option::is_none")]
2292 pub deleted_at: Option<chrono::DateTime<chrono::Utc>>,
2293}
2294
2295#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2296pub struct FileVersionLegalHolds {
2297 #[serde(default, skip_serializing_if = "Option::is_none")]
2298 pub limit: Option<i64>,
2299 #[serde(
2300 default,
2301 skip_serializing_if = "Option::is_none",
2302 deserialize_with = "double_option"
2303 )]
2304 pub next_marker: Option<Option<String>>,
2305 #[serde(
2306 default,
2307 skip_serializing_if = "Option::is_none",
2308 deserialize_with = "double_option"
2309 )]
2310 pub prev_marker: Option<Option<String>>,
2311 #[serde(default, skip_serializing_if = "Option::is_none")]
2312 pub entries: Option<Vec<FileVersionLegalHold>>,
2313}
2314
2315#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2316pub struct FileVersionRetention {
2317 #[serde(default, skip_serializing_if = "Option::is_none")]
2318 pub id: Option<String>,
2319 #[serde(default, skip_serializing_if = "Option::is_none")]
2320 pub r#type: Option<FileVersionRetentionType>,
2321 #[serde(default, skip_serializing_if = "Option::is_none")]
2322 pub file_version: Option<FileVersionMini>,
2323 #[serde(default, skip_serializing_if = "Option::is_none")]
2324 pub file: Option<FileMini>,
2325 #[serde(default, skip_serializing_if = "Option::is_none")]
2326 pub applied_at: Option<chrono::DateTime<chrono::Utc>>,
2327 #[serde(default, skip_serializing_if = "Option::is_none")]
2328 pub disposition_at: Option<chrono::DateTime<chrono::Utc>>,
2329 #[serde(default, skip_serializing_if = "Option::is_none")]
2330 pub winning_retention_policy: Option<RetentionPolicyMini>,
2331}
2332
2333#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2334pub struct FileVersionRetentions {
2335 #[serde(default, skip_serializing_if = "Option::is_none")]
2336 pub limit: Option<i64>,
2337 #[serde(
2338 default,
2339 skip_serializing_if = "Option::is_none",
2340 deserialize_with = "double_option"
2341 )]
2342 pub next_marker: Option<Option<String>>,
2343 #[serde(
2344 default,
2345 skip_serializing_if = "Option::is_none",
2346 deserialize_with = "double_option"
2347 )]
2348 pub prev_marker: Option<Option<String>>,
2349 #[serde(default, skip_serializing_if = "Option::is_none")]
2350 pub entries: Option<Vec<FileVersionRetention>>,
2351}
2352
2353#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2354pub struct FileVersions {
2355 #[serde(default, skip_serializing_if = "Option::is_none")]
2356 pub total_count: Option<i64>,
2357 #[serde(default, skip_serializing_if = "Option::is_none")]
2358 pub limit: Option<i64>,
2359 #[serde(default, skip_serializing_if = "Option::is_none")]
2360 pub offset: Option<i64>,
2361 #[serde(default, skip_serializing_if = "Option::is_none")]
2362 pub order: Option<Vec<CollectionsOrder>>,
2363 #[serde(default, skip_serializing_if = "Option::is_none")]
2364 pub entries: Option<Vec<FileVersionFull>>,
2365}
2366
2367#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2368pub struct FileVersionsOnHold {
2369 #[serde(default, skip_serializing_if = "Option::is_none")]
2370 pub limit: Option<i64>,
2371 #[serde(
2372 default,
2373 skip_serializing_if = "Option::is_none",
2374 deserialize_with = "double_option"
2375 )]
2376 pub next_marker: Option<Option<String>>,
2377 #[serde(
2378 default,
2379 skip_serializing_if = "Option::is_none",
2380 deserialize_with = "double_option"
2381 )]
2382 pub prev_marker: Option<Option<String>>,
2383 #[serde(default, skip_serializing_if = "Option::is_none")]
2384 pub entries: Option<Vec<FileVersion>>,
2385}
2386
2387#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2388pub struct Folder {
2389 pub id: String,
2390 #[serde(
2391 default,
2392 skip_serializing_if = "Option::is_none",
2393 deserialize_with = "double_option"
2394 )]
2395 pub etag: Option<Option<String>>,
2396 pub r#type: FolderType,
2397 #[serde(default, skip_serializing_if = "Option::is_none")]
2398 pub sequence_id: Option<String>,
2399 #[serde(default, skip_serializing_if = "Option::is_none")]
2400 pub name: Option<String>,
2401 #[serde(
2402 default,
2403 skip_serializing_if = "Option::is_none",
2404 deserialize_with = "double_option"
2405 )]
2406 pub created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2407 #[serde(
2408 default,
2409 skip_serializing_if = "Option::is_none",
2410 deserialize_with = "double_option"
2411 )]
2412 pub modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2413 #[serde(default, skip_serializing_if = "Option::is_none")]
2414 pub description: Option<String>,
2415 #[serde(default, skip_serializing_if = "Option::is_none")]
2416 pub size: Option<i64>,
2417 #[serde(default, skip_serializing_if = "Option::is_none")]
2418 pub path_collection: Option<FilePathCollection>,
2419 #[serde(default, skip_serializing_if = "Option::is_none")]
2420 pub created_by: Option<UserMini>,
2421 #[serde(default, skip_serializing_if = "Option::is_none")]
2422 pub modified_by: Option<UserMini>,
2423 #[serde(
2424 default,
2425 skip_serializing_if = "Option::is_none",
2426 deserialize_with = "double_option"
2427 )]
2428 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2429 #[serde(
2430 default,
2431 skip_serializing_if = "Option::is_none",
2432 deserialize_with = "double_option"
2433 )]
2434 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2435 #[serde(
2436 default,
2437 skip_serializing_if = "Option::is_none",
2438 deserialize_with = "double_option"
2439 )]
2440 pub content_created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2441 #[serde(
2442 default,
2443 skip_serializing_if = "Option::is_none",
2444 deserialize_with = "double_option"
2445 )]
2446 pub content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2447 #[serde(default, skip_serializing_if = "Option::is_none")]
2448 pub owned_by: Option<UserMini>,
2449 #[serde(
2450 default,
2451 skip_serializing_if = "Option::is_none",
2452 deserialize_with = "double_option"
2453 )]
2454 pub shared_link: Option<Option<FileSharedLink>>,
2455 #[serde(
2456 default,
2457 skip_serializing_if = "Option::is_none",
2458 deserialize_with = "double_option"
2459 )]
2460 pub folder_upload_email: Option<Option<FolderFolderUploadEmail>>,
2461 #[serde(
2462 default,
2463 skip_serializing_if = "Option::is_none",
2464 deserialize_with = "double_option"
2465 )]
2466 pub parent: Option<Option<FolderMini>>,
2467 #[serde(default, skip_serializing_if = "Option::is_none")]
2468 pub item_status: Option<FileItemStatus>,
2469 #[serde(default, skip_serializing_if = "Option::is_none")]
2470 pub item_collection: Option<Items>,
2471}
2472
2473#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2474pub struct FolderBase {
2475 pub id: String,
2476 #[serde(
2477 default,
2478 skip_serializing_if = "Option::is_none",
2479 deserialize_with = "double_option"
2480 )]
2481 pub etag: Option<Option<String>>,
2482 pub r#type: FolderType,
2483}
2484
2485#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2486pub struct FolderFull {
2487 pub id: String,
2488 #[serde(
2489 default,
2490 skip_serializing_if = "Option::is_none",
2491 deserialize_with = "double_option"
2492 )]
2493 pub etag: Option<Option<String>>,
2494 pub r#type: FolderType,
2495 #[serde(default, skip_serializing_if = "Option::is_none")]
2496 pub sequence_id: Option<String>,
2497 #[serde(default, skip_serializing_if = "Option::is_none")]
2498 pub name: Option<String>,
2499 #[serde(
2500 default,
2501 skip_serializing_if = "Option::is_none",
2502 deserialize_with = "double_option"
2503 )]
2504 pub created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2505 #[serde(
2506 default,
2507 skip_serializing_if = "Option::is_none",
2508 deserialize_with = "double_option"
2509 )]
2510 pub modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2511 #[serde(default, skip_serializing_if = "Option::is_none")]
2512 pub description: Option<String>,
2513 #[serde(default, skip_serializing_if = "Option::is_none")]
2514 pub size: Option<i64>,
2515 #[serde(default, skip_serializing_if = "Option::is_none")]
2516 pub path_collection: Option<FilePathCollection>,
2517 #[serde(default, skip_serializing_if = "Option::is_none")]
2518 pub created_by: Option<UserMini>,
2519 #[serde(default, skip_serializing_if = "Option::is_none")]
2520 pub modified_by: Option<UserMini>,
2521 #[serde(
2522 default,
2523 skip_serializing_if = "Option::is_none",
2524 deserialize_with = "double_option"
2525 )]
2526 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2527 #[serde(
2528 default,
2529 skip_serializing_if = "Option::is_none",
2530 deserialize_with = "double_option"
2531 )]
2532 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2533 #[serde(
2534 default,
2535 skip_serializing_if = "Option::is_none",
2536 deserialize_with = "double_option"
2537 )]
2538 pub content_created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2539 #[serde(
2540 default,
2541 skip_serializing_if = "Option::is_none",
2542 deserialize_with = "double_option"
2543 )]
2544 pub content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2545 #[serde(default, skip_serializing_if = "Option::is_none")]
2546 pub owned_by: Option<UserMini>,
2547 #[serde(
2548 default,
2549 skip_serializing_if = "Option::is_none",
2550 deserialize_with = "double_option"
2551 )]
2552 pub shared_link: Option<Option<FileSharedLink>>,
2553 #[serde(
2554 default,
2555 skip_serializing_if = "Option::is_none",
2556 deserialize_with = "double_option"
2557 )]
2558 pub folder_upload_email: Option<Option<FolderFolderUploadEmail>>,
2559 #[serde(
2560 default,
2561 skip_serializing_if = "Option::is_none",
2562 deserialize_with = "double_option"
2563 )]
2564 pub parent: Option<Option<FolderMini>>,
2565 #[serde(default, skip_serializing_if = "Option::is_none")]
2566 pub item_status: Option<FileItemStatus>,
2567 #[serde(default, skip_serializing_if = "Option::is_none")]
2568 pub item_collection: Option<Items>,
2569 #[serde(default, skip_serializing_if = "Option::is_none")]
2570 pub sync_state: Option<FolderFullSyncState>,
2571 #[serde(default, skip_serializing_if = "Option::is_none")]
2572 pub has_collaborations: Option<bool>,
2573 #[serde(default, skip_serializing_if = "Option::is_none")]
2574 pub permissions: Option<FolderFullPermissions>,
2575 #[serde(default, skip_serializing_if = "Option::is_none")]
2576 pub tags: Option<Vec<String>>,
2577 #[serde(default, skip_serializing_if = "Option::is_none")]
2578 pub can_non_owners_invite: Option<bool>,
2579 #[serde(default, skip_serializing_if = "Option::is_none")]
2580 pub is_externally_owned: Option<bool>,
2581 #[serde(default, skip_serializing_if = "Option::is_none")]
2582 pub metadata:
2583 Option<std::collections::HashMap<String, std::collections::HashMap<String, MetadataFull>>>,
2584 #[serde(default, skip_serializing_if = "Option::is_none")]
2585 pub is_collaboration_restricted_to_enterprise: Option<bool>,
2586 #[serde(default, skip_serializing_if = "Option::is_none")]
2587 pub allowed_shared_link_access_levels: Option<Vec<SharedLinkAccess>>,
2588 #[serde(default, skip_serializing_if = "Option::is_none")]
2589 pub allowed_invitee_roles: Option<Vec<FileFullAllowedInviteeRoles>>,
2590 #[serde(default, skip_serializing_if = "Option::is_none")]
2591 pub watermark_info: Option<FileFullWatermarkInfo>,
2592 #[serde(default, skip_serializing_if = "Option::is_none")]
2593 pub is_accessible_via_shared_link: Option<bool>,
2594 #[serde(default, skip_serializing_if = "Option::is_none")]
2595 pub can_non_owners_view_collaborators: Option<bool>,
2596 #[serde(
2597 default,
2598 skip_serializing_if = "Option::is_none",
2599 deserialize_with = "double_option"
2600 )]
2601 pub classification: Option<Option<FileFullClassification>>,
2602 #[serde(default, skip_serializing_if = "Option::is_none")]
2603 pub is_associated_with_app_item: Option<bool>,
2604}
2605
2606#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2607pub struct FolderMini {
2608 pub id: String,
2609 #[serde(
2610 default,
2611 skip_serializing_if = "Option::is_none",
2612 deserialize_with = "double_option"
2613 )]
2614 pub etag: Option<Option<String>>,
2615 pub r#type: FolderType,
2616 #[serde(default, skip_serializing_if = "Option::is_none")]
2617 pub sequence_id: Option<String>,
2618 #[serde(default, skip_serializing_if = "Option::is_none")]
2619 pub name: Option<String>,
2620}
2621
2622#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2623pub struct FolderLock {
2624 #[serde(default, skip_serializing_if = "Option::is_none")]
2625 pub folder: Option<FolderMini>,
2626 #[serde(default, skip_serializing_if = "Option::is_none")]
2627 pub id: Option<String>,
2628 #[serde(default, skip_serializing_if = "Option::is_none")]
2629 pub r#type: Option<String>,
2630 #[serde(default, skip_serializing_if = "Option::is_none")]
2631 pub created_by: Option<UserBase>,
2632 #[serde(default, skip_serializing_if = "Option::is_none")]
2633 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2634 #[serde(default, skip_serializing_if = "Option::is_none")]
2635 pub locked_operations: Option<FolderLockLockedOperations>,
2636 #[serde(default, skip_serializing_if = "Option::is_none")]
2637 pub lock_type: Option<String>,
2638}
2639
2640#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2641pub struct FolderLocks {
2642 #[serde(default, skip_serializing_if = "Option::is_none")]
2643 pub entries: Option<Vec<FolderLock>>,
2644 #[serde(default, skip_serializing_if = "Option::is_none")]
2645 pub limit: Option<String>,
2646 #[serde(
2647 default,
2648 skip_serializing_if = "Option::is_none",
2649 deserialize_with = "double_option"
2650 )]
2651 pub next_marker: Option<Option<String>>,
2652}
2653
2654#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2655pub struct FolderReference {
2656 pub r#type: FolderType,
2657 pub id: String,
2658}
2659
2660#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2661pub struct GenericSource {}
2662
2663#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2664pub struct Group {
2665 pub id: String,
2666 pub r#type: GroupType,
2667 #[serde(default, skip_serializing_if = "Option::is_none")]
2668 pub name: Option<String>,
2669 #[serde(default, skip_serializing_if = "Option::is_none")]
2670 pub group_type: Option<GroupGroupType>,
2671 #[serde(default, skip_serializing_if = "Option::is_none")]
2672 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2673 #[serde(default, skip_serializing_if = "Option::is_none")]
2674 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
2675}
2676
2677#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2678pub struct GroupBase {
2679 pub id: String,
2680 pub r#type: GroupType,
2681}
2682
2683#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2684pub struct GroupFull {
2685 pub id: String,
2686 pub r#type: GroupType,
2687 #[serde(default, skip_serializing_if = "Option::is_none")]
2688 pub name: Option<String>,
2689 #[serde(default, skip_serializing_if = "Option::is_none")]
2690 pub group_type: Option<GroupGroupType>,
2691 #[serde(default, skip_serializing_if = "Option::is_none")]
2692 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2693 #[serde(default, skip_serializing_if = "Option::is_none")]
2694 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
2695 #[serde(default, skip_serializing_if = "Option::is_none")]
2696 pub provenance: Option<String>,
2697 #[serde(default, skip_serializing_if = "Option::is_none")]
2698 pub external_sync_identifier: Option<String>,
2699 #[serde(default, skip_serializing_if = "Option::is_none")]
2700 pub description: Option<String>,
2701 #[serde(default, skip_serializing_if = "Option::is_none")]
2702 pub invitability_level: Option<GroupFullInvitabilityLevel>,
2703 #[serde(default, skip_serializing_if = "Option::is_none")]
2704 pub member_viewability_level: Option<GroupFullInvitabilityLevel>,
2705 #[serde(default, skip_serializing_if = "Option::is_none")]
2706 pub permissions: Option<GroupFullPermissions>,
2707}
2708
2709#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2710pub struct GroupMini {
2711 pub id: String,
2712 pub r#type: GroupType,
2713 #[serde(default, skip_serializing_if = "Option::is_none")]
2714 pub name: Option<String>,
2715 #[serde(default, skip_serializing_if = "Option::is_none")]
2716 pub group_type: Option<GroupGroupType>,
2717}
2718
2719#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2720pub struct GroupMembership {
2721 #[serde(default, skip_serializing_if = "Option::is_none")]
2722 pub id: Option<String>,
2723 #[serde(default, skip_serializing_if = "Option::is_none")]
2724 pub r#type: Option<GroupMembershipType>,
2725 #[serde(default, skip_serializing_if = "Option::is_none")]
2726 pub user: Option<UserMini>,
2727 #[serde(default, skip_serializing_if = "Option::is_none")]
2728 pub group: Option<GroupMini>,
2729 #[serde(default, skip_serializing_if = "Option::is_none")]
2730 pub role: Option<GroupMembershipRole>,
2731 #[serde(default, skip_serializing_if = "Option::is_none")]
2732 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2733 #[serde(default, skip_serializing_if = "Option::is_none")]
2734 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
2735}
2736
2737#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2738pub struct GroupMemberships {
2739 #[serde(default, skip_serializing_if = "Option::is_none")]
2740 pub total_count: Option<i64>,
2741 #[serde(default, skip_serializing_if = "Option::is_none")]
2742 pub limit: Option<i64>,
2743 #[serde(default, skip_serializing_if = "Option::is_none")]
2744 pub offset: Option<i64>,
2745 #[serde(default, skip_serializing_if = "Option::is_none")]
2746 pub order: Option<Vec<CollectionsOrder>>,
2747 #[serde(default, skip_serializing_if = "Option::is_none")]
2748 pub entries: Option<Vec<GroupMembership>>,
2749}
2750
2751#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2752pub struct Groups {
2753 #[serde(default, skip_serializing_if = "Option::is_none")]
2754 pub total_count: Option<i64>,
2755 #[serde(default, skip_serializing_if = "Option::is_none")]
2756 pub limit: Option<i64>,
2757 #[serde(default, skip_serializing_if = "Option::is_none")]
2758 pub offset: Option<i64>,
2759 #[serde(default, skip_serializing_if = "Option::is_none")]
2760 pub order: Option<Vec<CollectionsOrder>>,
2761 #[serde(default, skip_serializing_if = "Option::is_none")]
2762 pub entries: Option<Vec<GroupFull>>,
2763}
2764
2765#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2766pub struct IntegrationMapping {
2767 pub id: String,
2768 pub r#type: IntegrationMappingType,
2769 #[serde(default, skip_serializing_if = "Option::is_none")]
2770 pub integration_type: Option<IntegrationMappingIntegrationType>,
2771 #[serde(default, skip_serializing_if = "Option::is_none")]
2772 pub is_manually_created: Option<bool>,
2773 #[serde(default, skip_serializing_if = "Option::is_none")]
2774 pub options: Option<IntegrationMappingSlackOptions>,
2775 #[serde(default, skip_serializing_if = "Option::is_none")]
2776 pub created_by: Option<UserIntegrationMappings>,
2777 #[serde(default, skip_serializing_if = "Option::is_none")]
2778 pub modified_by: Option<UserIntegrationMappings>,
2779 pub partner_item: IntegrationMappingPartnerItemSlack,
2780 pub box_item: FolderMini,
2781 #[serde(default, skip_serializing_if = "Option::is_none")]
2782 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2783 #[serde(default, skip_serializing_if = "Option::is_none")]
2784 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
2785}
2786
2787#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2788pub struct IntegrationMappingBase {
2789 pub id: String,
2790 pub r#type: IntegrationMappingType,
2791}
2792
2793#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2794pub struct IntegrationMappingBoxItemSlack {
2795 pub r#type: FolderType,
2796 pub id: String,
2797}
2798
2799#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2800pub struct IntegrationMappingPartnerItemSlack {
2801 pub r#type: IntegrationMappingPartnerItemSlackType,
2802 pub id: String,
2803 #[serde(
2804 default,
2805 skip_serializing_if = "Option::is_none",
2806 deserialize_with = "double_option"
2807 )]
2808 pub slack_workspace_id: Option<Option<String>>,
2809 #[serde(
2810 default,
2811 skip_serializing_if = "Option::is_none",
2812 deserialize_with = "double_option"
2813 )]
2814 pub slack_org_id: Option<Option<String>>,
2815}
2816
2817#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2818pub struct IntegrationMappingPartnerItemTeams {
2819 pub r#type: IntegrationMappingPartnerItemTeamsType,
2820 pub id: String,
2821 pub tenant_id: String,
2822}
2823
2824#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2825pub struct IntegrationMappingPartnerItemTeamsCreateRequest {
2826 pub r#type: IntegrationMappingPartnerItemTeamsType,
2827 pub id: String,
2828 pub tenant_id: String,
2829 pub team_id: String,
2830}
2831
2832#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2833pub struct IntegrationMappings {
2834 #[serde(default, skip_serializing_if = "Option::is_none")]
2835 pub limit: Option<i64>,
2836 #[serde(
2837 default,
2838 skip_serializing_if = "Option::is_none",
2839 deserialize_with = "double_option"
2840 )]
2841 pub next_marker: Option<Option<String>>,
2842 #[serde(default, skip_serializing_if = "Option::is_none")]
2843 pub entries: Option<Vec<IntegrationMapping>>,
2844}
2845
2846#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2847pub struct IntegrationMappingSlackCreateRequest {
2848 pub partner_item: IntegrationMappingPartnerItemSlack,
2849 pub box_item: IntegrationMappingBoxItemSlack,
2850 #[serde(default, skip_serializing_if = "Option::is_none")]
2851 pub options: Option<IntegrationMappingSlackOptions>,
2852}
2853
2854#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2855pub struct IntegrationMappingSlackOptions {
2856 #[serde(default, skip_serializing_if = "Option::is_none")]
2857 pub is_access_management_disabled: Option<bool>,
2858}
2859
2860#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2861pub struct IntegrationMappingsTeams {
2862 #[serde(default, skip_serializing_if = "Option::is_none")]
2863 pub entries: Option<Vec<IntegrationMappingTeams>>,
2864}
2865
2866#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2867pub struct IntegrationMappingTeams {
2868 pub id: String,
2869 pub r#type: IntegrationMappingType,
2870 #[serde(default, skip_serializing_if = "Option::is_none")]
2871 pub integration_type: Option<IntegrationMappingTeamsIntegrationType>,
2872 #[serde(default, skip_serializing_if = "Option::is_none")]
2873 pub is_overridden_by_manual_mapping: Option<bool>,
2874 pub partner_item: IntegrationMappingPartnerItemTeams,
2875 pub box_item: FolderReference,
2876 #[serde(default, skip_serializing_if = "Option::is_none")]
2877 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2878 #[serde(default, skip_serializing_if = "Option::is_none")]
2879 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
2880}
2881
2882#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2883pub struct IntegrationMappingTeamsCreateRequest {
2884 pub partner_item: IntegrationMappingPartnerItemTeamsCreateRequest,
2885 pub box_item: FolderReference,
2886}
2887
2888#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2889pub struct Invite {
2890 pub id: String,
2891 pub r#type: InviteType,
2892 #[serde(default, skip_serializing_if = "Option::is_none")]
2893 pub invited_to: Option<CollaborationAllowlistEntryEnterprise>,
2894 #[serde(default, skip_serializing_if = "Option::is_none")]
2895 pub actionable_by: Option<UserMini>,
2896 #[serde(default, skip_serializing_if = "Option::is_none")]
2897 pub invited_by: Option<UserMini>,
2898 #[serde(default, skip_serializing_if = "Option::is_none")]
2899 pub status: Option<String>,
2900 #[serde(default, skip_serializing_if = "Option::is_none")]
2901 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2902 #[serde(default, skip_serializing_if = "Option::is_none")]
2903 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
2904}
2905
2906#[derive(Clone, Debug, PartialEq)]
2907pub enum Item {
2908 File(FileFull),
2909 Folder(FolderMini),
2910 WebLink(WebLink),
2911 Unknown(serde_json::Value),
2913}
2914
2915impl Default for Item {
2916 fn default() -> Self {
2917 Self::Unknown(Default::default())
2918 }
2919}
2920
2921impl serde::Serialize for Item {
2922 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
2923 match self {
2924 Self::File(inner) => inner.serialize(serializer),
2925 Self::Folder(inner) => inner.serialize(serializer),
2926 Self::WebLink(inner) => inner.serialize(serializer),
2927 Self::Unknown(inner) => inner.serialize(serializer),
2928 }
2929 }
2930}
2931
2932impl<'de> serde::Deserialize<'de> for Item {
2933 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2934 let value = serde_json::Value::deserialize(deserializer)?;
2935 let tag = value
2936 .get("type")
2937 .and_then(serde_json::Value::as_str)
2938 .map(str::to_owned);
2939 match tag.as_deref() {
2940 Some("file") => Ok(Self::File(
2941 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
2942 )),
2943 Some("folder") => Ok(Self::Folder(
2944 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
2945 )),
2946 Some("web_link") => Ok(Self::WebLink(
2947 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
2948 )),
2949 _ => Ok(Self::Unknown(value)),
2950 }
2951 }
2952}
2953
2954#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2955pub struct Items {
2956 #[serde(default, skip_serializing_if = "Option::is_none")]
2957 pub limit: Option<i64>,
2958 #[serde(
2959 default,
2960 skip_serializing_if = "Option::is_none",
2961 deserialize_with = "double_option"
2962 )]
2963 pub next_marker: Option<Option<String>>,
2964 #[serde(
2965 default,
2966 skip_serializing_if = "Option::is_none",
2967 deserialize_with = "double_option"
2968 )]
2969 pub prev_marker: Option<Option<String>>,
2970 #[serde(default, skip_serializing_if = "Option::is_none")]
2971 pub total_count: Option<i64>,
2972 #[serde(default, skip_serializing_if = "Option::is_none")]
2973 pub offset: Option<i64>,
2974 #[serde(default, skip_serializing_if = "Option::is_none")]
2975 pub order: Option<Vec<CollectionsOrder>>,
2976 #[serde(default, skip_serializing_if = "Option::is_none")]
2977 pub entries: Option<Vec<Item>>,
2978}
2979
2980#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2981pub struct ItemsOffsetPaginated {
2982 #[serde(default, skip_serializing_if = "Option::is_none")]
2983 pub total_count: Option<i64>,
2984 #[serde(default, skip_serializing_if = "Option::is_none")]
2985 pub limit: Option<i64>,
2986 #[serde(default, skip_serializing_if = "Option::is_none")]
2987 pub offset: Option<i64>,
2988 #[serde(default, skip_serializing_if = "Option::is_none")]
2989 pub order: Option<Vec<CollectionsOrder>>,
2990 #[serde(default, skip_serializing_if = "Option::is_none")]
2991 pub entries: Option<Vec<Item>>,
2992}
2993
2994#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2995pub struct KeywordSkillCard {
2996 #[serde(default, skip_serializing_if = "Option::is_none")]
2997 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2998 pub r#type: KeywordSkillCardType,
2999 pub skill_card_type: KeywordSkillCardSkillCardType,
3000 #[serde(default, skip_serializing_if = "Option::is_none")]
3001 pub skill_card_title: Option<KeywordSkillCardSkillCardTitle>,
3002 pub skill: KeywordSkillCardSkill,
3003 pub invocation: KeywordSkillCardInvocation,
3004 pub entries: Vec<KeywordSkillCardEntries>,
3005}
3006
3007#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3008pub struct LegalHoldPolicies {
3009 #[serde(default, skip_serializing_if = "Option::is_none")]
3010 pub limit: Option<i64>,
3011 #[serde(
3012 default,
3013 skip_serializing_if = "Option::is_none",
3014 deserialize_with = "double_option"
3015 )]
3016 pub next_marker: Option<Option<String>>,
3017 #[serde(
3018 default,
3019 skip_serializing_if = "Option::is_none",
3020 deserialize_with = "double_option"
3021 )]
3022 pub prev_marker: Option<Option<String>>,
3023 #[serde(default, skip_serializing_if = "Option::is_none")]
3024 pub entries: Option<Vec<LegalHoldPolicy>>,
3025}
3026
3027#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3028pub struct LegalHoldPolicy {
3029 pub id: String,
3030 pub r#type: LegalHoldPolicyType,
3031 #[serde(default, skip_serializing_if = "Option::is_none")]
3032 pub policy_name: Option<String>,
3033 #[serde(default, skip_serializing_if = "Option::is_none")]
3034 pub description: Option<String>,
3035 #[serde(default, skip_serializing_if = "Option::is_none")]
3036 pub status: Option<LegalHoldPolicyStatus>,
3037 #[serde(default, skip_serializing_if = "Option::is_none")]
3038 pub assignment_counts: Option<LegalHoldPolicyAssignmentCounts>,
3039 #[serde(default, skip_serializing_if = "Option::is_none")]
3040 pub created_by: Option<UserMini>,
3041 #[serde(default, skip_serializing_if = "Option::is_none")]
3042 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
3043 #[serde(default, skip_serializing_if = "Option::is_none")]
3044 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
3045 #[serde(default, skip_serializing_if = "Option::is_none")]
3046 pub deleted_at: Option<chrono::DateTime<chrono::Utc>>,
3047 #[serde(default, skip_serializing_if = "Option::is_none")]
3048 pub filter_started_at: Option<chrono::DateTime<chrono::Utc>>,
3049 #[serde(default, skip_serializing_if = "Option::is_none")]
3050 pub filter_ended_at: Option<chrono::DateTime<chrono::Utc>>,
3051 #[serde(default, skip_serializing_if = "Option::is_none")]
3052 pub release_notes: Option<String>,
3053}
3054
3055#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3056pub struct LegalHoldPolicyMini {
3057 pub id: String,
3058 pub r#type: LegalHoldPolicyType,
3059}
3060
3061#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3062pub struct LegalHoldPolicyAssignedItem {
3063 pub r#type: LegalHoldPolicyAssignedItemType,
3064 pub id: String,
3065}
3066
3067#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3068pub struct LegalHoldPolicyAssignment {
3069 #[serde(default, skip_serializing_if = "Option::is_none")]
3070 pub id: Option<String>,
3071 #[serde(default, skip_serializing_if = "Option::is_none")]
3072 pub r#type: Option<LegalHoldPolicyAssignmentType>,
3073 #[serde(default, skip_serializing_if = "Option::is_none")]
3074 pub legal_hold_policy: Option<LegalHoldPolicyMini>,
3075 #[serde(default, skip_serializing_if = "Option::is_none")]
3076 pub assigned_to: Option<LegalHoldPolicyAssignedItem>,
3077 #[serde(default, skip_serializing_if = "Option::is_none")]
3078 pub assigned_by: Option<UserMini>,
3079 #[serde(default, skip_serializing_if = "Option::is_none")]
3080 pub assigned_at: Option<chrono::DateTime<chrono::Utc>>,
3081 #[serde(default, skip_serializing_if = "Option::is_none")]
3082 pub deleted_at: Option<chrono::DateTime<chrono::Utc>>,
3083}
3084
3085#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3086pub struct LegalHoldPolicyAssignmentBase {
3087 #[serde(default, skip_serializing_if = "Option::is_none")]
3088 pub id: Option<String>,
3089 #[serde(default, skip_serializing_if = "Option::is_none")]
3090 pub r#type: Option<LegalHoldPolicyAssignmentType>,
3091}
3092
3093#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3094pub struct LegalHoldPolicyAssignments {
3095 #[serde(default, skip_serializing_if = "Option::is_none")]
3096 pub limit: Option<i64>,
3097 #[serde(
3098 default,
3099 skip_serializing_if = "Option::is_none",
3100 deserialize_with = "double_option"
3101 )]
3102 pub next_marker: Option<Option<String>>,
3103 #[serde(
3104 default,
3105 skip_serializing_if = "Option::is_none",
3106 deserialize_with = "double_option"
3107 )]
3108 pub prev_marker: Option<Option<String>>,
3109 #[serde(default, skip_serializing_if = "Option::is_none")]
3110 pub entries: Option<Vec<LegalHoldPolicyAssignment>>,
3111}
3112
3113pub type Metadata = MetadataBase;
3114
3115#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3116pub struct MetadataBase {
3117 #[serde(rename = "$parent", default, skip_serializing_if = "Option::is_none")]
3118 pub parent: Option<String>,
3119 #[serde(rename = "$template", default, skip_serializing_if = "Option::is_none")]
3120 pub template: Option<String>,
3121 #[serde(rename = "$scope", default, skip_serializing_if = "Option::is_none")]
3122 pub scope: Option<String>,
3123 #[serde(rename = "$version", default, skip_serializing_if = "Option::is_none")]
3124 pub version: Option<i64>,
3125}
3126
3127#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3128pub struct MetadataFull {
3129 #[serde(rename = "$parent", default, skip_serializing_if = "Option::is_none")]
3130 pub parent: Option<String>,
3131 #[serde(rename = "$template", default, skip_serializing_if = "Option::is_none")]
3132 pub template: Option<String>,
3133 #[serde(rename = "$scope", default, skip_serializing_if = "Option::is_none")]
3134 pub scope: Option<String>,
3135 #[serde(rename = "$version", default, skip_serializing_if = "Option::is_none")]
3136 pub version: Option<i64>,
3137 #[serde(rename = "$canEdit", default, skip_serializing_if = "Option::is_none")]
3138 pub can_edit: Option<bool>,
3139 #[serde(rename = "$id", default, skip_serializing_if = "Option::is_none")]
3140 pub id: Option<String>,
3141 #[serde(rename = "$type", default, skip_serializing_if = "Option::is_none")]
3142 pub r#type: Option<String>,
3143 #[serde(
3144 rename = "$typeVersion",
3145 default,
3146 skip_serializing_if = "Option::is_none"
3147 )]
3148 pub type_version: Option<i64>,
3149}
3150
3151#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3152pub struct MetadataCascadePolicies {
3153 #[serde(default, skip_serializing_if = "Option::is_none")]
3154 pub limit: Option<i64>,
3155 #[serde(
3156 default,
3157 skip_serializing_if = "Option::is_none",
3158 deserialize_with = "double_option"
3159 )]
3160 pub next_marker: Option<Option<String>>,
3161 #[serde(
3162 default,
3163 skip_serializing_if = "Option::is_none",
3164 deserialize_with = "double_option"
3165 )]
3166 pub prev_marker: Option<Option<String>>,
3167 #[serde(default, skip_serializing_if = "Option::is_none")]
3168 pub entries: Option<Vec<MetadataCascadePolicy>>,
3169}
3170
3171#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3172pub struct MetadataCascadePolicy {
3173 pub id: String,
3174 pub r#type: MetadataCascadePolicyType,
3175 #[serde(default, skip_serializing_if = "Option::is_none")]
3176 pub owner_enterprise: Option<MetadataCascadePolicyOwnerEnterprise>,
3177 #[serde(default, skip_serializing_if = "Option::is_none")]
3178 pub parent: Option<MetadataCascadePolicyParent>,
3179 #[serde(default, skip_serializing_if = "Option::is_none")]
3180 pub scope: Option<String>,
3181 #[serde(
3182 rename = "templateKey",
3183 default,
3184 skip_serializing_if = "Option::is_none"
3185 )]
3186 pub template_key: Option<String>,
3187}
3188
3189#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3190pub struct MetadataError {
3191 #[serde(default, skip_serializing_if = "Option::is_none")]
3192 pub code: Option<String>,
3193 #[serde(default, skip_serializing_if = "Option::is_none")]
3194 pub message: Option<String>,
3195 #[serde(default, skip_serializing_if = "Option::is_none")]
3196 pub request_id: Option<String>,
3197}
3198
3199#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3200pub struct MetadataFieldFilterDateRange {
3201 #[serde(default, skip_serializing_if = "Option::is_none")]
3202 pub lt: Option<chrono::DateTime<chrono::Utc>>,
3203 #[serde(default, skip_serializing_if = "Option::is_none")]
3204 pub gt: Option<chrono::DateTime<chrono::Utc>>,
3205}
3206
3207#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3208pub struct MetadataFieldFilterFloatRange {
3209 #[serde(default, skip_serializing_if = "Option::is_none")]
3210 pub lt: Option<f64>,
3211 #[serde(default, skip_serializing_if = "Option::is_none")]
3212 pub gt: Option<f64>,
3213}
3214
3215#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3216pub struct MetadataFilter {
3217 #[serde(default, skip_serializing_if = "Option::is_none")]
3218 pub scope: Option<MetadataFilterScope>,
3219 #[serde(
3220 rename = "templateKey",
3221 default,
3222 skip_serializing_if = "Option::is_none"
3223 )]
3224 pub template_key: Option<String>,
3225 #[serde(default, skip_serializing_if = "Option::is_none")]
3226 pub filters: Option<std::collections::HashMap<String, MetadataFilterValue>>,
3227}
3228
3229#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3230#[serde(transparent)]
3231pub struct MetadataFilterValue(pub serde_json::Value);
3232
3233#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3234#[serde(transparent)]
3235pub struct MetadataInstanceValue(pub serde_json::Value);
3236
3237#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3238pub struct MetadataQuery {
3239 pub from: String,
3240 #[serde(default, skip_serializing_if = "Option::is_none")]
3241 pub query: Option<String>,
3242 #[serde(default, skip_serializing_if = "Option::is_none")]
3243 pub query_params: Option<std::collections::HashMap<String, serde_json::Value>>,
3244 pub ancestor_folder_id: String,
3245 #[serde(default, skip_serializing_if = "Option::is_none")]
3246 pub order_by: Option<Vec<MetadataQueryOrderBy>>,
3247 #[serde(default, skip_serializing_if = "Option::is_none")]
3248 pub limit: Option<i64>,
3249 #[serde(default, skip_serializing_if = "Option::is_none")]
3250 pub marker: Option<String>,
3251 #[serde(default, skip_serializing_if = "Option::is_none")]
3252 pub fields: Option<Vec<String>>,
3253}
3254
3255#[derive(Clone, Debug, PartialEq)]
3256pub enum MetadataQueryResultItem {
3257 File(FileFull),
3258 Folder(FolderFull),
3259 Unknown(serde_json::Value),
3261}
3262
3263impl Default for MetadataQueryResultItem {
3264 fn default() -> Self {
3265 Self::Unknown(Default::default())
3266 }
3267}
3268
3269impl serde::Serialize for MetadataQueryResultItem {
3270 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3271 match self {
3272 Self::File(inner) => inner.serialize(serializer),
3273 Self::Folder(inner) => inner.serialize(serializer),
3274 Self::Unknown(inner) => inner.serialize(serializer),
3275 }
3276 }
3277}
3278
3279impl<'de> serde::Deserialize<'de> for MetadataQueryResultItem {
3280 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3281 let value = serde_json::Value::deserialize(deserializer)?;
3282 let tag = value
3283 .get("type")
3284 .and_then(serde_json::Value::as_str)
3285 .map(str::to_owned);
3286 match tag.as_deref() {
3287 Some("file") => Ok(Self::File(
3288 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3289 )),
3290 Some("folder") => Ok(Self::Folder(
3291 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3292 )),
3293 _ => Ok(Self::Unknown(value)),
3294 }
3295 }
3296}
3297
3298#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3299pub struct MetadataQueryResults {
3300 #[serde(default, skip_serializing_if = "Option::is_none")]
3301 pub entries: Option<Vec<MetadataQueryResultItem>>,
3302 #[serde(default, skip_serializing_if = "Option::is_none")]
3303 pub limit: Option<i64>,
3304 #[serde(default, skip_serializing_if = "Option::is_none")]
3305 pub next_marker: Option<String>,
3306}
3307
3308#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3309pub struct Metadatas {
3310 #[serde(default, skip_serializing_if = "Option::is_none")]
3311 pub entries: Option<Vec<Metadata>>,
3312 #[serde(default, skip_serializing_if = "Option::is_none")]
3313 pub limit: Option<i64>,
3314}
3315
3316#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3317pub struct MetadataTaxonomies {
3318 #[serde(default, skip_serializing_if = "Option::is_none")]
3319 pub limit: Option<i64>,
3320 #[serde(
3321 default,
3322 skip_serializing_if = "Option::is_none",
3323 deserialize_with = "double_option"
3324 )]
3325 pub next_marker: Option<Option<String>>,
3326 #[serde(
3327 default,
3328 skip_serializing_if = "Option::is_none",
3329 deserialize_with = "double_option"
3330 )]
3331 pub prev_marker: Option<Option<String>>,
3332 #[serde(default, skip_serializing_if = "Option::is_none")]
3333 pub entries: Option<Vec<MetadataTaxonomy>>,
3334}
3335
3336#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3337pub struct MetadataTaxonomy {
3338 pub id: String,
3339 #[serde(default, skip_serializing_if = "Option::is_none")]
3340 pub key: Option<String>,
3341 #[serde(rename = "displayName")]
3342 pub display_name: String,
3343 pub namespace: String,
3344 #[serde(default, skip_serializing_if = "Option::is_none")]
3345 pub levels: Option<Vec<MetadataTaxonomyLevel>>,
3346}
3347
3348#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3349pub struct MetadataTaxonomyAncestor {
3350 #[serde(default, skip_serializing_if = "Option::is_none")]
3351 pub id: Option<String>,
3352 #[serde(
3353 rename = "displayName",
3354 default,
3355 skip_serializing_if = "Option::is_none"
3356 )]
3357 pub display_name: Option<String>,
3358 #[serde(default, skip_serializing_if = "Option::is_none")]
3359 pub level: Option<i64>,
3360}
3361
3362#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3363pub struct MetadataTaxonomyLevel {
3364 #[serde(
3365 rename = "displayName",
3366 default,
3367 skip_serializing_if = "Option::is_none"
3368 )]
3369 pub display_name: Option<String>,
3370 #[serde(default, skip_serializing_if = "Option::is_none")]
3371 pub description: Option<String>,
3372 #[serde(default, skip_serializing_if = "Option::is_none")]
3373 pub level: Option<i64>,
3374}
3375
3376#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3377pub struct MetadataTaxonomyLevels {
3378 #[serde(default, skip_serializing_if = "Option::is_none")]
3379 pub entries: Option<Vec<MetadataTaxonomyLevel>>,
3380}
3381
3382#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3383pub struct MetadataTaxonomyNode {
3384 pub id: String,
3385 #[serde(rename = "displayName")]
3386 pub display_name: String,
3387 pub level: i64,
3388 #[serde(rename = "parentId", default, skip_serializing_if = "Option::is_none")]
3389 pub parent_id: Option<String>,
3390 #[serde(rename = "nodePath", default, skip_serializing_if = "Option::is_none")]
3391 pub node_path: Option<Vec<String>>,
3392 #[serde(default, skip_serializing_if = "Option::is_none")]
3393 pub ancestors: Option<Vec<MetadataTaxonomyAncestor>>,
3394}
3395
3396#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3397pub struct MetadataTaxonomyNodes {
3398 #[serde(default, skip_serializing_if = "Option::is_none")]
3399 pub limit: Option<i64>,
3400 #[serde(
3401 default,
3402 skip_serializing_if = "Option::is_none",
3403 deserialize_with = "double_option"
3404 )]
3405 pub next_marker: Option<Option<String>>,
3406 #[serde(
3407 default,
3408 skip_serializing_if = "Option::is_none",
3409 deserialize_with = "double_option"
3410 )]
3411 pub prev_marker: Option<Option<String>>,
3412 #[serde(default, skip_serializing_if = "Option::is_none")]
3413 pub entries: Option<Vec<MetadataTaxonomyNode>>,
3414}
3415
3416#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3417pub struct MetadataTemplate {
3418 pub id: String,
3419 pub r#type: MetadataTemplateType,
3420 #[serde(default, skip_serializing_if = "Option::is_none")]
3421 pub scope: Option<String>,
3422 #[serde(
3423 rename = "templateKey",
3424 default,
3425 skip_serializing_if = "Option::is_none"
3426 )]
3427 pub template_key: Option<String>,
3428 #[serde(
3429 rename = "displayName",
3430 default,
3431 skip_serializing_if = "Option::is_none"
3432 )]
3433 pub display_name: Option<String>,
3434 #[serde(default, skip_serializing_if = "Option::is_none")]
3435 pub hidden: Option<bool>,
3436 #[serde(default, skip_serializing_if = "Option::is_none")]
3437 pub fields: Option<Vec<MetadataTemplateFields>>,
3438 #[serde(
3439 rename = "copyInstanceOnItemCopy",
3440 default,
3441 skip_serializing_if = "Option::is_none"
3442 )]
3443 pub copy_instance_on_item_copy: Option<bool>,
3444}
3445
3446#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3447pub struct MetadataTemplates {
3448 #[serde(default, skip_serializing_if = "Option::is_none")]
3449 pub limit: Option<i64>,
3450 #[serde(
3451 default,
3452 skip_serializing_if = "Option::is_none",
3453 deserialize_with = "double_option"
3454 )]
3455 pub next_marker: Option<Option<String>>,
3456 #[serde(
3457 default,
3458 skip_serializing_if = "Option::is_none",
3459 deserialize_with = "double_option"
3460 )]
3461 pub prev_marker: Option<Option<String>>,
3462 #[serde(default, skip_serializing_if = "Option::is_none")]
3463 pub entries: Option<Vec<MetadataTemplate>>,
3464}
3465
3466#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3467pub struct OAuth2Error {
3468 #[serde(default, skip_serializing_if = "Option::is_none")]
3469 pub error: Option<String>,
3470 #[serde(default, skip_serializing_if = "Option::is_none")]
3471 pub error_description: Option<String>,
3472}
3473
3474#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3475pub struct Outcome {
3476 pub id: String,
3477 #[serde(default, skip_serializing_if = "Option::is_none")]
3478 pub collaborators: Option<CollaboratorVariable>,
3479 #[serde(default, skip_serializing_if = "Option::is_none")]
3480 pub completion_rule: Option<CompletionRuleVariable>,
3481 #[serde(default, skip_serializing_if = "Option::is_none")]
3482 pub file_collaborator_role: Option<RoleVariable>,
3483 #[serde(default, skip_serializing_if = "Option::is_none")]
3484 pub task_collaborators: Option<CollaboratorVariable>,
3485 #[serde(default, skip_serializing_if = "Option::is_none")]
3486 pub role: Option<RoleVariable>,
3487}
3488
3489#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3490pub struct PostOAuth2Revoke {
3491 #[serde(default, skip_serializing_if = "Option::is_none")]
3492 pub client_id: Option<String>,
3493 #[serde(default, skip_serializing_if = "Option::is_none")]
3494 pub client_secret: Option<String>,
3495 #[serde(default, skip_serializing_if = "Option::is_none")]
3496 pub token: Option<String>,
3497}
3498
3499#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3500pub struct PostOAuth2Token {
3501 pub grant_type: PostOAuth2TokenGrantType,
3502 #[serde(default, skip_serializing_if = "Option::is_none")]
3503 pub client_id: Option<String>,
3504 #[serde(default, skip_serializing_if = "Option::is_none")]
3505 pub client_secret: Option<String>,
3506 #[serde(default, skip_serializing_if = "Option::is_none")]
3507 pub code: Option<String>,
3508 #[serde(default, skip_serializing_if = "Option::is_none")]
3509 pub refresh_token: Option<String>,
3510 #[serde(default, skip_serializing_if = "Option::is_none")]
3511 pub assertion: Option<String>,
3512 #[serde(default, skip_serializing_if = "Option::is_none")]
3513 pub subject_token: Option<String>,
3514 #[serde(default, skip_serializing_if = "Option::is_none")]
3515 pub subject_token_type: Option<AccessTokenIssuedTokenType>,
3516 #[serde(default, skip_serializing_if = "Option::is_none")]
3517 pub actor_token: Option<String>,
3518 #[serde(default, skip_serializing_if = "Option::is_none")]
3519 pub actor_token_type: Option<PostOAuth2TokenActorTokenType>,
3520 #[serde(default, skip_serializing_if = "Option::is_none")]
3521 pub scope: Option<String>,
3522 #[serde(default, skip_serializing_if = "Option::is_none")]
3523 pub resource: Option<String>,
3524 #[serde(default, skip_serializing_if = "Option::is_none")]
3525 pub box_subject_type: Option<PostOAuth2TokenBoxSubjectType>,
3526 #[serde(default, skip_serializing_if = "Option::is_none")]
3527 pub box_subject_id: Option<String>,
3528 #[serde(default, skip_serializing_if = "Option::is_none")]
3529 pub box_shared_link: Option<String>,
3530}
3531
3532#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3533pub struct PostOAuth2TokenRefreshAccessToken {
3534 pub grant_type: PostOAuth2TokenRefreshAccessTokenGrantType,
3535 pub client_id: String,
3536 pub client_secret: String,
3537 pub refresh_token: String,
3538}
3539
3540#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3541pub struct RealtimeServer {
3542 #[serde(default, skip_serializing_if = "Option::is_none")]
3543 pub r#type: Option<String>,
3544 #[serde(default, skip_serializing_if = "Option::is_none")]
3545 pub url: Option<String>,
3546 #[serde(default, skip_serializing_if = "Option::is_none")]
3547 pub ttl: Option<String>,
3548 #[serde(default, skip_serializing_if = "Option::is_none")]
3549 pub max_retries: Option<String>,
3550 #[serde(default, skip_serializing_if = "Option::is_none")]
3551 pub retry_timeout: Option<i64>,
3552}
3553
3554#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3555pub struct RealtimeServers {
3556 #[serde(default, skip_serializing_if = "Option::is_none")]
3557 pub chunk_size: Option<i64>,
3558 #[serde(default, skip_serializing_if = "Option::is_none")]
3559 pub entries: Option<Vec<RealtimeServer>>,
3560}
3561
3562#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3563pub struct RecentItem {
3564 #[serde(default, skip_serializing_if = "Option::is_none")]
3565 pub r#type: Option<String>,
3566 #[serde(default, skip_serializing_if = "Option::is_none")]
3567 pub item: Option<RecentItemResource>,
3568 #[serde(default, skip_serializing_if = "Option::is_none")]
3569 pub interaction_type: Option<RecentItemInteractionType>,
3570 #[serde(default, skip_serializing_if = "Option::is_none")]
3571 pub interacted_at: Option<chrono::DateTime<chrono::Utc>>,
3572 #[serde(default, skip_serializing_if = "Option::is_none")]
3573 pub interaction_shared_link: Option<String>,
3574}
3575
3576#[derive(Clone, Debug, PartialEq)]
3577pub enum RecentItemResource {
3578 File(FileFull),
3579 Folder(FolderFull),
3580 WebLink(WebLink),
3581 Unknown(serde_json::Value),
3583}
3584
3585impl Default for RecentItemResource {
3586 fn default() -> Self {
3587 Self::Unknown(Default::default())
3588 }
3589}
3590
3591impl serde::Serialize for RecentItemResource {
3592 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3593 match self {
3594 Self::File(inner) => inner.serialize(serializer),
3595 Self::Folder(inner) => inner.serialize(serializer),
3596 Self::WebLink(inner) => inner.serialize(serializer),
3597 Self::Unknown(inner) => inner.serialize(serializer),
3598 }
3599 }
3600}
3601
3602impl<'de> serde::Deserialize<'de> for RecentItemResource {
3603 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3604 let value = serde_json::Value::deserialize(deserializer)?;
3605 let tag = value
3606 .get("type")
3607 .and_then(serde_json::Value::as_str)
3608 .map(str::to_owned);
3609 match tag.as_deref() {
3610 Some("file") => Ok(Self::File(
3611 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3612 )),
3613 Some("folder") => Ok(Self::Folder(
3614 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3615 )),
3616 Some("web_link") => Ok(Self::WebLink(
3617 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3618 )),
3619 _ => Ok(Self::Unknown(value)),
3620 }
3621 }
3622}
3623
3624#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3625pub struct RecentItems {
3626 #[serde(default, skip_serializing_if = "Option::is_none")]
3627 pub limit: Option<i64>,
3628 #[serde(
3629 default,
3630 skip_serializing_if = "Option::is_none",
3631 deserialize_with = "double_option"
3632 )]
3633 pub next_marker: Option<Option<String>>,
3634 #[serde(
3635 default,
3636 skip_serializing_if = "Option::is_none",
3637 deserialize_with = "double_option"
3638 )]
3639 pub prev_marker: Option<Option<String>>,
3640 #[serde(default, skip_serializing_if = "Option::is_none")]
3641 pub entries: Option<Vec<RecentItem>>,
3642}
3643
3644#[derive(Clone, Debug, PartialEq)]
3645pub enum Resource {
3646 Folder(FolderMini),
3647 File(FileMini),
3648 Unknown(serde_json::Value),
3650}
3651
3652impl Default for Resource {
3653 fn default() -> Self {
3654 Self::Unknown(Default::default())
3655 }
3656}
3657
3658impl serde::Serialize for Resource {
3659 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3660 match self {
3661 Self::Folder(inner) => inner.serialize(serializer),
3662 Self::File(inner) => inner.serialize(serializer),
3663 Self::Unknown(inner) => inner.serialize(serializer),
3664 }
3665 }
3666}
3667
3668impl<'de> serde::Deserialize<'de> for Resource {
3669 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3670 let value = serde_json::Value::deserialize(deserializer)?;
3671 let tag = value
3672 .get("type")
3673 .and_then(serde_json::Value::as_str)
3674 .map(str::to_owned);
3675 match tag.as_deref() {
3676 Some("folder") => Ok(Self::Folder(
3677 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3678 )),
3679 Some("file") => Ok(Self::File(
3680 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3681 )),
3682 _ => Ok(Self::Unknown(value)),
3683 }
3684 }
3685}
3686
3687#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3688pub struct ResourceScope {
3689 #[serde(default, skip_serializing_if = "Option::is_none")]
3690 pub scope: Option<ResourceScopeScope>,
3691 #[serde(default, skip_serializing_if = "Option::is_none")]
3692 pub object: Option<Resource>,
3693}
3694
3695#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3696pub struct RetentionPolicies {
3697 #[serde(default, skip_serializing_if = "Option::is_none")]
3698 pub entries: Option<Vec<RetentionPolicy>>,
3699 #[serde(default, skip_serializing_if = "Option::is_none")]
3700 pub limit: Option<i64>,
3701 #[serde(
3702 default,
3703 skip_serializing_if = "Option::is_none",
3704 deserialize_with = "double_option"
3705 )]
3706 pub next_marker: Option<Option<String>>,
3707}
3708
3709#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3710pub struct RetentionPolicy {
3711 pub id: String,
3712 pub r#type: RetentionPolicyType,
3713 #[serde(default, skip_serializing_if = "Option::is_none")]
3714 pub policy_name: Option<String>,
3715 #[serde(default, skip_serializing_if = "Option::is_none")]
3716 pub retention_length: Option<String>,
3717 #[serde(default, skip_serializing_if = "Option::is_none")]
3718 pub disposition_action: Option<RetentionPolicyDispositionAction>,
3719 #[serde(default, skip_serializing_if = "Option::is_none")]
3720 pub max_extension_length: Option<RetentionPolicyMaxExtensionLengthResponse>,
3721 #[serde(default, skip_serializing_if = "Option::is_none")]
3722 pub description: Option<String>,
3723 #[serde(default, skip_serializing_if = "Option::is_none")]
3724 pub policy_type: Option<RetentionPolicyPolicyType>,
3725 #[serde(default, skip_serializing_if = "Option::is_none")]
3726 pub retention_type: Option<RetentionPolicyRetentionType>,
3727 #[serde(default, skip_serializing_if = "Option::is_none")]
3728 pub status: Option<RetentionPolicyStatus>,
3729 #[serde(default, skip_serializing_if = "Option::is_none")]
3730 pub created_by: Option<UserMini>,
3731 #[serde(default, skip_serializing_if = "Option::is_none")]
3732 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
3733 #[serde(default, skip_serializing_if = "Option::is_none")]
3734 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
3735 #[serde(default, skip_serializing_if = "Option::is_none")]
3736 pub can_owner_extend_retention: Option<bool>,
3737 #[serde(default, skip_serializing_if = "Option::is_none")]
3738 pub are_owners_notified: Option<bool>,
3739 #[serde(default, skip_serializing_if = "Option::is_none")]
3740 pub custom_notification_recipients: Option<Vec<UserMini>>,
3741 #[serde(default, skip_serializing_if = "Option::is_none")]
3742 pub assignment_counts: Option<RetentionPolicyAssignmentCounts>,
3743}
3744
3745#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3746pub struct RetentionPolicyBase {
3747 pub id: String,
3748 pub r#type: RetentionPolicyType,
3749}
3750
3751#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3752pub struct RetentionPolicyMini {
3753 pub id: String,
3754 pub r#type: RetentionPolicyType,
3755 #[serde(default, skip_serializing_if = "Option::is_none")]
3756 pub policy_name: Option<String>,
3757 #[serde(default, skip_serializing_if = "Option::is_none")]
3758 pub retention_length: Option<String>,
3759 #[serde(default, skip_serializing_if = "Option::is_none")]
3760 pub disposition_action: Option<RetentionPolicyDispositionAction>,
3761 #[serde(default, skip_serializing_if = "Option::is_none")]
3762 pub max_extension_length: Option<RetentionPolicyMaxExtensionLengthResponse>,
3763}
3764
3765#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3766pub struct RetentionPolicyAssignment {
3767 pub id: String,
3768 pub r#type: RetentionPolicyAssignmentType,
3769 #[serde(default, skip_serializing_if = "Option::is_none")]
3770 pub retention_policy: Option<RetentionPolicyMini>,
3771 #[serde(default, skip_serializing_if = "Option::is_none")]
3772 pub assigned_to: Option<RetentionPolicyAssignmentAssignedTo>,
3773 #[serde(
3774 default,
3775 skip_serializing_if = "Option::is_none",
3776 deserialize_with = "double_option"
3777 )]
3778 pub filter_fields: Option<Option<Vec<RetentionPolicyAssignmentFilterFields>>>,
3779 #[serde(default, skip_serializing_if = "Option::is_none")]
3780 pub assigned_by: Option<UserMini>,
3781 #[serde(default, skip_serializing_if = "Option::is_none")]
3782 pub assigned_at: Option<chrono::DateTime<chrono::Utc>>,
3783 #[serde(default, skip_serializing_if = "Option::is_none")]
3784 pub start_date_field: Option<String>,
3785}
3786
3787#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3788pub struct RetentionPolicyAssignments {
3789 #[serde(default, skip_serializing_if = "Option::is_none")]
3790 pub entries: Option<Vec<RetentionPolicyAssignment>>,
3791 #[serde(default, skip_serializing_if = "Option::is_none")]
3792 pub limit: Option<i64>,
3793 #[serde(
3794 default,
3795 skip_serializing_if = "Option::is_none",
3796 deserialize_with = "double_option"
3797 )]
3798 pub next_marker: Option<Option<String>>,
3799}
3800
3801#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3802#[serde(transparent)]
3803pub struct RetentionPolicyMaxExtensionLengthRequest(pub serde_json::Value);
3804
3805#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3806#[serde(transparent)]
3807pub struct RetentionPolicyMaxExtensionLengthResponse(pub serde_json::Value);
3808
3809#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3810pub struct RoleVariable {
3811 pub r#type: CollaboratorVariableType,
3812 pub variable_type: RoleVariableVariableType,
3813 pub variable_value: FileFullAllowedInviteeRoles,
3814}
3815
3816#[derive(Clone, Debug, PartialEq)]
3817pub enum SearchResultItem {
3818 File(FileFull),
3819 Folder(FolderFull),
3820 WebLink(WebLink),
3821 Unknown(serde_json::Value),
3823}
3824
3825impl Default for SearchResultItem {
3826 fn default() -> Self {
3827 Self::Unknown(Default::default())
3828 }
3829}
3830
3831impl serde::Serialize for SearchResultItem {
3832 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3833 match self {
3834 Self::File(inner) => inner.serialize(serializer),
3835 Self::Folder(inner) => inner.serialize(serializer),
3836 Self::WebLink(inner) => inner.serialize(serializer),
3837 Self::Unknown(inner) => inner.serialize(serializer),
3838 }
3839 }
3840}
3841
3842impl<'de> serde::Deserialize<'de> for SearchResultItem {
3843 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3844 let value = serde_json::Value::deserialize(deserializer)?;
3845 let tag = value
3846 .get("type")
3847 .and_then(serde_json::Value::as_str)
3848 .map(str::to_owned);
3849 match tag.as_deref() {
3850 Some("file") => Ok(Self::File(
3851 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3852 )),
3853 Some("folder") => Ok(Self::Folder(
3854 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3855 )),
3856 Some("web_link") => Ok(Self::WebLink(
3857 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3858 )),
3859 _ => Ok(Self::Unknown(value)),
3860 }
3861 }
3862}
3863
3864#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3865pub struct SearchResults {
3866 #[serde(default, skip_serializing_if = "Option::is_none")]
3867 pub total_count: Option<i64>,
3868 #[serde(default, skip_serializing_if = "Option::is_none")]
3869 pub limit: Option<i64>,
3870 #[serde(default, skip_serializing_if = "Option::is_none")]
3871 pub offset: Option<i64>,
3872 pub r#type: SearchResultsType,
3873 #[serde(default, skip_serializing_if = "Option::is_none")]
3874 pub entries: Option<Vec<SearchResultItem>>,
3875}
3876
3877#[derive(Clone, Debug, PartialEq)]
3878pub enum SearchResultsResponse {
3879 SearchResultsItems(SearchResults),
3880 SearchResultsWithSharedLinks(SearchResultsWithSharedLinks),
3881 Unknown(serde_json::Value),
3883}
3884
3885impl Default for SearchResultsResponse {
3886 fn default() -> Self {
3887 Self::Unknown(Default::default())
3888 }
3889}
3890
3891impl serde::Serialize for SearchResultsResponse {
3892 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3893 match self {
3894 Self::SearchResultsItems(inner) => inner.serialize(serializer),
3895 Self::SearchResultsWithSharedLinks(inner) => inner.serialize(serializer),
3896 Self::Unknown(inner) => inner.serialize(serializer),
3897 }
3898 }
3899}
3900
3901impl<'de> serde::Deserialize<'de> for SearchResultsResponse {
3902 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3903 let value = serde_json::Value::deserialize(deserializer)?;
3904 let tag = value
3905 .get("type")
3906 .and_then(serde_json::Value::as_str)
3907 .map(str::to_owned);
3908 match tag.as_deref() {
3909 Some("search_results_items") => Ok(Self::SearchResultsItems(
3910 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3911 )),
3912 Some("search_results_with_shared_links") => Ok(Self::SearchResultsWithSharedLinks(
3913 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3914 )),
3915 _ => Ok(Self::Unknown(value)),
3916 }
3917 }
3918}
3919
3920#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3921pub struct SearchResultsWithSharedLinks {
3922 #[serde(default, skip_serializing_if = "Option::is_none")]
3923 pub total_count: Option<i64>,
3924 #[serde(default, skip_serializing_if = "Option::is_none")]
3925 pub limit: Option<i64>,
3926 #[serde(default, skip_serializing_if = "Option::is_none")]
3927 pub offset: Option<i64>,
3928 pub r#type: SearchResultsWithSharedLinksType,
3929 #[serde(default, skip_serializing_if = "Option::is_none")]
3930 pub entries: Option<Vec<SearchResultWithSharedLink>>,
3931}
3932
3933#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3934pub struct SearchResultWithSharedLink {
3935 #[serde(default, skip_serializing_if = "Option::is_none")]
3936 pub accessible_via_shared_link: Option<String>,
3937 #[serde(default, skip_serializing_if = "Option::is_none")]
3938 pub item: Option<SearchResultWithSharedLinkItem>,
3939 #[serde(default, skip_serializing_if = "Option::is_none")]
3940 pub r#type: Option<String>,
3941}
3942
3943#[derive(Clone, Debug, PartialEq)]
3944pub enum SearchResultWithSharedLinkItem {
3945 File(FileFull),
3946 Folder(FolderFull),
3947 WebLink(WebLink),
3948 Unknown(serde_json::Value),
3950}
3951
3952impl Default for SearchResultWithSharedLinkItem {
3953 fn default() -> Self {
3954 Self::Unknown(Default::default())
3955 }
3956}
3957
3958impl serde::Serialize for SearchResultWithSharedLinkItem {
3959 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3960 match self {
3961 Self::File(inner) => inner.serialize(serializer),
3962 Self::Folder(inner) => inner.serialize(serializer),
3963 Self::WebLink(inner) => inner.serialize(serializer),
3964 Self::Unknown(inner) => inner.serialize(serializer),
3965 }
3966 }
3967}
3968
3969impl<'de> serde::Deserialize<'de> for SearchResultWithSharedLinkItem {
3970 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3971 let value = serde_json::Value::deserialize(deserializer)?;
3972 let tag = value
3973 .get("type")
3974 .and_then(serde_json::Value::as_str)
3975 .map(str::to_owned);
3976 match tag.as_deref() {
3977 Some("file") => Ok(Self::File(
3978 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3979 )),
3980 Some("folder") => Ok(Self::Folder(
3981 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3982 )),
3983 Some("web_link") => Ok(Self::WebLink(
3984 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
3985 )),
3986 _ => Ok(Self::Unknown(value)),
3987 }
3988 }
3989}
3990
3991#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3992pub struct SessionTerminationMessage {
3993 #[serde(default, skip_serializing_if = "Option::is_none")]
3994 pub message: Option<String>,
3995}
3996
3997#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3998pub struct ShieldInformationBarrier {
3999 #[serde(default, skip_serializing_if = "Option::is_none")]
4000 pub id: Option<String>,
4001 #[serde(default, skip_serializing_if = "Option::is_none")]
4002 pub r#type: Option<ShieldInformationBarrierType>,
4003 #[serde(default, skip_serializing_if = "Option::is_none")]
4004 pub enterprise: Option<EnterpriseBase>,
4005 #[serde(default, skip_serializing_if = "Option::is_none")]
4006 pub status: Option<ShieldInformationBarrierStatus>,
4007 #[serde(default, skip_serializing_if = "Option::is_none")]
4008 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
4009 #[serde(default, skip_serializing_if = "Option::is_none")]
4010 pub created_by: Option<UserBase>,
4011 #[serde(default, skip_serializing_if = "Option::is_none")]
4012 pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
4013 #[serde(default, skip_serializing_if = "Option::is_none")]
4014 pub updated_by: Option<UserBase>,
4015 #[serde(default, skip_serializing_if = "Option::is_none")]
4016 pub enabled_at: Option<chrono::DateTime<chrono::Utc>>,
4017 #[serde(default, skip_serializing_if = "Option::is_none")]
4018 pub enabled_by: Option<UserBase>,
4019}
4020
4021#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4022pub struct ShieldInformationBarrierBase {
4023 #[serde(default, skip_serializing_if = "Option::is_none")]
4024 pub id: Option<String>,
4025 #[serde(default, skip_serializing_if = "Option::is_none")]
4026 pub r#type: Option<ShieldInformationBarrierType>,
4027}
4028
4029#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4030pub struct ShieldInformationBarrierReference {
4031 #[serde(default, skip_serializing_if = "Option::is_none")]
4032 pub shield_information_barrier: Option<ShieldInformationBarrierBase>,
4033}
4034
4035#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4036pub struct ShieldInformationBarrierReport {
4037 #[serde(default, skip_serializing_if = "Option::is_none")]
4038 pub id: Option<String>,
4039 #[serde(default, skip_serializing_if = "Option::is_none")]
4040 pub r#type: Option<ShieldInformationBarrierReportType>,
4041 #[serde(default, skip_serializing_if = "Option::is_none")]
4042 pub shield_information_barrier: Option<ShieldInformationBarrierReference>,
4043 #[serde(default, skip_serializing_if = "Option::is_none")]
4044 pub status: Option<ShieldInformationBarrierReportStatus>,
4045 #[serde(default, skip_serializing_if = "Option::is_none")]
4046 pub details: Option<ShieldInformationBarrierReportDetails>,
4047 #[serde(default, skip_serializing_if = "Option::is_none")]
4048 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
4049 #[serde(default, skip_serializing_if = "Option::is_none")]
4050 pub created_by: Option<UserBase>,
4051 #[serde(default, skip_serializing_if = "Option::is_none")]
4052 pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
4053}
4054
4055#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4056pub struct ShieldInformationBarrierReportBase {
4057 #[serde(default, skip_serializing_if = "Option::is_none")]
4058 pub id: Option<String>,
4059 #[serde(default, skip_serializing_if = "Option::is_none")]
4060 pub r#type: Option<ShieldInformationBarrierReportType>,
4061}
4062
4063#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4064pub struct ShieldInformationBarrierReportDetails {
4065 #[serde(default, skip_serializing_if = "Option::is_none")]
4066 pub details: Option<ShieldInformationBarrierReportDetailsDetails>,
4067}
4068
4069#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4070pub struct ShieldInformationBarrierReports {
4071 #[serde(default, skip_serializing_if = "Option::is_none")]
4072 pub limit: Option<i64>,
4073 #[serde(
4074 default,
4075 skip_serializing_if = "Option::is_none",
4076 deserialize_with = "double_option"
4077 )]
4078 pub next_marker: Option<Option<String>>,
4079 #[serde(default, skip_serializing_if = "Option::is_none")]
4080 pub entries: Option<Vec<ShieldInformationBarrierReport>>,
4081}
4082
4083#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4084pub struct ShieldInformationBarriers {
4085 #[serde(default, skip_serializing_if = "Option::is_none")]
4086 pub limit: Option<i64>,
4087 #[serde(
4088 default,
4089 skip_serializing_if = "Option::is_none",
4090 deserialize_with = "double_option"
4091 )]
4092 pub next_marker: Option<Option<String>>,
4093 #[serde(default, skip_serializing_if = "Option::is_none")]
4094 pub entries: Option<Vec<ShieldInformationBarrier>>,
4095}
4096
4097#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4098pub struct ShieldInformationBarrierSegment {
4099 #[serde(default, skip_serializing_if = "Option::is_none")]
4100 pub id: Option<String>,
4101 #[serde(default, skip_serializing_if = "Option::is_none")]
4102 pub r#type: Option<ShieldInformationBarrierSegmentType>,
4103 #[serde(default, skip_serializing_if = "Option::is_none")]
4104 pub shield_information_barrier: Option<ShieldInformationBarrierBase>,
4105 #[serde(default, skip_serializing_if = "Option::is_none")]
4106 pub name: Option<String>,
4107 #[serde(default, skip_serializing_if = "Option::is_none")]
4108 pub description: Option<String>,
4109 #[serde(default, skip_serializing_if = "Option::is_none")]
4110 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
4111 #[serde(default, skip_serializing_if = "Option::is_none")]
4112 pub created_by: Option<UserBase>,
4113 #[serde(default, skip_serializing_if = "Option::is_none")]
4114 pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
4115 #[serde(default, skip_serializing_if = "Option::is_none")]
4116 pub updated_by: Option<UserBase>,
4117}
4118
4119#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4120pub struct ShieldInformationBarrierSegmentMember {
4121 #[serde(default, skip_serializing_if = "Option::is_none")]
4122 pub id: Option<String>,
4123 #[serde(default, skip_serializing_if = "Option::is_none")]
4124 pub r#type: Option<ShieldInformationBarrierSegmentMemberType>,
4125 #[serde(default, skip_serializing_if = "Option::is_none")]
4126 pub user: Option<UserBase>,
4127 #[serde(default, skip_serializing_if = "Option::is_none")]
4128 pub shield_information_barrier: Option<ShieldInformationBarrierBase>,
4129 #[serde(default, skip_serializing_if = "Option::is_none")]
4130 pub shield_information_barrier_segment:
4131 Option<ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment>,
4132 #[serde(default, skip_serializing_if = "Option::is_none")]
4133 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
4134 #[serde(default, skip_serializing_if = "Option::is_none")]
4135 pub created_by: Option<UserBase>,
4136 #[serde(default, skip_serializing_if = "Option::is_none")]
4137 pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
4138 #[serde(default, skip_serializing_if = "Option::is_none")]
4139 pub updated_by: Option<UserBase>,
4140}
4141
4142#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4143pub struct ShieldInformationBarrierSegmentMemberBase {
4144 #[serde(default, skip_serializing_if = "Option::is_none")]
4145 pub id: Option<String>,
4146 #[serde(default, skip_serializing_if = "Option::is_none")]
4147 pub r#type: Option<ShieldInformationBarrierSegmentMemberType>,
4148}
4149
4150#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4151pub struct ShieldInformationBarrierSegmentMemberMini {
4152 #[serde(default, skip_serializing_if = "Option::is_none")]
4153 pub id: Option<String>,
4154 #[serde(default, skip_serializing_if = "Option::is_none")]
4155 pub r#type: Option<ShieldInformationBarrierSegmentMemberType>,
4156 #[serde(default, skip_serializing_if = "Option::is_none")]
4157 pub user: Option<UserBase>,
4158}
4159
4160#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4161pub struct ShieldInformationBarrierSegmentMembers {
4162 #[serde(default, skip_serializing_if = "Option::is_none")]
4163 pub limit: Option<i64>,
4164 #[serde(
4165 default,
4166 skip_serializing_if = "Option::is_none",
4167 deserialize_with = "double_option"
4168 )]
4169 pub next_marker: Option<Option<String>>,
4170 #[serde(default, skip_serializing_if = "Option::is_none")]
4171 pub entries: Option<Vec<ShieldInformationBarrierSegmentMember>>,
4172}
4173
4174#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4175pub struct ShieldInformationBarrierSegmentRestriction {
4176 #[serde(default, skip_serializing_if = "Option::is_none")]
4177 pub r#type: Option<ShieldInformationBarrierSegmentRestrictionType>,
4178 #[serde(default, skip_serializing_if = "Option::is_none")]
4179 pub id: Option<String>,
4180 pub shield_information_barrier_segment:
4181 ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment,
4182 pub restricted_segment: ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment,
4183 #[serde(default, skip_serializing_if = "Option::is_none")]
4184 pub shield_information_barrier: Option<ShieldInformationBarrierBase>,
4185 #[serde(default, skip_serializing_if = "Option::is_none")]
4186 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
4187 #[serde(default, skip_serializing_if = "Option::is_none")]
4188 pub created_by: Option<UserBase>,
4189 #[serde(default, skip_serializing_if = "Option::is_none")]
4190 pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
4191 #[serde(default, skip_serializing_if = "Option::is_none")]
4192 pub updated_by: Option<UserBase>,
4193}
4194
4195#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4196pub struct ShieldInformationBarrierSegmentRestrictionBase {
4197 #[serde(default, skip_serializing_if = "Option::is_none")]
4198 pub r#type: Option<ShieldInformationBarrierSegmentRestrictionType>,
4199 #[serde(default, skip_serializing_if = "Option::is_none")]
4200 pub id: Option<String>,
4201}
4202
4203#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4204pub struct ShieldInformationBarrierSegmentRestrictionMini {
4205 #[serde(default, skip_serializing_if = "Option::is_none")]
4206 pub r#type: Option<ShieldInformationBarrierSegmentRestrictionType>,
4207 #[serde(default, skip_serializing_if = "Option::is_none")]
4208 pub id: Option<String>,
4209 pub shield_information_barrier_segment:
4210 ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment,
4211 pub restricted_segment: ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment,
4212}
4213
4214#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4215pub struct ShieldInformationBarrierSegmentRestrictions {
4216 #[serde(default, skip_serializing_if = "Option::is_none")]
4217 pub limit: Option<i64>,
4218 #[serde(
4219 default,
4220 skip_serializing_if = "Option::is_none",
4221 deserialize_with = "double_option"
4222 )]
4223 pub next_marker: Option<Option<String>>,
4224 #[serde(default, skip_serializing_if = "Option::is_none")]
4225 pub entries: Option<Vec<ShieldInformationBarrierSegmentRestriction>>,
4226}
4227
4228#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4229pub struct ShieldInformationBarrierSegments {
4230 #[serde(default, skip_serializing_if = "Option::is_none")]
4231 pub limit: Option<i64>,
4232 #[serde(
4233 default,
4234 skip_serializing_if = "Option::is_none",
4235 deserialize_with = "double_option"
4236 )]
4237 pub next_marker: Option<Option<String>>,
4238 #[serde(default, skip_serializing_if = "Option::is_none")]
4239 pub entries: Option<Vec<ShieldInformationBarrierSegment>>,
4240}
4241
4242#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4243pub struct SignRequest {
4244 #[serde(default, skip_serializing_if = "Option::is_none")]
4245 pub is_document_preparation_needed: Option<bool>,
4246 #[serde(
4247 default,
4248 skip_serializing_if = "Option::is_none",
4249 deserialize_with = "double_option"
4250 )]
4251 pub redirect_url: Option<Option<String>>,
4252 #[serde(
4253 default,
4254 skip_serializing_if = "Option::is_none",
4255 deserialize_with = "double_option"
4256 )]
4257 pub declined_redirect_url: Option<Option<String>>,
4258 #[serde(default, skip_serializing_if = "Option::is_none")]
4259 pub are_text_signatures_enabled: Option<bool>,
4260 #[serde(
4261 default,
4262 skip_serializing_if = "Option::is_none",
4263 deserialize_with = "double_option"
4264 )]
4265 pub email_subject: Option<Option<String>>,
4266 #[serde(
4267 default,
4268 skip_serializing_if = "Option::is_none",
4269 deserialize_with = "double_option"
4270 )]
4271 pub email_message: Option<Option<String>>,
4272 #[serde(default, skip_serializing_if = "Option::is_none")]
4273 pub are_reminders_enabled: Option<bool>,
4274 #[serde(default, skip_serializing_if = "Option::is_none")]
4275 pub name: Option<String>,
4276 #[serde(default, skip_serializing_if = "Option::is_none")]
4277 pub prefill_tags: Option<Vec<SignRequestPrefillTag>>,
4278 #[serde(
4279 default,
4280 skip_serializing_if = "Option::is_none",
4281 deserialize_with = "double_option"
4282 )]
4283 pub days_valid: Option<Option<i64>>,
4284 #[serde(
4285 default,
4286 skip_serializing_if = "Option::is_none",
4287 deserialize_with = "double_option"
4288 )]
4289 pub external_id: Option<Option<String>>,
4290 #[serde(
4291 default,
4292 skip_serializing_if = "Option::is_none",
4293 deserialize_with = "double_option"
4294 )]
4295 pub template_id: Option<Option<String>>,
4296 #[serde(
4297 default,
4298 skip_serializing_if = "Option::is_none",
4299 deserialize_with = "double_option"
4300 )]
4301 pub external_system_name: Option<Option<String>>,
4302 #[serde(
4303 default,
4304 skip_serializing_if = "Option::is_none",
4305 deserialize_with = "double_option"
4306 )]
4307 pub request_flow: Option<Option<String>>,
4308 #[serde(default, skip_serializing_if = "Option::is_none")]
4309 pub r#type: Option<SignRequestType>,
4310 #[serde(default, skip_serializing_if = "Option::is_none")]
4311 pub source_files: Option<Vec<FileBase>>,
4312 #[serde(default, skip_serializing_if = "Option::is_none")]
4313 pub signers: Option<Vec<SignRequestSigner>>,
4314 #[serde(
4315 default,
4316 skip_serializing_if = "Option::is_none",
4317 deserialize_with = "double_option"
4318 )]
4319 pub signature_color: Option<Option<String>>,
4320 #[serde(default, skip_serializing_if = "Option::is_none")]
4321 pub id: Option<String>,
4322 #[serde(
4323 default,
4324 skip_serializing_if = "Option::is_none",
4325 deserialize_with = "double_option"
4326 )]
4327 pub prepare_url: Option<Option<String>>,
4328 #[serde(default, skip_serializing_if = "Option::is_none")]
4329 pub signing_log: Option<FileMini>,
4330 #[serde(default, skip_serializing_if = "Option::is_none")]
4331 pub status: Option<SignRequestStatus>,
4332 #[serde(default, skip_serializing_if = "Option::is_none")]
4333 pub sign_files: Option<SignRequestSignFiles>,
4334 #[serde(
4335 default,
4336 skip_serializing_if = "Option::is_none",
4337 deserialize_with = "double_option"
4338 )]
4339 pub auto_expire_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
4340 #[serde(default, skip_serializing_if = "Option::is_none")]
4341 pub parent_folder: Option<FolderMini>,
4342 #[serde(
4343 default,
4344 skip_serializing_if = "Option::is_none",
4345 deserialize_with = "double_option"
4346 )]
4347 pub collaborator_level: Option<Option<String>>,
4348 #[serde(default, skip_serializing_if = "Option::is_none")]
4349 pub short_id: Option<String>,
4350 #[serde(default, skip_serializing_if = "Option::is_none")]
4351 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
4352 #[serde(
4353 default,
4354 skip_serializing_if = "Option::is_none",
4355 deserialize_with = "double_option"
4356 )]
4357 pub finished_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
4358 #[serde(
4359 default,
4360 skip_serializing_if = "Option::is_none",
4361 deserialize_with = "double_option"
4362 )]
4363 pub error_code: Option<Option<String>>,
4364 #[serde(
4365 default,
4366 skip_serializing_if = "Option::is_none",
4367 deserialize_with = "double_option"
4368 )]
4369 pub sender_email: Option<Option<String>>,
4370 #[serde(
4371 default,
4372 skip_serializing_if = "Option::is_none",
4373 deserialize_with = "double_option"
4374 )]
4375 pub sender_id: Option<Option<i64>>,
4376}
4377
4378#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4379pub struct SignRequestBase {
4380 #[serde(default, skip_serializing_if = "Option::is_none")]
4381 pub is_document_preparation_needed: Option<bool>,
4382 #[serde(
4383 default,
4384 skip_serializing_if = "Option::is_none",
4385 deserialize_with = "double_option"
4386 )]
4387 pub redirect_url: Option<Option<String>>,
4388 #[serde(
4389 default,
4390 skip_serializing_if = "Option::is_none",
4391 deserialize_with = "double_option"
4392 )]
4393 pub declined_redirect_url: Option<Option<String>>,
4394 #[serde(default, skip_serializing_if = "Option::is_none")]
4395 pub are_text_signatures_enabled: Option<bool>,
4396 #[serde(
4397 default,
4398 skip_serializing_if = "Option::is_none",
4399 deserialize_with = "double_option"
4400 )]
4401 pub email_subject: Option<Option<String>>,
4402 #[serde(
4403 default,
4404 skip_serializing_if = "Option::is_none",
4405 deserialize_with = "double_option"
4406 )]
4407 pub email_message: Option<Option<String>>,
4408 #[serde(default, skip_serializing_if = "Option::is_none")]
4409 pub are_reminders_enabled: Option<bool>,
4410 #[serde(default, skip_serializing_if = "Option::is_none")]
4411 pub name: Option<String>,
4412 #[serde(default, skip_serializing_if = "Option::is_none")]
4413 pub prefill_tags: Option<Vec<SignRequestPrefillTag>>,
4414 #[serde(
4415 default,
4416 skip_serializing_if = "Option::is_none",
4417 deserialize_with = "double_option"
4418 )]
4419 pub days_valid: Option<Option<i64>>,
4420 #[serde(
4421 default,
4422 skip_serializing_if = "Option::is_none",
4423 deserialize_with = "double_option"
4424 )]
4425 pub external_id: Option<Option<String>>,
4426 #[serde(
4427 default,
4428 skip_serializing_if = "Option::is_none",
4429 deserialize_with = "double_option"
4430 )]
4431 pub template_id: Option<Option<String>>,
4432 #[serde(
4433 default,
4434 skip_serializing_if = "Option::is_none",
4435 deserialize_with = "double_option"
4436 )]
4437 pub external_system_name: Option<Option<String>>,
4438 #[serde(
4439 default,
4440 skip_serializing_if = "Option::is_none",
4441 deserialize_with = "double_option"
4442 )]
4443 pub request_flow: Option<Option<String>>,
4444}
4445
4446#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4447pub struct SignRequestCancelRequest {
4448 #[serde(default, skip_serializing_if = "Option::is_none")]
4449 pub reason: Option<String>,
4450}
4451
4452#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4453pub struct SignRequestCreateRequest {
4454 #[serde(default, skip_serializing_if = "Option::is_none")]
4455 pub is_document_preparation_needed: Option<bool>,
4456 #[serde(
4457 default,
4458 skip_serializing_if = "Option::is_none",
4459 deserialize_with = "double_option"
4460 )]
4461 pub redirect_url: Option<Option<String>>,
4462 #[serde(
4463 default,
4464 skip_serializing_if = "Option::is_none",
4465 deserialize_with = "double_option"
4466 )]
4467 pub declined_redirect_url: Option<Option<String>>,
4468 #[serde(default, skip_serializing_if = "Option::is_none")]
4469 pub are_text_signatures_enabled: Option<bool>,
4470 #[serde(
4471 default,
4472 skip_serializing_if = "Option::is_none",
4473 deserialize_with = "double_option"
4474 )]
4475 pub email_subject: Option<Option<String>>,
4476 #[serde(
4477 default,
4478 skip_serializing_if = "Option::is_none",
4479 deserialize_with = "double_option"
4480 )]
4481 pub email_message: Option<Option<String>>,
4482 #[serde(default, skip_serializing_if = "Option::is_none")]
4483 pub are_reminders_enabled: Option<bool>,
4484 #[serde(default, skip_serializing_if = "Option::is_none")]
4485 pub name: Option<String>,
4486 #[serde(default, skip_serializing_if = "Option::is_none")]
4487 pub prefill_tags: Option<Vec<SignRequestPrefillTag>>,
4488 #[serde(
4489 default,
4490 skip_serializing_if = "Option::is_none",
4491 deserialize_with = "double_option"
4492 )]
4493 pub days_valid: Option<Option<i64>>,
4494 #[serde(
4495 default,
4496 skip_serializing_if = "Option::is_none",
4497 deserialize_with = "double_option"
4498 )]
4499 pub external_id: Option<Option<String>>,
4500 #[serde(
4501 default,
4502 skip_serializing_if = "Option::is_none",
4503 deserialize_with = "double_option"
4504 )]
4505 pub template_id: Option<Option<String>>,
4506 #[serde(
4507 default,
4508 skip_serializing_if = "Option::is_none",
4509 deserialize_with = "double_option"
4510 )]
4511 pub external_system_name: Option<Option<String>>,
4512 #[serde(
4513 default,
4514 skip_serializing_if = "Option::is_none",
4515 deserialize_with = "double_option"
4516 )]
4517 pub request_flow: Option<Option<String>>,
4518 #[serde(
4519 default,
4520 skip_serializing_if = "Option::is_none",
4521 deserialize_with = "double_option"
4522 )]
4523 pub source_files: Option<Option<Vec<FileBase>>>,
4524 #[serde(
4525 default,
4526 skip_serializing_if = "Option::is_none",
4527 deserialize_with = "double_option"
4528 )]
4529 pub signature_color: Option<Option<SignRequestCreateRequestSignatureColor>>,
4530 pub signers: Vec<SignRequestCreateSigner>,
4531 #[serde(default, skip_serializing_if = "Option::is_none")]
4532 pub parent_folder: Option<FolderMini>,
4533}
4534
4535#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4536pub struct SignRequestCreateSigner {
4537 #[serde(
4538 default,
4539 skip_serializing_if = "Option::is_none",
4540 deserialize_with = "double_option"
4541 )]
4542 pub email: Option<Option<String>>,
4543 #[serde(default, skip_serializing_if = "Option::is_none")]
4544 pub role: Option<SignRequestCreateSignerRole>,
4545 #[serde(default, skip_serializing_if = "Option::is_none")]
4546 pub is_in_person: Option<bool>,
4547 #[serde(default, skip_serializing_if = "Option::is_none")]
4548 pub order: Option<i64>,
4549 #[serde(
4550 default,
4551 skip_serializing_if = "Option::is_none",
4552 deserialize_with = "double_option"
4553 )]
4554 pub embed_url_external_user_id: Option<Option<String>>,
4555 #[serde(
4556 default,
4557 skip_serializing_if = "Option::is_none",
4558 deserialize_with = "double_option"
4559 )]
4560 pub redirect_url: Option<Option<String>>,
4561 #[serde(
4562 default,
4563 skip_serializing_if = "Option::is_none",
4564 deserialize_with = "double_option"
4565 )]
4566 pub declined_redirect_url: Option<Option<String>>,
4567 #[serde(
4568 default,
4569 skip_serializing_if = "Option::is_none",
4570 deserialize_with = "double_option"
4571 )]
4572 pub login_required: Option<Option<bool>>,
4573 #[serde(
4574 default,
4575 skip_serializing_if = "Option::is_none",
4576 deserialize_with = "double_option"
4577 )]
4578 pub verification_phone_number: Option<Option<String>>,
4579 #[serde(
4580 default,
4581 skip_serializing_if = "Option::is_none",
4582 deserialize_with = "double_option"
4583 )]
4584 pub password: Option<Option<String>>,
4585 #[serde(
4586 default,
4587 skip_serializing_if = "Option::is_none",
4588 deserialize_with = "double_option"
4589 )]
4590 pub signer_group_id: Option<Option<String>>,
4591 #[serde(
4592 default,
4593 skip_serializing_if = "Option::is_none",
4594 deserialize_with = "double_option"
4595 )]
4596 pub suppress_notifications: Option<Option<bool>>,
4597 #[serde(
4598 default,
4599 skip_serializing_if = "Option::is_none",
4600 deserialize_with = "double_option"
4601 )]
4602 pub language: Option<Option<String>>,
4603}
4604
4605#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4606pub struct SignRequestPrefillTag {
4607 #[serde(
4608 default,
4609 skip_serializing_if = "Option::is_none",
4610 deserialize_with = "double_option"
4611 )]
4612 pub document_tag_id: Option<Option<String>>,
4613 #[serde(
4614 default,
4615 skip_serializing_if = "Option::is_none",
4616 deserialize_with = "double_option"
4617 )]
4618 pub text_value: Option<Option<String>>,
4619 #[serde(
4620 default,
4621 skip_serializing_if = "Option::is_none",
4622 deserialize_with = "double_option"
4623 )]
4624 pub checkbox_value: Option<Option<bool>>,
4625 #[serde(
4626 default,
4627 skip_serializing_if = "Option::is_none",
4628 deserialize_with = "double_option"
4629 )]
4630 pub date_value: Option<Option<chrono::NaiveDate>>,
4631}
4632
4633#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4634pub struct SignRequests {
4635 #[serde(default, skip_serializing_if = "Option::is_none")]
4636 pub limit: Option<i64>,
4637 #[serde(
4638 default,
4639 skip_serializing_if = "Option::is_none",
4640 deserialize_with = "double_option"
4641 )]
4642 pub next_marker: Option<Option<String>>,
4643 #[serde(default, skip_serializing_if = "Option::is_none")]
4644 pub entries: Option<Vec<SignRequest>>,
4645}
4646
4647#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4648pub struct SignRequestSigner {
4649 pub email: Option<String>,
4650 #[serde(default, skip_serializing_if = "Option::is_none")]
4651 pub role: Option<SignRequestCreateSignerRole>,
4652 #[serde(default, skip_serializing_if = "Option::is_none")]
4653 pub is_in_person: Option<bool>,
4654 #[serde(default, skip_serializing_if = "Option::is_none")]
4655 pub order: Option<i64>,
4656 #[serde(
4657 default,
4658 skip_serializing_if = "Option::is_none",
4659 deserialize_with = "double_option"
4660 )]
4661 pub embed_url_external_user_id: Option<Option<String>>,
4662 #[serde(
4663 default,
4664 skip_serializing_if = "Option::is_none",
4665 deserialize_with = "double_option"
4666 )]
4667 pub redirect_url: Option<Option<String>>,
4668 #[serde(
4669 default,
4670 skip_serializing_if = "Option::is_none",
4671 deserialize_with = "double_option"
4672 )]
4673 pub declined_redirect_url: Option<Option<String>>,
4674 #[serde(
4675 default,
4676 skip_serializing_if = "Option::is_none",
4677 deserialize_with = "double_option"
4678 )]
4679 pub login_required: Option<Option<bool>>,
4680 #[serde(
4681 default,
4682 skip_serializing_if = "Option::is_none",
4683 deserialize_with = "double_option"
4684 )]
4685 pub verification_phone_number: Option<Option<String>>,
4686 #[serde(
4687 default,
4688 skip_serializing_if = "Option::is_none",
4689 deserialize_with = "double_option"
4690 )]
4691 pub password: Option<Option<String>>,
4692 #[serde(
4693 default,
4694 skip_serializing_if = "Option::is_none",
4695 deserialize_with = "double_option"
4696 )]
4697 pub signer_group_id: Option<Option<String>>,
4698 #[serde(
4699 default,
4700 skip_serializing_if = "Option::is_none",
4701 deserialize_with = "double_option"
4702 )]
4703 pub suppress_notifications: Option<Option<bool>>,
4704 #[serde(
4705 default,
4706 skip_serializing_if = "Option::is_none",
4707 deserialize_with = "double_option"
4708 )]
4709 pub language: Option<Option<String>>,
4710 #[serde(default, skip_serializing_if = "Option::is_none")]
4711 pub has_viewed_document: Option<bool>,
4712 #[serde(
4713 default,
4714 skip_serializing_if = "Option::is_none",
4715 deserialize_with = "double_option"
4716 )]
4717 pub signer_decision: Option<Option<SignRequestSignerSignerDecision>>,
4718 #[serde(default, skip_serializing_if = "Option::is_none")]
4719 pub inputs: Option<Vec<SignRequestSignerInput>>,
4720 #[serde(
4721 default,
4722 skip_serializing_if = "Option::is_none",
4723 deserialize_with = "double_option"
4724 )]
4725 pub embed_url: Option<Option<String>>,
4726 #[serde(
4727 default,
4728 skip_serializing_if = "Option::is_none",
4729 deserialize_with = "double_option"
4730 )]
4731 pub iframeable_embed_url: Option<Option<String>>,
4732 #[serde(
4733 default,
4734 skip_serializing_if = "Option::is_none",
4735 deserialize_with = "double_option"
4736 )]
4737 pub attachments: Option<Option<Vec<SignRequestSignerAttachment>>>,
4738}
4739
4740#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4741pub struct SignRequestSignerAttachment {
4742 #[serde(
4743 default,
4744 skip_serializing_if = "Option::is_none",
4745 deserialize_with = "double_option"
4746 )]
4747 pub id: Option<Option<String>>,
4748 #[serde(
4749 default,
4750 skip_serializing_if = "Option::is_none",
4751 deserialize_with = "double_option"
4752 )]
4753 pub name: Option<Option<String>>,
4754}
4755
4756#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4757pub struct SignRequestSignerInput {
4758 #[serde(
4759 default,
4760 skip_serializing_if = "Option::is_none",
4761 deserialize_with = "double_option"
4762 )]
4763 pub document_tag_id: Option<Option<String>>,
4764 #[serde(
4765 default,
4766 skip_serializing_if = "Option::is_none",
4767 deserialize_with = "double_option"
4768 )]
4769 pub text_value: Option<Option<String>>,
4770 #[serde(
4771 default,
4772 skip_serializing_if = "Option::is_none",
4773 deserialize_with = "double_option"
4774 )]
4775 pub checkbox_value: Option<Option<bool>>,
4776 #[serde(
4777 default,
4778 skip_serializing_if = "Option::is_none",
4779 deserialize_with = "double_option"
4780 )]
4781 pub date_value: Option<Option<chrono::NaiveDate>>,
4782 #[serde(default, skip_serializing_if = "Option::is_none")]
4783 pub r#type: Option<SignRequestSignerInputType>,
4784 #[serde(default, skip_serializing_if = "Option::is_none")]
4785 pub content_type: Option<SignRequestSignerInputContentType>,
4786 pub page_index: i64,
4787 #[serde(default, skip_serializing_if = "Option::is_none")]
4788 pub read_only: Option<bool>,
4789 #[serde(default, skip_serializing_if = "Option::is_none")]
4790 pub validation: Option<SignRequestSignerInputValidation2>,
4791 #[serde(
4792 default,
4793 skip_serializing_if = "Option::is_none",
4794 deserialize_with = "double_option"
4795 )]
4796 pub reason: Option<Option<String>>,
4797 #[serde(
4798 default,
4799 skip_serializing_if = "Option::is_none",
4800 deserialize_with = "double_option"
4801 )]
4802 pub is_validated: Option<Option<bool>>,
4803}
4804
4805#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4806pub struct SignRequestSignerInputCustomValidation {
4807 pub validation_type: SignRequestSignerInputCustomValidationValidationType,
4808 pub custom_regex: Option<String>,
4809 pub custom_error_message: Option<String>,
4810}
4811
4812#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4813pub struct SignRequestSignerInputDateAsiaValidation {
4814 #[serde(default, skip_serializing_if = "Option::is_none")]
4815 pub validation_type: Option<SignRequestSignerInputDateAsiaValidationValidationType>,
4816}
4817
4818#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4819pub struct SignRequestSignerInputDateEUValidation {
4820 #[serde(default, skip_serializing_if = "Option::is_none")]
4821 pub validation_type: Option<SignRequestSignerInputDateEUValidationValidationType>,
4822}
4823
4824#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4825pub struct SignRequestSignerInputDateISOValidation {
4826 #[serde(default, skip_serializing_if = "Option::is_none")]
4827 pub validation_type: Option<SignRequestSignerInputDateISOValidationValidationType>,
4828}
4829
4830#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4831pub struct SignRequestSignerInputDateUSValidation {
4832 #[serde(default, skip_serializing_if = "Option::is_none")]
4833 pub validation_type: Option<SignRequestSignerInputDateUSValidationValidationType>,
4834}
4835
4836#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4837pub struct SignRequestSignerInputEmailValidation {
4838 pub validation_type: SignRequestSignerInputEmailValidationValidationType,
4839}
4840
4841#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4842pub struct SignRequestSignerInputNumberWithCommaValidation {
4843 #[serde(default, skip_serializing_if = "Option::is_none")]
4844 pub validation_type: Option<SignRequestSignerInputNumberWithCommaValidationValidationType>,
4845}
4846
4847#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4848pub struct SignRequestSignerInputNumberWithPeriodValidation {
4849 #[serde(default, skip_serializing_if = "Option::is_none")]
4850 pub validation_type: Option<SignRequestSignerInputNumberWithPeriodValidationValidationType>,
4851}
4852
4853#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4854pub struct SignRequestSignerInputSSNValidation {
4855 pub validation_type: SignRequestSignerInputSSNValidationValidationType,
4856}
4857
4858#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4859#[serde(transparent)]
4860pub struct SignRequestSignerInputValidation(pub serde_json::Value);
4861
4862#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4863pub struct SignRequestSignerInputZIP4Validation {
4864 pub validation_type: SignRequestSignerInputZIP4ValidationValidationType,
4865}
4866
4867#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4868pub struct SignRequestSignerInputZIPValidation {
4869 pub validation_type: SignRequestSignerInputZIPValidationValidationType,
4870}
4871
4872#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4873pub struct SignTemplate {
4874 #[serde(default, skip_serializing_if = "Option::is_none")]
4875 pub r#type: Option<SignTemplateType>,
4876 #[serde(default, skip_serializing_if = "Option::is_none")]
4877 pub id: Option<String>,
4878 #[serde(
4879 default,
4880 skip_serializing_if = "Option::is_none",
4881 deserialize_with = "double_option"
4882 )]
4883 pub name: Option<Option<String>>,
4884 #[serde(
4885 default,
4886 skip_serializing_if = "Option::is_none",
4887 deserialize_with = "double_option"
4888 )]
4889 pub email_subject: Option<Option<String>>,
4890 #[serde(
4891 default,
4892 skip_serializing_if = "Option::is_none",
4893 deserialize_with = "double_option"
4894 )]
4895 pub email_message: Option<Option<String>>,
4896 #[serde(
4897 default,
4898 skip_serializing_if = "Option::is_none",
4899 deserialize_with = "double_option"
4900 )]
4901 pub days_valid: Option<Option<i64>>,
4902 #[serde(default, skip_serializing_if = "Option::is_none")]
4903 pub parent_folder: Option<FolderMini>,
4904 #[serde(default, skip_serializing_if = "Option::is_none")]
4905 pub source_files: Option<Vec<FileMini>>,
4906 #[serde(default, skip_serializing_if = "Option::is_none")]
4907 pub are_fields_locked: Option<bool>,
4908 #[serde(default, skip_serializing_if = "Option::is_none")]
4909 pub are_options_locked: Option<bool>,
4910 #[serde(default, skip_serializing_if = "Option::is_none")]
4911 pub are_recipients_locked: Option<bool>,
4912 #[serde(default, skip_serializing_if = "Option::is_none")]
4913 pub are_email_settings_locked: Option<bool>,
4914 #[serde(default, skip_serializing_if = "Option::is_none")]
4915 pub are_files_locked: Option<bool>,
4916 #[serde(default, skip_serializing_if = "Option::is_none")]
4917 pub signers: Option<Vec<TemplateSigner>>,
4918 #[serde(default, skip_serializing_if = "Option::is_none")]
4919 pub additional_info: Option<SignTemplateAdditionalInfo>,
4920 #[serde(
4921 default,
4922 skip_serializing_if = "Option::is_none",
4923 deserialize_with = "double_option"
4924 )]
4925 pub ready_sign_link: Option<Option<SignTemplateReadySignLink>>,
4926 #[serde(
4927 default,
4928 skip_serializing_if = "Option::is_none",
4929 deserialize_with = "double_option"
4930 )]
4931 pub custom_branding: Option<Option<SignTemplateCustomBranding>>,
4932 #[serde(
4933 default,
4934 skip_serializing_if = "Option::is_none",
4935 deserialize_with = "double_option"
4936 )]
4937 pub request_flow: Option<Option<String>>,
4938}
4939
4940#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4941pub struct SignTemplates {
4942 #[serde(default, skip_serializing_if = "Option::is_none")]
4943 pub limit: Option<i64>,
4944 #[serde(
4945 default,
4946 skip_serializing_if = "Option::is_none",
4947 deserialize_with = "double_option"
4948 )]
4949 pub next_marker: Option<Option<String>>,
4950 #[serde(
4951 default,
4952 skip_serializing_if = "Option::is_none",
4953 deserialize_with = "double_option"
4954 )]
4955 pub prev_marker: Option<Option<String>>,
4956 #[serde(default, skip_serializing_if = "Option::is_none")]
4957 pub entries: Option<Vec<SignTemplate>>,
4958}
4959
4960#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4961#[serde(transparent)]
4962pub struct SkillCard(pub serde_json::Value);
4963
4964#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4965pub struct SkillCardsMetadata {
4966 #[serde(rename = "$canEdit", default, skip_serializing_if = "Option::is_none")]
4967 pub can_edit: Option<bool>,
4968 #[serde(rename = "$id", default, skip_serializing_if = "Option::is_none")]
4969 pub id: Option<String>,
4970 #[serde(rename = "$parent", default, skip_serializing_if = "Option::is_none")]
4971 pub parent: Option<String>,
4972 #[serde(rename = "$scope", default, skip_serializing_if = "Option::is_none")]
4973 pub scope: Option<String>,
4974 #[serde(rename = "$template", default, skip_serializing_if = "Option::is_none")]
4975 pub template: Option<String>,
4976 #[serde(rename = "$type", default, skip_serializing_if = "Option::is_none")]
4977 pub r#type: Option<String>,
4978 #[serde(
4979 rename = "$typeVersion",
4980 default,
4981 skip_serializing_if = "Option::is_none"
4982 )]
4983 pub type_version: Option<i64>,
4984 #[serde(rename = "$version", default, skip_serializing_if = "Option::is_none")]
4985 pub version: Option<i64>,
4986 #[serde(default, skip_serializing_if = "Option::is_none")]
4987 pub cards: Option<Vec<SkillCard>>,
4988}
4989
4990#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
4991pub struct StatusSkillCard {
4992 #[serde(default, skip_serializing_if = "Option::is_none")]
4993 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
4994 pub r#type: KeywordSkillCardType,
4995 pub skill_card_type: StatusSkillCardSkillCardType,
4996 #[serde(default, skip_serializing_if = "Option::is_none")]
4997 pub skill_card_title: Option<KeywordSkillCardSkillCardTitle>,
4998 pub status: StatusSkillCardStatus,
4999 pub skill: KeywordSkillCardSkill,
5000 pub invocation: KeywordSkillCardInvocation,
5001}
5002
5003#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5004pub struct StoragePolicies {
5005 #[serde(default, skip_serializing_if = "Option::is_none")]
5006 pub limit: Option<i64>,
5007 #[serde(
5008 default,
5009 skip_serializing_if = "Option::is_none",
5010 deserialize_with = "double_option"
5011 )]
5012 pub next_marker: Option<Option<String>>,
5013 #[serde(
5014 default,
5015 skip_serializing_if = "Option::is_none",
5016 deserialize_with = "double_option"
5017 )]
5018 pub prev_marker: Option<Option<String>>,
5019 #[serde(default, skip_serializing_if = "Option::is_none")]
5020 pub entries: Option<Vec<StoragePolicy>>,
5021}
5022
5023#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5024pub struct StoragePolicy {
5025 pub id: String,
5026 pub r#type: StoragePolicyType,
5027 #[serde(default, skip_serializing_if = "Option::is_none")]
5028 pub name: Option<String>,
5029}
5030
5031#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5032pub struct StoragePolicyMini {
5033 pub id: String,
5034 pub r#type: StoragePolicyType,
5035}
5036
5037#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5038pub struct StoragePolicyAssignment {
5039 pub id: String,
5040 pub r#type: StoragePolicyAssignmentType,
5041 #[serde(default, skip_serializing_if = "Option::is_none")]
5042 pub storage_policy: Option<StoragePolicyMini>,
5043 #[serde(default, skip_serializing_if = "Option::is_none")]
5044 pub assigned_to: Option<CommentItem>,
5045}
5046
5047#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5048pub struct StoragePolicyAssignments {
5049 #[serde(default, skip_serializing_if = "Option::is_none")]
5050 pub limit: Option<i64>,
5051 #[serde(
5052 default,
5053 skip_serializing_if = "Option::is_none",
5054 deserialize_with = "double_option"
5055 )]
5056 pub next_marker: Option<Option<String>>,
5057 #[serde(
5058 default,
5059 skip_serializing_if = "Option::is_none",
5060 deserialize_with = "double_option"
5061 )]
5062 pub prev_marker: Option<Option<String>>,
5063 #[serde(default, skip_serializing_if = "Option::is_none")]
5064 pub entries: Option<Vec<StoragePolicyAssignment>>,
5065}
5066
5067#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5068pub struct Task {
5069 #[serde(default, skip_serializing_if = "Option::is_none")]
5070 pub id: Option<String>,
5071 #[serde(default, skip_serializing_if = "Option::is_none")]
5072 pub r#type: Option<TaskType>,
5073 #[serde(default, skip_serializing_if = "Option::is_none")]
5074 pub item: Option<FileMini>,
5075 #[serde(default, skip_serializing_if = "Option::is_none")]
5076 pub due_at: Option<chrono::DateTime<chrono::Utc>>,
5077 #[serde(default, skip_serializing_if = "Option::is_none")]
5078 pub action: Option<TaskAction>,
5079 #[serde(default, skip_serializing_if = "Option::is_none")]
5080 pub message: Option<String>,
5081 #[serde(default, skip_serializing_if = "Option::is_none")]
5082 pub task_assignment_collection: Option<TaskAssignments>,
5083 #[serde(default, skip_serializing_if = "Option::is_none")]
5084 pub is_completed: Option<bool>,
5085 #[serde(default, skip_serializing_if = "Option::is_none")]
5086 pub created_by: Option<UserMini>,
5087 #[serde(default, skip_serializing_if = "Option::is_none")]
5088 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
5089 #[serde(default, skip_serializing_if = "Option::is_none")]
5090 pub completion_rule: Option<TaskCompletionRule>,
5091}
5092
5093#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5094pub struct TaskAssignment {
5095 #[serde(default, skip_serializing_if = "Option::is_none")]
5096 pub id: Option<String>,
5097 #[serde(default, skip_serializing_if = "Option::is_none")]
5098 pub r#type: Option<TaskAssignmentType>,
5099 #[serde(default, skip_serializing_if = "Option::is_none")]
5100 pub item: Option<FileMini>,
5101 #[serde(default, skip_serializing_if = "Option::is_none")]
5102 pub assigned_to: Option<UserMini>,
5103 #[serde(default, skip_serializing_if = "Option::is_none")]
5104 pub message: Option<String>,
5105 #[serde(default, skip_serializing_if = "Option::is_none")]
5106 pub completed_at: Option<chrono::DateTime<chrono::Utc>>,
5107 #[serde(default, skip_serializing_if = "Option::is_none")]
5108 pub assigned_at: Option<chrono::DateTime<chrono::Utc>>,
5109 #[serde(default, skip_serializing_if = "Option::is_none")]
5110 pub reminded_at: Option<chrono::DateTime<chrono::Utc>>,
5111 #[serde(default, skip_serializing_if = "Option::is_none")]
5112 pub resolution_state: Option<TaskAssignmentResolutionState>,
5113 #[serde(default, skip_serializing_if = "Option::is_none")]
5114 pub assigned_by: Option<UserMini>,
5115}
5116
5117#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5118pub struct TaskAssignments {
5119 #[serde(default, skip_serializing_if = "Option::is_none")]
5120 pub total_count: Option<i64>,
5121 #[serde(default, skip_serializing_if = "Option::is_none")]
5122 pub entries: Option<Vec<TaskAssignment>>,
5123}
5124
5125#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5126pub struct Tasks {
5127 #[serde(default, skip_serializing_if = "Option::is_none")]
5128 pub total_count: Option<i64>,
5129 #[serde(default, skip_serializing_if = "Option::is_none")]
5130 pub entries: Option<Vec<Task>>,
5131}
5132
5133#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5134pub struct TemplateSigner {
5135 #[serde(default, skip_serializing_if = "Option::is_none")]
5136 pub inputs: Option<Vec<TemplateSignerInput>>,
5137 #[serde(
5138 default,
5139 skip_serializing_if = "Option::is_none",
5140 deserialize_with = "double_option"
5141 )]
5142 pub email: Option<Option<String>>,
5143 #[serde(default, skip_serializing_if = "Option::is_none")]
5144 pub role: Option<SignRequestCreateSignerRole>,
5145 #[serde(default, skip_serializing_if = "Option::is_none")]
5146 pub is_in_person: Option<bool>,
5147 #[serde(default, skip_serializing_if = "Option::is_none")]
5148 pub order: Option<i64>,
5149 #[serde(
5150 default,
5151 skip_serializing_if = "Option::is_none",
5152 deserialize_with = "double_option"
5153 )]
5154 pub signer_group_id: Option<Option<String>>,
5155 #[serde(
5156 default,
5157 skip_serializing_if = "Option::is_none",
5158 deserialize_with = "double_option"
5159 )]
5160 pub label: Option<Option<String>>,
5161 #[serde(default, skip_serializing_if = "Option::is_none")]
5162 pub public_id: Option<String>,
5163 #[serde(
5164 default,
5165 skip_serializing_if = "Option::is_none",
5166 deserialize_with = "double_option"
5167 )]
5168 pub is_password_required: Option<Option<bool>>,
5169 #[serde(
5170 default,
5171 skip_serializing_if = "Option::is_none",
5172 deserialize_with = "double_option"
5173 )]
5174 pub is_phone_number_required: Option<Option<bool>>,
5175 #[serde(
5176 default,
5177 skip_serializing_if = "Option::is_none",
5178 deserialize_with = "double_option"
5179 )]
5180 pub login_required: Option<Option<bool>>,
5181}
5182
5183#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5184pub struct TemplateSignerInput {
5185 #[serde(
5186 default,
5187 skip_serializing_if = "Option::is_none",
5188 deserialize_with = "double_option"
5189 )]
5190 pub document_tag_id: Option<Option<String>>,
5191 #[serde(
5192 default,
5193 skip_serializing_if = "Option::is_none",
5194 deserialize_with = "double_option"
5195 )]
5196 pub text_value: Option<Option<String>>,
5197 #[serde(
5198 default,
5199 skip_serializing_if = "Option::is_none",
5200 deserialize_with = "double_option"
5201 )]
5202 pub checkbox_value: Option<Option<bool>>,
5203 #[serde(
5204 default,
5205 skip_serializing_if = "Option::is_none",
5206 deserialize_with = "double_option"
5207 )]
5208 pub date_value: Option<Option<chrono::NaiveDate>>,
5209 #[serde(default, skip_serializing_if = "Option::is_none")]
5210 pub r#type: Option<TemplateSignerInputType>,
5211 #[serde(default, skip_serializing_if = "Option::is_none")]
5212 pub content_type: Option<SignRequestSignerInputContentType>,
5213 #[serde(default, skip_serializing_if = "Option::is_none")]
5214 pub is_required: Option<bool>,
5215 pub page_index: i64,
5216 #[serde(
5217 default,
5218 skip_serializing_if = "Option::is_none",
5219 deserialize_with = "double_option"
5220 )]
5221 pub document_id: Option<Option<String>>,
5222 #[serde(
5223 default,
5224 skip_serializing_if = "Option::is_none",
5225 deserialize_with = "double_option"
5226 )]
5227 pub dropdown_choices: Option<Option<Vec<String>>>,
5228 #[serde(
5229 default,
5230 skip_serializing_if = "Option::is_none",
5231 deserialize_with = "double_option"
5232 )]
5233 pub group_id: Option<Option<String>>,
5234 #[serde(default, skip_serializing_if = "Option::is_none")]
5235 pub coordinates: Option<TemplateSignerInputCoordinates>,
5236 #[serde(default, skip_serializing_if = "Option::is_none")]
5237 pub dimensions: Option<TemplateSignerInputDimensions>,
5238 #[serde(
5239 default,
5240 skip_serializing_if = "Option::is_none",
5241 deserialize_with = "double_option"
5242 )]
5243 pub label: Option<Option<String>>,
5244 #[serde(default, skip_serializing_if = "Option::is_none")]
5245 pub read_only: Option<bool>,
5246 #[serde(default, skip_serializing_if = "Option::is_none")]
5247 pub validation: Option<SignRequestSignerInputValidation2>,
5248}
5249
5250#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5251pub struct TermsOfService {
5252 pub id: String,
5253 pub r#type: TermsOfServiceType,
5254 #[serde(default, skip_serializing_if = "Option::is_none")]
5255 pub status: Option<TermsOfServiceStatus>,
5256 #[serde(default, skip_serializing_if = "Option::is_none")]
5257 pub enterprise: Option<CollaborationAllowlistEntryEnterprise>,
5258 #[serde(default, skip_serializing_if = "Option::is_none")]
5259 pub tos_type: Option<TermsOfServiceTosType>,
5260 #[serde(default, skip_serializing_if = "Option::is_none")]
5261 pub text: Option<String>,
5262 #[serde(default, skip_serializing_if = "Option::is_none")]
5263 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
5264 #[serde(default, skip_serializing_if = "Option::is_none")]
5265 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
5266}
5267
5268#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5269pub struct TermsOfServiceBase {
5270 pub id: String,
5271 pub r#type: TermsOfServiceType,
5272}
5273
5274#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5275pub struct TermsOfServices {
5276 #[serde(default, skip_serializing_if = "Option::is_none")]
5277 pub total_count: Option<i64>,
5278 #[serde(default, skip_serializing_if = "Option::is_none")]
5279 pub entries: Option<Vec<TermsOfService>>,
5280}
5281
5282#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5283pub struct TermsOfServiceUserStatus {
5284 pub id: String,
5285 pub r#type: TermsOfServiceUserStatusType,
5286 #[serde(default, skip_serializing_if = "Option::is_none")]
5287 pub tos: Option<TermsOfServiceBase>,
5288 #[serde(default, skip_serializing_if = "Option::is_none")]
5289 pub user: Option<UserMini>,
5290 #[serde(default, skip_serializing_if = "Option::is_none")]
5291 pub is_accepted: Option<bool>,
5292 #[serde(default, skip_serializing_if = "Option::is_none")]
5293 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
5294 #[serde(default, skip_serializing_if = "Option::is_none")]
5295 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
5296}
5297
5298#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5299pub struct TermsOfServiceUserStatuses {
5300 #[serde(default, skip_serializing_if = "Option::is_none")]
5301 pub total_count: Option<i64>,
5302 #[serde(default, skip_serializing_if = "Option::is_none")]
5303 pub entries: Option<Vec<TermsOfServiceUserStatus>>,
5304}
5305
5306#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5307pub struct TimelineSkillCard {
5308 #[serde(default, skip_serializing_if = "Option::is_none")]
5309 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
5310 pub r#type: KeywordSkillCardType,
5311 pub skill_card_type: TimelineSkillCardSkillCardType,
5312 #[serde(default, skip_serializing_if = "Option::is_none")]
5313 pub skill_card_title: Option<KeywordSkillCardSkillCardTitle>,
5314 pub skill: KeywordSkillCardSkill,
5315 pub invocation: KeywordSkillCardInvocation,
5316 #[serde(default, skip_serializing_if = "Option::is_none")]
5317 pub duration: Option<i64>,
5318 pub entries: Vec<TimelineSkillCardEntries>,
5319}
5320
5321#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5322pub struct TrackingCode {
5323 #[serde(default, skip_serializing_if = "Option::is_none")]
5324 pub r#type: Option<TrackingCodeType>,
5325 #[serde(default, skip_serializing_if = "Option::is_none")]
5326 pub name: Option<String>,
5327 #[serde(default, skip_serializing_if = "Option::is_none")]
5328 pub value: Option<String>,
5329}
5330
5331#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5332pub struct TranscriptSkillCard {
5333 #[serde(default, skip_serializing_if = "Option::is_none")]
5334 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
5335 pub r#type: KeywordSkillCardType,
5336 pub skill_card_type: TranscriptSkillCardSkillCardType,
5337 #[serde(default, skip_serializing_if = "Option::is_none")]
5338 pub skill_card_title: Option<KeywordSkillCardSkillCardTitle>,
5339 pub skill: KeywordSkillCardSkill,
5340 pub invocation: KeywordSkillCardInvocation,
5341 #[serde(default, skip_serializing_if = "Option::is_none")]
5342 pub duration: Option<i64>,
5343 pub entries: Vec<TranscriptSkillCardEntries>,
5344}
5345
5346#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5347pub struct TrashFile {
5348 pub id: String,
5349 #[serde(
5350 default,
5351 skip_serializing_if = "Option::is_none",
5352 deserialize_with = "double_option"
5353 )]
5354 pub etag: Option<Option<String>>,
5355 pub r#type: AiCitationType,
5356 pub sequence_id: String,
5357 #[serde(default, skip_serializing_if = "Option::is_none")]
5358 pub name: Option<String>,
5359 pub sha1: String,
5360 #[serde(default, skip_serializing_if = "Option::is_none")]
5361 pub file_version: Option<FileVersionMini>,
5362 pub description: String,
5363 pub size: i64,
5364 pub path_collection: TrashFilePathCollection,
5365 pub created_at: chrono::DateTime<chrono::Utc>,
5366 pub modified_at: chrono::DateTime<chrono::Utc>,
5367 #[serde(
5368 default,
5369 skip_serializing_if = "Option::is_none",
5370 deserialize_with = "double_option"
5371 )]
5372 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5373 #[serde(
5374 default,
5375 skip_serializing_if = "Option::is_none",
5376 deserialize_with = "double_option"
5377 )]
5378 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5379 #[serde(
5380 default,
5381 skip_serializing_if = "Option::is_none",
5382 deserialize_with = "double_option"
5383 )]
5384 pub content_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 content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5391 #[serde(default, skip_serializing_if = "Option::is_none")]
5392 pub created_by: Option<UserMini>,
5393 pub modified_by: UserMini,
5394 pub owned_by: UserMini,
5395 #[serde(
5396 default,
5397 skip_serializing_if = "Option::is_none",
5398 deserialize_with = "double_option"
5399 )]
5400 pub shared_link: Option<Option<String>>,
5401 #[serde(
5402 default,
5403 skip_serializing_if = "Option::is_none",
5404 deserialize_with = "double_option"
5405 )]
5406 pub parent: Option<Option<FolderMini>>,
5407 pub item_status: FileItemStatus,
5408}
5409
5410#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5411pub struct TrashFileRestored {
5412 pub id: String,
5413 #[serde(
5414 default,
5415 skip_serializing_if = "Option::is_none",
5416 deserialize_with = "double_option"
5417 )]
5418 pub etag: Option<Option<String>>,
5419 pub r#type: AiCitationType,
5420 pub sequence_id: String,
5421 #[serde(default, skip_serializing_if = "Option::is_none")]
5422 pub name: Option<String>,
5423 pub sha1: String,
5424 #[serde(default, skip_serializing_if = "Option::is_none")]
5425 pub file_version: Option<FileVersionMini>,
5426 pub description: String,
5427 pub size: i64,
5428 pub path_collection: FilePathCollection,
5429 pub created_at: chrono::DateTime<chrono::Utc>,
5430 pub modified_at: chrono::DateTime<chrono::Utc>,
5431 #[serde(
5432 default,
5433 skip_serializing_if = "Option::is_none",
5434 deserialize_with = "double_option"
5435 )]
5436 pub trashed_at: Option<Option<String>>,
5437 #[serde(
5438 default,
5439 skip_serializing_if = "Option::is_none",
5440 deserialize_with = "double_option"
5441 )]
5442 pub purged_at: Option<Option<String>>,
5443 #[serde(
5444 default,
5445 skip_serializing_if = "Option::is_none",
5446 deserialize_with = "double_option"
5447 )]
5448 pub content_created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5449 #[serde(
5450 default,
5451 skip_serializing_if = "Option::is_none",
5452 deserialize_with = "double_option"
5453 )]
5454 pub content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5455 #[serde(default, skip_serializing_if = "Option::is_none")]
5456 pub created_by: Option<UserMini>,
5457 pub modified_by: UserMini,
5458 pub owned_by: UserMini,
5459 #[serde(
5460 default,
5461 skip_serializing_if = "Option::is_none",
5462 deserialize_with = "double_option"
5463 )]
5464 pub shared_link: Option<Option<String>>,
5465 #[serde(
5466 default,
5467 skip_serializing_if = "Option::is_none",
5468 deserialize_with = "double_option"
5469 )]
5470 pub parent: Option<Option<FolderMini>>,
5471 pub item_status: FileItemStatus,
5472}
5473
5474#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5475pub struct TrashFolder {
5476 pub id: String,
5477 #[serde(
5478 default,
5479 skip_serializing_if = "Option::is_none",
5480 deserialize_with = "double_option"
5481 )]
5482 pub etag: Option<Option<String>>,
5483 pub r#type: FolderType,
5484 #[serde(default, skip_serializing_if = "Option::is_none")]
5485 pub sequence_id: Option<String>,
5486 pub name: String,
5487 #[serde(
5488 default,
5489 skip_serializing_if = "Option::is_none",
5490 deserialize_with = "double_option"
5491 )]
5492 pub created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5493 #[serde(
5494 default,
5495 skip_serializing_if = "Option::is_none",
5496 deserialize_with = "double_option"
5497 )]
5498 pub modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5499 pub description: String,
5500 pub size: i64,
5501 pub path_collection: TrashFilePathCollection,
5502 pub created_by: UserMini,
5503 pub modified_by: UserMini,
5504 #[serde(
5505 default,
5506 skip_serializing_if = "Option::is_none",
5507 deserialize_with = "double_option"
5508 )]
5509 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5510 #[serde(
5511 default,
5512 skip_serializing_if = "Option::is_none",
5513 deserialize_with = "double_option"
5514 )]
5515 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5516 #[serde(
5517 default,
5518 skip_serializing_if = "Option::is_none",
5519 deserialize_with = "double_option"
5520 )]
5521 pub content_created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5522 #[serde(
5523 default,
5524 skip_serializing_if = "Option::is_none",
5525 deserialize_with = "double_option"
5526 )]
5527 pub content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5528 pub owned_by: UserMini,
5529 #[serde(
5530 default,
5531 skip_serializing_if = "Option::is_none",
5532 deserialize_with = "double_option"
5533 )]
5534 pub shared_link: Option<Option<String>>,
5535 #[serde(
5536 default,
5537 skip_serializing_if = "Option::is_none",
5538 deserialize_with = "double_option"
5539 )]
5540 pub folder_upload_email: Option<Option<String>>,
5541 #[serde(
5542 default,
5543 skip_serializing_if = "Option::is_none",
5544 deserialize_with = "double_option"
5545 )]
5546 pub parent: Option<Option<FolderMini>>,
5547 pub item_status: FileItemStatus,
5548}
5549
5550#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5551pub struct TrashFolderRestored {
5552 #[serde(default, skip_serializing_if = "Option::is_none")]
5553 pub id: Option<String>,
5554 #[serde(
5555 default,
5556 skip_serializing_if = "Option::is_none",
5557 deserialize_with = "double_option"
5558 )]
5559 pub etag: Option<Option<String>>,
5560 #[serde(default, skip_serializing_if = "Option::is_none")]
5561 pub r#type: Option<FolderType>,
5562 #[serde(default, skip_serializing_if = "Option::is_none")]
5563 pub sequence_id: Option<String>,
5564 #[serde(default, skip_serializing_if = "Option::is_none")]
5565 pub name: Option<String>,
5566 #[serde(
5567 default,
5568 skip_serializing_if = "Option::is_none",
5569 deserialize_with = "double_option"
5570 )]
5571 pub created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5572 #[serde(
5573 default,
5574 skip_serializing_if = "Option::is_none",
5575 deserialize_with = "double_option"
5576 )]
5577 pub modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5578 #[serde(default, skip_serializing_if = "Option::is_none")]
5579 pub description: Option<String>,
5580 #[serde(default, skip_serializing_if = "Option::is_none")]
5581 pub size: Option<i64>,
5582 #[serde(default, skip_serializing_if = "Option::is_none")]
5583 pub path_collection: Option<FilePathCollection>,
5584 #[serde(default, skip_serializing_if = "Option::is_none")]
5585 pub created_by: Option<UserMini>,
5586 #[serde(default, skip_serializing_if = "Option::is_none")]
5587 pub modified_by: Option<UserMini>,
5588 #[serde(
5589 default,
5590 skip_serializing_if = "Option::is_none",
5591 deserialize_with = "double_option"
5592 )]
5593 pub trashed_at: Option<Option<String>>,
5594 #[serde(
5595 default,
5596 skip_serializing_if = "Option::is_none",
5597 deserialize_with = "double_option"
5598 )]
5599 pub purged_at: Option<Option<String>>,
5600 #[serde(
5601 default,
5602 skip_serializing_if = "Option::is_none",
5603 deserialize_with = "double_option"
5604 )]
5605 pub content_created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5606 #[serde(
5607 default,
5608 skip_serializing_if = "Option::is_none",
5609 deserialize_with = "double_option"
5610 )]
5611 pub content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5612 #[serde(default, skip_serializing_if = "Option::is_none")]
5613 pub owned_by: Option<UserMini>,
5614 #[serde(
5615 default,
5616 skip_serializing_if = "Option::is_none",
5617 deserialize_with = "double_option"
5618 )]
5619 pub shared_link: Option<Option<String>>,
5620 #[serde(
5621 default,
5622 skip_serializing_if = "Option::is_none",
5623 deserialize_with = "double_option"
5624 )]
5625 pub folder_upload_email: Option<Option<String>>,
5626 #[serde(
5627 default,
5628 skip_serializing_if = "Option::is_none",
5629 deserialize_with = "double_option"
5630 )]
5631 pub parent: Option<Option<FolderMini>>,
5632 #[serde(default, skip_serializing_if = "Option::is_none")]
5633 pub item_status: Option<FileItemStatus>,
5634}
5635
5636#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5637pub struct TrashWebLink {
5638 #[serde(default, skip_serializing_if = "Option::is_none")]
5639 pub r#type: Option<TrashWebLinkType>,
5640 #[serde(default, skip_serializing_if = "Option::is_none")]
5641 pub id: Option<String>,
5642 #[serde(default, skip_serializing_if = "Option::is_none")]
5643 pub sequence_id: Option<String>,
5644 #[serde(default, skip_serializing_if = "Option::is_none")]
5645 pub etag: Option<String>,
5646 #[serde(default, skip_serializing_if = "Option::is_none")]
5647 pub name: Option<String>,
5648 #[serde(default, skip_serializing_if = "Option::is_none")]
5649 pub url: Option<String>,
5650 #[serde(default, skip_serializing_if = "Option::is_none")]
5651 pub parent: Option<FolderMini>,
5652 #[serde(default, skip_serializing_if = "Option::is_none")]
5653 pub description: Option<String>,
5654 #[serde(default, skip_serializing_if = "Option::is_none")]
5655 pub path_collection: Option<TrashFilePathCollection>,
5656 #[serde(default, skip_serializing_if = "Option::is_none")]
5657 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
5658 #[serde(default, skip_serializing_if = "Option::is_none")]
5659 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
5660 #[serde(
5661 default,
5662 skip_serializing_if = "Option::is_none",
5663 deserialize_with = "double_option"
5664 )]
5665 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5666 #[serde(
5667 default,
5668 skip_serializing_if = "Option::is_none",
5669 deserialize_with = "double_option"
5670 )]
5671 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
5672 #[serde(default, skip_serializing_if = "Option::is_none")]
5673 pub created_by: Option<UserMini>,
5674 #[serde(default, skip_serializing_if = "Option::is_none")]
5675 pub modified_by: Option<UserMini>,
5676 #[serde(default, skip_serializing_if = "Option::is_none")]
5677 pub owned_by: Option<UserMini>,
5678 #[serde(
5679 default,
5680 skip_serializing_if = "Option::is_none",
5681 deserialize_with = "double_option"
5682 )]
5683 pub shared_link: Option<Option<String>>,
5684 #[serde(default, skip_serializing_if = "Option::is_none")]
5685 pub item_status: Option<FileItemStatus>,
5686}
5687
5688#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5689pub struct TrashWebLinkRestored {
5690 #[serde(default, skip_serializing_if = "Option::is_none")]
5691 pub r#type: Option<TrashWebLinkType>,
5692 #[serde(default, skip_serializing_if = "Option::is_none")]
5693 pub id: Option<String>,
5694 pub sequence_id: String,
5695 #[serde(default, skip_serializing_if = "Option::is_none")]
5696 pub etag: Option<String>,
5697 #[serde(default, skip_serializing_if = "Option::is_none")]
5698 pub name: Option<String>,
5699 #[serde(default, skip_serializing_if = "Option::is_none")]
5700 pub url: Option<String>,
5701 #[serde(default, skip_serializing_if = "Option::is_none")]
5702 pub parent: Option<FolderMini>,
5703 #[serde(default, skip_serializing_if = "Option::is_none")]
5704 pub description: Option<String>,
5705 pub path_collection: FilePathCollection,
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(
5711 default,
5712 skip_serializing_if = "Option::is_none",
5713 deserialize_with = "double_option"
5714 )]
5715 pub trashed_at: Option<Option<String>>,
5716 #[serde(
5717 default,
5718 skip_serializing_if = "Option::is_none",
5719 deserialize_with = "double_option"
5720 )]
5721 pub purged_at: Option<Option<String>>,
5722 #[serde(default, skip_serializing_if = "Option::is_none")]
5723 pub created_by: Option<UserMini>,
5724 #[serde(default, skip_serializing_if = "Option::is_none")]
5725 pub modified_by: Option<UserMini>,
5726 #[serde(default, skip_serializing_if = "Option::is_none")]
5727 pub owned_by: Option<UserMini>,
5728 #[serde(
5729 default,
5730 skip_serializing_if = "Option::is_none",
5731 deserialize_with = "double_option"
5732 )]
5733 pub shared_link: Option<Option<String>>,
5734 #[serde(default, skip_serializing_if = "Option::is_none")]
5735 pub item_status: Option<FileItemStatus>,
5736}
5737
5738#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5739pub struct UploadedPart {
5740 #[serde(default, skip_serializing_if = "Option::is_none")]
5741 pub part: Option<UploadPart>,
5742}
5743
5744#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5745pub struct UploadPart {
5746 #[serde(default, skip_serializing_if = "Option::is_none")]
5747 pub part_id: Option<String>,
5748 #[serde(default, skip_serializing_if = "Option::is_none")]
5749 pub offset: Option<i64>,
5750 #[serde(default, skip_serializing_if = "Option::is_none")]
5751 pub size: Option<i64>,
5752 #[serde(default, skip_serializing_if = "Option::is_none")]
5753 pub sha1: Option<String>,
5754}
5755
5756#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5757pub struct UploadPartMini {
5758 #[serde(default, skip_serializing_if = "Option::is_none")]
5759 pub part_id: Option<String>,
5760 #[serde(default, skip_serializing_if = "Option::is_none")]
5761 pub offset: Option<i64>,
5762 #[serde(default, skip_serializing_if = "Option::is_none")]
5763 pub size: Option<i64>,
5764}
5765
5766#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5767pub struct UploadParts {
5768 #[serde(default, skip_serializing_if = "Option::is_none")]
5769 pub total_count: Option<i64>,
5770 #[serde(default, skip_serializing_if = "Option::is_none")]
5771 pub limit: Option<i64>,
5772 #[serde(default, skip_serializing_if = "Option::is_none")]
5773 pub offset: Option<i64>,
5774 #[serde(default, skip_serializing_if = "Option::is_none")]
5775 pub order: Option<Vec<CollectionsOrder>>,
5776 #[serde(default, skip_serializing_if = "Option::is_none")]
5777 pub entries: Option<Vec<UploadPart>>,
5778}
5779
5780#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5781pub struct UploadSession {
5782 #[serde(default, skip_serializing_if = "Option::is_none")]
5783 pub id: Option<String>,
5784 #[serde(default, skip_serializing_if = "Option::is_none")]
5785 pub r#type: Option<UploadSessionType>,
5786 #[serde(default, skip_serializing_if = "Option::is_none")]
5787 pub session_expires_at: Option<chrono::DateTime<chrono::Utc>>,
5788 #[serde(default, skip_serializing_if = "Option::is_none")]
5789 pub part_size: Option<i64>,
5790 #[serde(default, skip_serializing_if = "Option::is_none")]
5791 pub total_parts: Option<i64>,
5792 #[serde(default, skip_serializing_if = "Option::is_none")]
5793 pub num_parts_processed: Option<i64>,
5794 #[serde(default, skip_serializing_if = "Option::is_none")]
5795 pub session_endpoints: Option<UploadSessionSessionEndpoints>,
5796}
5797
5798#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5799pub struct UploadUrl {
5800 #[serde(default, skip_serializing_if = "Option::is_none")]
5801 pub upload_url: Option<String>,
5802 #[serde(default, skip_serializing_if = "Option::is_none")]
5803 pub upload_token: Option<String>,
5804}
5805
5806#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5807pub struct User {
5808 pub id: String,
5809 pub r#type: VariableValueType,
5810 #[serde(default, skip_serializing_if = "Option::is_none")]
5811 pub name: Option<String>,
5812 #[serde(default, skip_serializing_if = "Option::is_none")]
5813 pub login: Option<String>,
5814 #[serde(default, skip_serializing_if = "Option::is_none")]
5815 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
5816 #[serde(default, skip_serializing_if = "Option::is_none")]
5817 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
5818 #[serde(default, skip_serializing_if = "Option::is_none")]
5819 pub language: Option<String>,
5820 #[serde(default, skip_serializing_if = "Option::is_none")]
5821 pub timezone: Option<String>,
5822 #[serde(default, skip_serializing_if = "Option::is_none")]
5823 pub space_amount: Option<i64>,
5824 #[serde(default, skip_serializing_if = "Option::is_none")]
5825 pub space_used: Option<i64>,
5826 #[serde(default, skip_serializing_if = "Option::is_none")]
5827 pub max_upload_size: Option<i64>,
5828 #[serde(default, skip_serializing_if = "Option::is_none")]
5829 pub status: Option<UserStatus>,
5830 #[serde(default, skip_serializing_if = "Option::is_none")]
5831 pub job_title: Option<String>,
5832 #[serde(default, skip_serializing_if = "Option::is_none")]
5833 pub phone: Option<String>,
5834 #[serde(default, skip_serializing_if = "Option::is_none")]
5835 pub address: Option<String>,
5836 #[serde(default, skip_serializing_if = "Option::is_none")]
5837 pub avatar_url: Option<String>,
5838 #[serde(
5839 default,
5840 skip_serializing_if = "Option::is_none",
5841 deserialize_with = "double_option"
5842 )]
5843 pub notification_email: Option<Option<UserNotificationEmail>>,
5844}
5845
5846#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5847pub struct UserBase {
5848 pub id: String,
5849 pub r#type: VariableValueType,
5850}
5851
5852#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5853pub struct UserCollaborations {
5854 pub id: String,
5855 pub r#type: VariableValueType,
5856 #[serde(default, skip_serializing_if = "Option::is_none")]
5857 pub name: Option<String>,
5858 #[serde(default, skip_serializing_if = "Option::is_none")]
5859 pub login: Option<String>,
5860 #[serde(default, skip_serializing_if = "Option::is_none")]
5861 pub is_active: Option<bool>,
5862}
5863
5864#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5865pub struct UserFull {
5866 pub id: String,
5867 pub r#type: VariableValueType,
5868 #[serde(default, skip_serializing_if = "Option::is_none")]
5869 pub name: Option<String>,
5870 #[serde(default, skip_serializing_if = "Option::is_none")]
5871 pub login: Option<String>,
5872 #[serde(default, skip_serializing_if = "Option::is_none")]
5873 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
5874 #[serde(default, skip_serializing_if = "Option::is_none")]
5875 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
5876 #[serde(default, skip_serializing_if = "Option::is_none")]
5877 pub language: Option<String>,
5878 #[serde(default, skip_serializing_if = "Option::is_none")]
5879 pub timezone: Option<String>,
5880 #[serde(default, skip_serializing_if = "Option::is_none")]
5881 pub space_amount: Option<i64>,
5882 #[serde(default, skip_serializing_if = "Option::is_none")]
5883 pub space_used: Option<i64>,
5884 #[serde(default, skip_serializing_if = "Option::is_none")]
5885 pub max_upload_size: Option<i64>,
5886 #[serde(default, skip_serializing_if = "Option::is_none")]
5887 pub status: Option<UserStatus>,
5888 #[serde(default, skip_serializing_if = "Option::is_none")]
5889 pub job_title: Option<String>,
5890 #[serde(default, skip_serializing_if = "Option::is_none")]
5891 pub phone: Option<String>,
5892 #[serde(default, skip_serializing_if = "Option::is_none")]
5893 pub address: Option<String>,
5894 #[serde(default, skip_serializing_if = "Option::is_none")]
5895 pub avatar_url: Option<String>,
5896 #[serde(
5897 default,
5898 skip_serializing_if = "Option::is_none",
5899 deserialize_with = "double_option"
5900 )]
5901 pub notification_email: Option<Option<UserNotificationEmail>>,
5902 #[serde(default, skip_serializing_if = "Option::is_none")]
5903 pub role: Option<UserFullRole>,
5904 #[serde(default, skip_serializing_if = "Option::is_none")]
5905 pub tracking_codes: Option<Vec<TrackingCode>>,
5906 #[serde(default, skip_serializing_if = "Option::is_none")]
5907 pub can_see_managed_users: Option<bool>,
5908 #[serde(default, skip_serializing_if = "Option::is_none")]
5909 pub is_sync_enabled: Option<bool>,
5910 #[serde(default, skip_serializing_if = "Option::is_none")]
5911 pub is_external_collab_restricted: Option<bool>,
5912 #[serde(default, skip_serializing_if = "Option::is_none")]
5913 pub is_exempt_from_device_limits: Option<bool>,
5914 #[serde(default, skip_serializing_if = "Option::is_none")]
5915 pub is_exempt_from_login_verification: Option<bool>,
5916 #[serde(default, skip_serializing_if = "Option::is_none")]
5917 pub enterprise: Option<CollaborationAllowlistEntryEnterprise>,
5918 #[serde(default, skip_serializing_if = "Option::is_none")]
5919 pub my_tags: Option<Vec<String>>,
5920 #[serde(default, skip_serializing_if = "Option::is_none")]
5921 pub hostname: Option<String>,
5922 #[serde(default, skip_serializing_if = "Option::is_none")]
5923 pub is_platform_access_only: Option<bool>,
5924 #[serde(default, skip_serializing_if = "Option::is_none")]
5925 pub external_app_user_id: Option<String>,
5926}
5927
5928#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5929pub struct UserMini {
5930 pub id: String,
5931 pub r#type: VariableValueType,
5932 #[serde(default, skip_serializing_if = "Option::is_none")]
5933 pub name: Option<String>,
5934 #[serde(default, skip_serializing_if = "Option::is_none")]
5935 pub login: Option<String>,
5936}
5937
5938#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5939pub struct UserAvatar {
5940 #[serde(default, skip_serializing_if = "Option::is_none")]
5941 pub pic_urls: Option<UserAvatarPicUrls>,
5942}
5943
5944#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5945pub struct UserIntegrationMappings {
5946 pub id: String,
5947 pub r#type: VariableValueType,
5948 #[serde(default, skip_serializing_if = "Option::is_none")]
5949 pub name: Option<String>,
5950 #[serde(default, skip_serializing_if = "Option::is_none")]
5951 pub login: Option<String>,
5952}
5953
5954#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5955pub struct Users {
5956 #[serde(default, skip_serializing_if = "Option::is_none")]
5957 pub limit: Option<i64>,
5958 #[serde(
5959 default,
5960 skip_serializing_if = "Option::is_none",
5961 deserialize_with = "double_option"
5962 )]
5963 pub next_marker: Option<Option<String>>,
5964 #[serde(
5965 default,
5966 skip_serializing_if = "Option::is_none",
5967 deserialize_with = "double_option"
5968 )]
5969 pub prev_marker: Option<Option<String>>,
5970 #[serde(default, skip_serializing_if = "Option::is_none")]
5971 pub total_count: Option<i64>,
5972 #[serde(default, skip_serializing_if = "Option::is_none")]
5973 pub offset: Option<i64>,
5974 #[serde(default, skip_serializing_if = "Option::is_none")]
5975 pub order: Option<Vec<CollectionsOrder>>,
5976 #[serde(default, skip_serializing_if = "Option::is_none")]
5977 pub entries: Option<Vec<UserFull>>,
5978}
5979
5980#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5981pub struct Watermark {
5982 #[serde(default, skip_serializing_if = "Option::is_none")]
5983 pub watermark: Option<WatermarkWatermark>,
5984}
5985
5986#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
5987pub struct Webhook {
5988 #[serde(default, skip_serializing_if = "Option::is_none")]
5989 pub id: Option<String>,
5990 #[serde(default, skip_serializing_if = "Option::is_none")]
5991 pub r#type: Option<WebhookType>,
5992 #[serde(default, skip_serializing_if = "Option::is_none")]
5993 pub target: Option<WebhookTarget>,
5994 #[serde(default, skip_serializing_if = "Option::is_none")]
5995 pub created_by: Option<UserMini>,
5996 #[serde(default, skip_serializing_if = "Option::is_none")]
5997 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
5998 #[serde(default, skip_serializing_if = "Option::is_none")]
5999 pub address: Option<String>,
6000 #[serde(default, skip_serializing_if = "Option::is_none")]
6001 pub triggers: Option<Vec<WebhookTriggers>>,
6002}
6003
6004#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6005pub struct WebhookMini {
6006 #[serde(default, skip_serializing_if = "Option::is_none")]
6007 pub id: Option<String>,
6008 #[serde(default, skip_serializing_if = "Option::is_none")]
6009 pub r#type: Option<WebhookType>,
6010 #[serde(default, skip_serializing_if = "Option::is_none")]
6011 pub target: Option<WebhookTarget>,
6012}
6013
6014#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6015pub struct Webhooks {
6016 #[serde(default, skip_serializing_if = "Option::is_none")]
6017 pub limit: Option<i64>,
6018 #[serde(
6019 default,
6020 skip_serializing_if = "Option::is_none",
6021 deserialize_with = "double_option"
6022 )]
6023 pub next_marker: Option<Option<String>>,
6024 #[serde(
6025 default,
6026 skip_serializing_if = "Option::is_none",
6027 deserialize_with = "double_option"
6028 )]
6029 pub prev_marker: Option<Option<String>>,
6030 #[serde(default, skip_serializing_if = "Option::is_none")]
6031 pub entries: Option<Vec<WebhookMini>>,
6032}
6033
6034#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6035pub struct WebLink {
6036 pub id: String,
6037 pub r#type: TrashWebLinkType,
6038 #[serde(default, skip_serializing_if = "Option::is_none")]
6039 pub etag: Option<String>,
6040 #[serde(default, skip_serializing_if = "Option::is_none")]
6041 pub url: Option<String>,
6042 #[serde(default, skip_serializing_if = "Option::is_none")]
6043 pub sequence_id: Option<String>,
6044 #[serde(default, skip_serializing_if = "Option::is_none")]
6045 pub name: Option<String>,
6046 #[serde(default, skip_serializing_if = "Option::is_none")]
6047 pub parent: Option<FolderMini>,
6048 #[serde(default, skip_serializing_if = "Option::is_none")]
6049 pub description: Option<String>,
6050 #[serde(default, skip_serializing_if = "Option::is_none")]
6051 pub path_collection: Option<FilePathCollection>,
6052 #[serde(default, skip_serializing_if = "Option::is_none")]
6053 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
6054 #[serde(default, skip_serializing_if = "Option::is_none")]
6055 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
6056 #[serde(
6057 default,
6058 skip_serializing_if = "Option::is_none",
6059 deserialize_with = "double_option"
6060 )]
6061 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
6062 #[serde(
6063 default,
6064 skip_serializing_if = "Option::is_none",
6065 deserialize_with = "double_option"
6066 )]
6067 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
6068 #[serde(default, skip_serializing_if = "Option::is_none")]
6069 pub created_by: Option<UserMini>,
6070 #[serde(default, skip_serializing_if = "Option::is_none")]
6071 pub modified_by: Option<UserMini>,
6072 #[serde(default, skip_serializing_if = "Option::is_none")]
6073 pub owned_by: Option<UserMini>,
6074 #[serde(
6075 default,
6076 skip_serializing_if = "Option::is_none",
6077 deserialize_with = "double_option"
6078 )]
6079 pub shared_link: Option<Option<FileSharedLink>>,
6080 #[serde(default, skip_serializing_if = "Option::is_none")]
6081 pub item_status: Option<FileItemStatus>,
6082}
6083
6084#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6085pub struct WebLinkBase {
6086 pub id: String,
6087 pub r#type: TrashWebLinkType,
6088 #[serde(default, skip_serializing_if = "Option::is_none")]
6089 pub etag: Option<String>,
6090}
6091
6092#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6093pub struct WebLinkMini {
6094 pub id: String,
6095 pub r#type: TrashWebLinkType,
6096 #[serde(default, skip_serializing_if = "Option::is_none")]
6097 pub etag: Option<String>,
6098 #[serde(default, skip_serializing_if = "Option::is_none")]
6099 pub url: Option<String>,
6100 #[serde(default, skip_serializing_if = "Option::is_none")]
6101 pub sequence_id: Option<String>,
6102 #[serde(default, skip_serializing_if = "Option::is_none")]
6103 pub name: Option<String>,
6104}
6105
6106#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6107pub struct Workflow {
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 r#type: Option<WorkflowType>,
6112 #[serde(default, skip_serializing_if = "Option::is_none")]
6113 pub name: Option<String>,
6114 #[serde(default, skip_serializing_if = "Option::is_none")]
6115 pub description: Option<String>,
6116 #[serde(default, skip_serializing_if = "Option::is_none")]
6117 pub is_enabled: Option<bool>,
6118 #[serde(default, skip_serializing_if = "Option::is_none")]
6119 pub flows: Option<Vec<WorkflowFlows>>,
6120}
6121
6122#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6123pub struct WorkflowMini {
6124 #[serde(default, skip_serializing_if = "Option::is_none")]
6125 pub id: Option<String>,
6126 #[serde(default, skip_serializing_if = "Option::is_none")]
6127 pub r#type: Option<WorkflowType>,
6128 #[serde(default, skip_serializing_if = "Option::is_none")]
6129 pub name: Option<String>,
6130 #[serde(default, skip_serializing_if = "Option::is_none")]
6131 pub description: Option<String>,
6132 #[serde(default, skip_serializing_if = "Option::is_none")]
6133 pub is_enabled: Option<bool>,
6134}
6135
6136#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6137pub struct Workflows {
6138 #[serde(default, skip_serializing_if = "Option::is_none")]
6139 pub limit: Option<i64>,
6140 #[serde(
6141 default,
6142 skip_serializing_if = "Option::is_none",
6143 deserialize_with = "double_option"
6144 )]
6145 pub next_marker: Option<Option<String>>,
6146 #[serde(
6147 default,
6148 skip_serializing_if = "Option::is_none",
6149 deserialize_with = "double_option"
6150 )]
6151 pub prev_marker: Option<Option<String>>,
6152 #[serde(default, skip_serializing_if = "Option::is_none")]
6153 pub entries: Option<Vec<Workflow>>,
6154}
6155
6156#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6157pub struct ZipDownload {
6158 #[serde(default, skip_serializing_if = "Option::is_none")]
6159 pub download_url: Option<String>,
6160 #[serde(default, skip_serializing_if = "Option::is_none")]
6161 pub status_url: Option<String>,
6162 #[serde(default, skip_serializing_if = "Option::is_none")]
6163 pub expires_at: Option<chrono::DateTime<chrono::Utc>>,
6164 #[serde(default, skip_serializing_if = "Option::is_none")]
6165 pub name_conflicts: Option<Vec<Vec<ZipDownloadNameConflicts>>>,
6166}
6167
6168#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6169pub struct ZipDownloadRequest {
6170 pub items: Vec<ZipDownloadRequestItems>,
6171 #[serde(default, skip_serializing_if = "Option::is_none")]
6172 pub download_file_name: Option<String>,
6173}
6174
6175#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6176pub struct ZipDownloadStatus {
6177 #[serde(default, skip_serializing_if = "Option::is_none")]
6178 pub total_file_count: Option<i64>,
6179 #[serde(default, skip_serializing_if = "Option::is_none")]
6180 pub downloaded_file_count: Option<i64>,
6181 #[serde(default, skip_serializing_if = "Option::is_none")]
6182 pub skipped_file_count: Option<i64>,
6183 #[serde(default, skip_serializing_if = "Option::is_none")]
6184 pub skipped_folder_count: Option<i64>,
6185 #[serde(default, skip_serializing_if = "Option::is_none")]
6186 pub state: Option<ZipDownloadStatusState>,
6187}
6188
6189#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6190#[serde(transparent)]
6191pub struct AccessTokenTokenType(pub String);
6192
6193impl AccessTokenTokenType {
6194 pub const BEARER: &'static str = "bearer";
6195}
6196
6197#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6198#[serde(transparent)]
6199pub struct AccessTokenIssuedTokenType(pub String);
6200
6201impl AccessTokenIssuedTokenType {
6202 pub const URN_IETF_PARAMS_OAUTH_TOKEN_TYPE_ACCESS_TOKEN: &'static str =
6203 "urn:ietf:params:oauth:token-type:access_token";
6204}
6205
6206#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6207#[serde(transparent)]
6208pub struct AiAgentAskType(pub String);
6209
6210impl AiAgentAskType {
6211 pub const AI_AGENT_ASK: &'static str = "ai_agent_ask";
6212}
6213
6214#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6215pub struct EmbeddingsStrategy {
6216 #[serde(default, skip_serializing_if = "Option::is_none")]
6217 pub id: Option<String>,
6218 #[serde(default, skip_serializing_if = "Option::is_none")]
6219 pub num_tokens_per_chunk: Option<i64>,
6220}
6221
6222#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6223pub struct AiAgentBasicGenToolEmbeddings {
6224 #[serde(default, skip_serializing_if = "Option::is_none")]
6225 pub model: Option<String>,
6226 #[serde(default, skip_serializing_if = "Option::is_none")]
6227 pub strategy: Option<EmbeddingsStrategy>,
6228}
6229
6230#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6231#[serde(transparent)]
6232pub struct AiAgentExtractType(pub String);
6233
6234impl AiAgentExtractType {
6235 pub const AI_AGENT_EXTRACT: &'static str = "ai_agent_extract";
6236}
6237
6238#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6239#[serde(transparent)]
6240pub struct AiAgentExtractStructuredType(pub String);
6241
6242impl AiAgentExtractStructuredType {
6243 pub const AI_AGENT_EXTRACT_STRUCTURED: &'static str = "ai_agent_extract_structured";
6244}
6245
6246#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6247pub struct AiAgentInfoModels {
6248 #[serde(default, skip_serializing_if = "Option::is_none")]
6249 pub name: Option<String>,
6250 #[serde(default, skip_serializing_if = "Option::is_none")]
6251 pub provider: Option<String>,
6252 #[serde(default, skip_serializing_if = "Option::is_none")]
6253 pub supported_purpose: Option<String>,
6254}
6255
6256#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6257#[serde(transparent)]
6258pub struct AiAgentReferenceType(pub String);
6259
6260impl AiAgentReferenceType {
6261 pub const AI_AGENT_ID: &'static str = "ai_agent_id";
6262}
6263
6264#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6265#[serde(transparent)]
6266pub struct AiAgentTextGenType(pub String);
6267
6268impl AiAgentTextGenType {
6269 pub const AI_AGENT_TEXT_GEN: &'static str = "ai_agent_text_gen";
6270}
6271
6272#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6273#[serde(transparent)]
6274pub struct AiAskMode(pub String);
6275
6276impl AiAskMode {
6277 pub const MULTIPLE_ITEM_QA: &'static str = "multiple_item_qa";
6278 pub const SINGLE_ITEM_QA: &'static str = "single_item_qa";
6279}
6280
6281#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6282#[serde(transparent)]
6283pub struct AiCitationType(pub String);
6284
6285impl AiCitationType {
6286 pub const FILE: &'static str = "file";
6287}
6288
6289#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6290#[serde(transparent)]
6291pub struct MetadataTemplateType(pub String);
6292
6293impl MetadataTemplateType {
6294 pub const METADATA_TEMPLATE: &'static str = "metadata_template";
6295}
6296
6297#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6298pub struct AiExtractStructuredMetadataTemplate {
6299 #[serde(default, skip_serializing_if = "Option::is_none")]
6300 pub template_key: Option<String>,
6301 #[serde(default, skip_serializing_if = "Option::is_none")]
6302 pub r#type: Option<MetadataTemplateType>,
6303 #[serde(default, skip_serializing_if = "Option::is_none")]
6304 pub scope: Option<String>,
6305}
6306
6307#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6308pub struct FieldsOptions {
6309 pub key: String,
6310}
6311
6312#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6313pub struct AiExtractStructuredFields {
6314 pub key: String,
6315 #[serde(default, skip_serializing_if = "Option::is_none")]
6316 pub description: Option<String>,
6317 #[serde(
6318 rename = "displayName",
6319 default,
6320 skip_serializing_if = "Option::is_none"
6321 )]
6322 pub display_name: Option<String>,
6323 #[serde(default, skip_serializing_if = "Option::is_none")]
6324 pub prompt: Option<String>,
6325 #[serde(default, skip_serializing_if = "Option::is_none")]
6326 pub r#type: Option<String>,
6327 #[serde(default, skip_serializing_if = "Option::is_none")]
6328 pub options: Option<Vec<FieldsOptions>>,
6329 #[serde(default, skip_serializing_if = "Option::is_none")]
6330 pub fields: Option<Vec<AiExtractSubField>>,
6331 #[serde(default, skip_serializing_if = "Option::is_none")]
6332 pub taxonomy_key: Option<String>,
6333 #[serde(default, skip_serializing_if = "Option::is_none")]
6334 pub namespace: Option<String>,
6335 #[serde(default, skip_serializing_if = "Option::is_none")]
6336 pub options_rules: Option<AiOptionsRules>,
6337}
6338
6339#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6340#[serde(transparent)]
6341pub struct AiItemAskType(pub String);
6342
6343impl AiItemAskType {
6344 pub const FILE: &'static str = "file";
6345 pub const HUBS: &'static str = "hubs";
6346}
6347
6348#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6349#[serde(transparent)]
6350pub struct AiLlmEndpointParamsAWSType(pub String);
6351
6352impl AiLlmEndpointParamsAWSType {
6353 pub const AWS_PARAMS: &'static str = "aws_params";
6354}
6355
6356#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6357#[serde(transparent)]
6358pub struct AiLlmEndpointParamsGoogleType(pub String);
6359
6360impl AiLlmEndpointParamsGoogleType {
6361 pub const GOOGLE_PARAMS: &'static str = "google_params";
6362}
6363
6364#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6365#[serde(transparent)]
6366pub struct AiLlmEndpointParamsIBMType(pub String);
6367
6368impl AiLlmEndpointParamsIBMType {
6369 pub const IBM_PARAMS: &'static str = "ibm_params";
6370}
6371
6372#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6373#[serde(transparent)]
6374pub struct AiLlmEndpointParamsOpenAiType(pub String);
6375
6376impl AiLlmEndpointParamsOpenAiType {
6377 pub const OPENAI_PARAMS: &'static str = "openai_params";
6378}
6379
6380#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6381#[serde(transparent)]
6382pub struct AiSingleAgentResponseType(pub String);
6383
6384impl AiSingleAgentResponseType {
6385 pub const AI_AGENT: &'static str = "ai_agent";
6386}
6387
6388#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6389#[serde(transparent)]
6390pub struct AiTaxonomyReferenceType(pub String);
6391
6392impl AiTaxonomyReferenceType {
6393 pub const TAXONOMY: &'static str = "taxonomy";
6394}
6395
6396#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6397pub struct AiTextGenItems {
6398 pub id: String,
6399 pub r#type: AiCitationType,
6400 #[serde(default, skip_serializing_if = "Option::is_none")]
6401 pub content: Option<String>,
6402}
6403
6404#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6405#[serde(transparent)]
6406pub struct AppItemType(pub String);
6407
6408impl AppItemType {
6409 pub const APP_ITEM: &'static str = "app_item";
6410}
6411
6412#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6413#[serde(transparent)]
6414pub struct AppItemAssociationType(pub String);
6415
6416impl AppItemAssociationType {
6417 pub const APP_ITEM_ASSOCIATION: &'static str = "app_item_association";
6418}
6419
6420#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6421#[serde(transparent)]
6422pub struct ClassificationTemplate2(pub String);
6423
6424impl ClassificationTemplate2 {
6425 pub const SECURITYCLASSIFICATION_6VMVOCHWUWO: &'static str =
6426 "securityClassification-6VMVochwUWo";
6427}
6428
6429#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6430#[serde(transparent)]
6431pub struct ClassificationTemplateDisplayName(pub String);
6432
6433impl ClassificationTemplateDisplayName {
6434 pub const CLASSIFICATION: &'static str = "Classification";
6435}
6436
6437#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6438#[serde(transparent)]
6439pub struct FieldsType(pub String);
6440
6441impl FieldsType {
6442 pub const ENUM: &'static str = "enum";
6443}
6444
6445#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6446#[serde(transparent)]
6447pub struct FieldsKey(pub String);
6448
6449impl FieldsKey {
6450 pub const BOX_SECURITY_CLASSIFICATION_KEY: &'static str = "Box__Security__Classification__Key";
6451}
6452
6453#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6454pub struct StaticConfigClassification {
6455 #[serde(
6456 rename = "classificationDefinition",
6457 default,
6458 skip_serializing_if = "Option::is_none"
6459 )]
6460 pub classification_definition: Option<String>,
6461 #[serde(rename = "colorID", default, skip_serializing_if = "Option::is_none")]
6462 pub color_id: Option<i64>,
6463}
6464
6465#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6466pub struct OptionsStaticConfig {
6467 #[serde(default, skip_serializing_if = "Option::is_none")]
6468 pub classification: Option<StaticConfigClassification>,
6469}
6470
6471#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6472pub struct FieldsOptions2 {
6473 pub id: String,
6474 pub key: String,
6475 #[serde(
6476 rename = "staticConfig",
6477 default,
6478 skip_serializing_if = "Option::is_none"
6479 )]
6480 pub static_config: Option<OptionsStaticConfig>,
6481}
6482
6483#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6484pub struct ClassificationTemplateFields {
6485 pub id: String,
6486 pub r#type: FieldsType,
6487 pub key: FieldsKey,
6488 #[serde(rename = "displayName")]
6489 pub display_name: ClassificationTemplateDisplayName,
6490 #[serde(default, skip_serializing_if = "Option::is_none")]
6491 pub hidden: Option<bool>,
6492 pub options: Vec<FieldsOptions2>,
6493}
6494
6495#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6496#[serde(transparent)]
6497pub struct ClientErrorType(pub String);
6498
6499impl ClientErrorType {
6500 pub const ERROR: &'static str = "error";
6501}
6502
6503#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6504#[serde(transparent)]
6505pub struct ClientErrorCode(pub String);
6506
6507impl ClientErrorCode {
6508 pub const CREATED: &'static str = "created";
6509 pub const ACCEPTED: &'static str = "accepted";
6510 pub const NO_CONTENT: &'static str = "no_content";
6511 pub const REDIRECT: &'static str = "redirect";
6512 pub const NOT_MODIFIED: &'static str = "not_modified";
6513 pub const BAD_REQUEST: &'static str = "bad_request";
6514 pub const UNAUTHORIZED: &'static str = "unauthorized";
6515 pub const FORBIDDEN: &'static str = "forbidden";
6516 pub const NOT_FOUND: &'static str = "not_found";
6517 pub const METHOD_NOT_ALLOWED: &'static str = "method_not_allowed";
6518 pub const CONFLICT: &'static str = "conflict";
6519 pub const PRECONDITION_FAILED: &'static str = "precondition_failed";
6520 pub const TOO_MANY_REQUESTS: &'static str = "too_many_requests";
6521 pub const INTERNAL_SERVER_ERROR: &'static str = "internal_server_error";
6522 pub const UNAVAILABLE: &'static str = "unavailable";
6523 pub const ITEM_NAME_INVALID: &'static str = "item_name_invalid";
6524 pub const INSUFFICIENT_SCOPE: &'static str = "insufficient_scope";
6525}
6526
6527#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6528#[serde(transparent)]
6529pub struct CollaborationType(pub String);
6530
6531impl CollaborationType {
6532 pub const COLLABORATION: &'static str = "collaboration";
6533}
6534
6535#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6536#[serde(transparent)]
6537pub struct CollaborationRole(pub String);
6538
6539impl CollaborationRole {
6540 pub const EDITOR: &'static str = "editor";
6541 pub const VIEWER: &'static str = "viewer";
6542 pub const PREVIEWER: &'static str = "previewer";
6543 pub const UPLOADER: &'static str = "uploader";
6544 pub const PREVIEWER_UPLOADER: &'static str = "previewer uploader";
6545 pub const VIEWER_UPLOADER: &'static str = "viewer uploader";
6546 pub const CO_OWNER: &'static str = "co-owner";
6547 pub const OWNER: &'static str = "owner";
6548}
6549
6550#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6551#[serde(transparent)]
6552pub struct CollaborationStatus(pub String);
6553
6554impl CollaborationStatus {
6555 pub const ACCEPTED: &'static str = "accepted";
6556 pub const PENDING: &'static str = "pending";
6557 pub const REJECTED: &'static str = "rejected";
6558}
6559
6560#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6561pub struct AcceptanceRequirementsStatusTermsOfServiceRequirement {
6562 #[serde(
6563 default,
6564 skip_serializing_if = "Option::is_none",
6565 deserialize_with = "double_option"
6566 )]
6567 pub is_accepted: Option<Option<bool>>,
6568 #[serde(default, skip_serializing_if = "Option::is_none")]
6569 pub terms_of_service: Option<TermsOfServiceBase>,
6570}
6571
6572#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6573pub struct AcceptanceRequirementsStatusStrongPasswordRequirement {
6574 #[serde(default, skip_serializing_if = "Option::is_none")]
6575 pub enterprise_has_strong_password_required_for_external_users: Option<bool>,
6576 #[serde(
6577 default,
6578 skip_serializing_if = "Option::is_none",
6579 deserialize_with = "double_option"
6580 )]
6581 pub user_has_strong_password: Option<Option<bool>>,
6582}
6583
6584#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6585pub struct AcceptanceRequirementsStatusTwoFactorAuthenticationRequirement {
6586 #[serde(default, skip_serializing_if = "Option::is_none")]
6587 pub enterprise_has_two_factor_auth_enabled: Option<bool>,
6588 #[serde(
6589 default,
6590 skip_serializing_if = "Option::is_none",
6591 deserialize_with = "double_option"
6592 )]
6593 pub user_has_two_factor_authentication_enabled: Option<Option<bool>>,
6594}
6595
6596#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6597pub struct CollaborationAcceptanceRequirementsStatus {
6598 #[serde(default, skip_serializing_if = "Option::is_none")]
6599 pub terms_of_service_requirement: Option<AcceptanceRequirementsStatusTermsOfServiceRequirement>,
6600 #[serde(default, skip_serializing_if = "Option::is_none")]
6601 pub strong_password_requirement: Option<AcceptanceRequirementsStatusStrongPasswordRequirement>,
6602 #[serde(default, skip_serializing_if = "Option::is_none")]
6603 pub two_factor_authentication_requirement:
6604 Option<AcceptanceRequirementsStatusTwoFactorAuthenticationRequirement>,
6605}
6606
6607#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6608#[serde(transparent)]
6609pub struct CollaborationAllowlistEntryType(pub String);
6610
6611impl CollaborationAllowlistEntryType {
6612 pub const COLLABORATION_WHITELIST_ENTRY: &'static str = "collaboration_whitelist_entry";
6613}
6614
6615#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6616#[serde(transparent)]
6617pub struct CollaborationAllowlistEntryDirection(pub String);
6618
6619impl CollaborationAllowlistEntryDirection {
6620 pub const INBOUND: &'static str = "inbound";
6621 pub const OUTBOUND: &'static str = "outbound";
6622 pub const BOTH: &'static str = "both";
6623}
6624
6625#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6626#[serde(transparent)]
6627pub struct EnterpriseType(pub String);
6628
6629impl EnterpriseType {
6630 pub const ENTERPRISE: &'static str = "enterprise";
6631}
6632
6633#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6634pub struct CollaborationAllowlistEntryEnterprise {
6635 #[serde(default, skip_serializing_if = "Option::is_none")]
6636 pub id: Option<String>,
6637 #[serde(default, skip_serializing_if = "Option::is_none")]
6638 pub r#type: Option<EnterpriseType>,
6639 #[serde(default, skip_serializing_if = "Option::is_none")]
6640 pub name: Option<String>,
6641}
6642
6643#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6644#[serde(transparent)]
6645pub struct CollaborationAllowlistExemptTargetType(pub String);
6646
6647impl CollaborationAllowlistExemptTargetType {
6648 pub const COLLABORATION_WHITELIST_EXEMPT_TARGET: &'static str =
6649 "collaboration_whitelist_exempt_target";
6650}
6651
6652#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6653#[serde(transparent)]
6654pub struct CollaboratorVariableType(pub String);
6655
6656impl CollaboratorVariableType {
6657 pub const VARIABLE: &'static str = "variable";
6658}
6659
6660#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6661#[serde(transparent)]
6662pub struct CollaboratorVariableVariableType(pub String);
6663
6664impl CollaboratorVariableVariableType {
6665 pub const USER_LIST: &'static str = "user_list";
6666}
6667
6668#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6669#[serde(transparent)]
6670pub struct VariableValueType(pub String);
6671
6672impl VariableValueType {
6673 pub const USER: &'static str = "user";
6674}
6675
6676#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6677pub struct CollaboratorVariableVariableValue {
6678 pub r#type: VariableValueType,
6679 pub id: String,
6680}
6681
6682#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6683#[serde(transparent)]
6684pub struct CollectionType(pub String);
6685
6686impl CollectionType {
6687 pub const COLLECTION: &'static str = "collection";
6688}
6689
6690#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6691#[serde(transparent)]
6692pub struct CollectionName(pub String);
6693
6694impl CollectionName {
6695 pub const FAVORITES: &'static str = "Favorites";
6696}
6697
6698#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6699#[serde(transparent)]
6700pub struct CollectionCollectionType(pub String);
6701
6702impl CollectionCollectionType {
6703 pub const FAVORITES: &'static str = "favorites";
6704}
6705
6706#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6707#[serde(transparent)]
6708pub struct OrderDirection(pub String);
6709
6710impl OrderDirection {
6711 pub const ASC: &'static str = "ASC";
6712 pub const DESC: &'static str = "DESC";
6713}
6714
6715#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6716pub struct CollectionsOrder {
6717 #[serde(default, skip_serializing_if = "Option::is_none")]
6718 pub by: Option<String>,
6719 #[serde(default, skip_serializing_if = "Option::is_none")]
6720 pub direction: Option<OrderDirection>,
6721}
6722
6723#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6724#[serde(transparent)]
6725pub struct CommentType(pub String);
6726
6727impl CommentType {
6728 pub const COMMENT: &'static str = "comment";
6729}
6730
6731#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6732pub struct CommentItem {
6733 #[serde(default, skip_serializing_if = "Option::is_none")]
6734 pub id: Option<String>,
6735 #[serde(default, skip_serializing_if = "Option::is_none")]
6736 pub r#type: Option<String>,
6737}
6738
6739#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6740#[serde(transparent)]
6741pub struct CompletionRuleVariableVariableType(pub String);
6742
6743impl CompletionRuleVariableVariableType {
6744 pub const TASK_COMPLETION_RULE: &'static str = "task_completion_rule";
6745}
6746
6747#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6748#[serde(transparent)]
6749pub struct CompletionRuleVariableVariableValue(pub String);
6750
6751impl CompletionRuleVariableVariableValue {
6752 pub const ALL_ASSIGNEES: &'static str = "all_assignees";
6753 pub const ANY_ASSIGNEES: &'static str = "any_assignees";
6754}
6755
6756#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6757pub struct ConflictErrorContextInfo {
6758 #[serde(default, skip_serializing_if = "Option::is_none")]
6759 pub conflicts: Option<Vec<FileConflict>>,
6760}
6761
6762#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6763#[serde(transparent)]
6764pub struct DevicePinnerType(pub String);
6765
6766impl DevicePinnerType {
6767 pub const DEVICE_PINNER: &'static str = "device_pinner";
6768}
6769
6770#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6771#[serde(transparent)]
6772pub struct OrderBy(pub String);
6773
6774impl OrderBy {
6775 pub const ID: &'static str = "id";
6776}
6777
6778#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6779#[serde(transparent)]
6780pub struct OrderDirection2(pub String);
6781
6782impl OrderDirection2 {
6783 pub const ASC: &'static str = "asc";
6784 pub const DESC: &'static str = "desc";
6785}
6786
6787#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
6788pub struct DevicePinnersOrder {
6789 #[serde(default, skip_serializing_if = "Option::is_none")]
6790 pub by: Option<OrderBy>,
6791 #[serde(default, skip_serializing_if = "Option::is_none")]
6792 pub direction: Option<OrderDirection2>,
6793}
6794
6795#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6796#[serde(transparent)]
6797pub struct EmailAliasType(pub String);
6798
6799impl EmailAliasType {
6800 pub const EMAIL_ALIAS: &'static str = "email_alias";
6801}
6802
6803#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
6804#[serde(transparent)]
6805pub struct EventEventType(pub String);
6806
6807impl EventEventType {
6808 pub const ACCESS_GRANTED: &'static str = "ACCESS_GRANTED";
6809 pub const ACCESS_REVOKED: &'static str = "ACCESS_REVOKED";
6810 pub const ADD_DEVICE_ASSOCIATION: &'static str = "ADD_DEVICE_ASSOCIATION";
6811 pub const ADD_LOGIN_ACTIVITY_DEVICE: &'static str = "ADD_LOGIN_ACTIVITY_DEVICE";
6812 pub const ADMIN_LOGIN: &'static str = "ADMIN_LOGIN";
6813 pub const ADVANCED_FOLDER_SETTINGS_UPDATE: &'static str = "ADVANCED_FOLDER_SETTINGS_UPDATE";
6814 pub const AI_SECURITY_DETECTION: &'static str = "AI_SECURITY_DETECTION";
6815 pub const ANNOTATIONV2_CREATE: &'static str = "ANNOTATIONV2_CREATE";
6816 pub const ANNOTATIONV2_DELETE: &'static str = "ANNOTATIONV2_DELETE";
6817 pub const ANNOTATIONV2_EDIT: &'static str = "ANNOTATIONV2_EDIT";
6818 pub const APPLICATION_CREATED: &'static str = "APPLICATION_CREATED";
6819 pub const APPLICATION_PUBLIC_KEY_ADDED: &'static str = "APPLICATION_PUBLIC_KEY_ADDED";
6820 pub const APPLICATION_PUBLIC_KEY_DELETED: &'static str = "APPLICATION_PUBLIC_KEY_DELETED";
6821 pub const BOX_AI_USER_FAILED_REQUEST: &'static str = "BOX_AI_USER_FAILED_REQUEST";
6822 pub const BOX_AI_USER_REQUEST: &'static str = "BOX_AI_USER_REQUEST";
6823 pub const CHANGE_ADMIN_ROLE: &'static str = "CHANGE_ADMIN_ROLE";
6824 pub const CHANGE_FOLDER_PERMISSION: &'static str = "CHANGE_FOLDER_PERMISSION";
6825 pub const COLLABORATION_ACCEPT: &'static str = "COLLABORATION_ACCEPT";
6826 pub const COLLABORATION_EXPIRATION: &'static str = "COLLABORATION_EXPIRATION";
6827 pub const COLLABORATION_INVITE: &'static str = "COLLABORATION_INVITE";
6828 pub const COLLABORATION_REMOVE: &'static str = "COLLABORATION_REMOVE";
6829 pub const COLLABORATION_ROLE_CHANGE: &'static str = "COLLABORATION_ROLE_CHANGE";
6830 pub const COLLAB_ADD_COLLABORATOR: &'static str = "COLLAB_ADD_COLLABORATOR";
6831 pub const COLLAB_INVITE_COLLABORATOR: &'static str = "COLLAB_INVITE_COLLABORATOR";
6832 pub const COLLAB_REMOVE_COLLABORATOR: &'static str = "COLLAB_REMOVE_COLLABORATOR";
6833 pub const COLLAB_ROLE_CHANGE: &'static str = "COLLAB_ROLE_CHANGE";
6834 pub const COLLECTION_CREATE: &'static str = "COLLECTION_CREATE";
6835 pub const COLLECTION_DELETE: &'static str = "COLLECTION_DELETE";
6836 pub const COLLECTION_ITEM_CREATE: &'static str = "COLLECTION_ITEM_CREATE";
6837 pub const COLLECTION_ITEM_DELETE: &'static str = "COLLECTION_ITEM_DELETE";
6838 pub const COLLECTION_ITEM_UPDATE: &'static str = "COLLECTION_ITEM_UPDATE";
6839 pub const COLLECTION_UPDATE: &'static str = "COLLECTION_UPDATE";
6840 pub const COMMENT_CREATE: &'static str = "COMMENT_CREATE";
6841 pub const COMMENT_DELETE: &'static str = "COMMENT_DELETE";
6842 pub const COMMENT_EDIT: &'static str = "COMMENT_EDIT";
6843 pub const CONTENT_ACCESS: &'static str = "CONTENT_ACCESS";
6844 pub const CONTENT_RECOVERY_REPORT_CREATE: &'static str = "CONTENT_RECOVERY_REPORT_CREATE";
6845 pub const CONTENT_RECOVERY_REPORT_DELETE: &'static str = "CONTENT_RECOVERY_REPORT_DELETE";
6846 pub const CONTENT_RECOVERY_REPORT_INITIATE: &'static str = "CONTENT_RECOVERY_REPORT_INITIATE";
6847 pub const CONTENT_WORKFLOW_ABNORMAL_DOWNLOAD_ACTIVITY: &'static str =
6848 "CONTENT_WORKFLOW_ABNORMAL_DOWNLOAD_ACTIVITY";
6849 pub const CONTENT_WORKFLOW_AUTOMATION_ADD: &'static str = "CONTENT_WORKFLOW_AUTOMATION_ADD";
6850 pub const CONTENT_WORKFLOW_AUTOMATION_DELETE: &'static str =
6851 "CONTENT_WORKFLOW_AUTOMATION_DELETE";
6852 pub const CONTENT_WORKFLOW_POLICY_ADD: &'static str = "CONTENT_WORKFLOW_POLICY_ADD";
6853 pub const CONTENT_WORKFLOW_SHARING_POLICY_VIOLATION: &'static str =
6854 "CONTENT_WORKFLOW_SHARING_POLICY_VIOLATION";
6855 pub const CONTENT_WORKFLOW_UPLOAD_POLICY_VIOLATION: &'static str =
6856 "CONTENT_WORKFLOW_UPLOAD_POLICY_VIOLATION";
6857 pub const COPY: &'static str = "COPY";
6858 pub const DATA_RETENTION_CREATE_RETENTION: &'static str = "DATA_RETENTION_CREATE_RETENTION";
6859 pub const DATA_RETENTION_REMOVE_RETENTION: &'static str = "DATA_RETENTION_REMOVE_RETENTION";
6860 pub const DELETE: &'static str = "DELETE";
6861 pub const DELETE_USER: &'static str = "DELETE_USER";
6862 pub const DEVICE_TRUST_CHECK_FAILED: &'static str = "DEVICE_TRUST_CHECK_FAILED";
6863 pub const DISABLE_MULTI_FACTOR_AUTH: &'static str = "DISABLE_MULTI_FACTOR_AUTH";
6864 pub const DOWNLOAD: &'static str = "DOWNLOAD";
6865 pub const EDIT: &'static str = "EDIT";
6866 pub const EDIT_USER: &'static str = "EDIT_USER";
6867 pub const EDR_CROWDSTRIKE_ACCESS_ALLOWED_NO_CROWDSTRIKE_DEVICE: &'static str =
6868 "EDR_CROWDSTRIKE_ACCESS_ALLOWED_NO_CROWDSTRIKE_DEVICE";
6869 pub const EDR_CROWDSTRIKE_ACCESS_REVOKED: &'static str = "EDR_CROWDSTRIKE_ACCESS_REVOKED";
6870 pub const EDR_CROWDSTRIKE_BOX_TOOLS_OUTDATED: &'static str =
6871 "EDR_CROWDSTRIKE_BOX_TOOLS_OUTDATED";
6872 pub const EDR_CROWDSTRIKE_DEVICE_DETECTED: &'static str = "EDR_CROWDSTRIKE_DEVICE_DETECTED";
6873 pub const EDR_CROWDSTRIKE_DRIVE_OUTDATED: &'static str = "EDR_CROWDSTRIKE_DRIVE_OUTDATED";
6874 pub const EDR_CROWDSTRIKE_NO_BOX_TOOLS: &'static str = "EDR_CROWDSTRIKE_NO_BOX_TOOLS";
6875 pub const EMAIL_ALIAS_CONFIRM: &'static str = "EMAIL_ALIAS_CONFIRM";
6876 pub const EMAIL_ALIAS_PRIMARY: &'static str = "EMAIL_ALIAS_PRIMARY";
6877 pub const EMAIL_ALIAS_REMOVE: &'static str = "EMAIL_ALIAS_REMOVE";
6878 pub const EMAIL_UPLOAD_DISABLED: &'static str = "EMAIL_UPLOAD_DISABLED";
6879 pub const EMAIL_UPLOAD_ENABLED: &'static str = "EMAIL_UPLOAD_ENABLED";
6880 pub const ENABLE_MULTI_FACTOR_AUTH: &'static str = "ENABLE_MULTI_FACTOR_AUTH";
6881 pub const ENABLE_TWO_FACTOR_AUTH: &'static str = "ENABLE_TWO_FACTOR_AUTH";
6882 pub const ENTERPRISE_APP_AUTHORIZATION_UPDATE: &'static str =
6883 "ENTERPRISE_APP_AUTHORIZATION_UPDATE";
6884 pub const EXTERNAL_COLLAB_SECURITY_SETTINGS: &'static str = "EXTERNAL_COLLAB_SECURITY_SETTINGS";
6885 pub const FAILED_LOGIN: &'static str = "FAILED_LOGIN";
6886 pub const FAVORITE: &'static str = "FAVORITE";
6887 pub const FILE_MARKED_MALICIOUS: &'static str = "FILE_MARKED_MALICIOUS";
6888 pub const FILE_REQUEST_CREATE: &'static str = "FILE_REQUEST_CREATE";
6889 pub const FILE_REQUEST_DELETE: &'static str = "FILE_REQUEST_DELETE";
6890 pub const FILE_REQUEST_UPDATE: &'static str = "FILE_REQUEST_UPDATE";
6891 pub const FILE_VERSION_RESTORE: &'static str = "FILE_VERSION_RESTORE";
6892 pub const FILE_WATERMARKED_DOWNLOAD: &'static str = "FILE_WATERMARKED_DOWNLOAD";
6893 pub const GROUP_ADD_ITEM: &'static str = "GROUP_ADD_ITEM";
6894 pub const GROUP_ADD_USER: &'static str = "GROUP_ADD_USER";
6895 pub const GROUP_ADMIN_CREATED: &'static str = "GROUP_ADMIN_CREATED";
6896 pub const GROUP_ADMIN_DELETED: &'static str = "GROUP_ADMIN_DELETED";
6897 pub const GROUP_ADMIN_PERMISSIONS_UPDATED: &'static str = "GROUP_ADMIN_PERMISSIONS_UPDATED";
6898 pub const GROUP_CREATION: &'static str = "GROUP_CREATION";
6899 pub const GROUP_DELETION: &'static str = "GROUP_DELETION";
6900 pub const GROUP_EDITED: &'static str = "GROUP_EDITED";
6901 pub const GROUP_REMOVE_ITEM: &'static str = "GROUP_REMOVE_ITEM";
6902 pub const GROUP_REMOVE_USER: &'static str = "GROUP_REMOVE_USER";
6903 pub const ILLEGAL_ITEM_OWNERSHIP_TRANSFER_BY_USER: &'static str =
6904 "ILLEGAL_ITEM_OWNERSHIP_TRANSFER_BY_USER";
6905 pub const ITEM_ASSOCIATION_CREATED: &'static str = "ITEM_ASSOCIATION_CREATED";
6906 pub const ITEM_ASSOCIATION_DELETED: &'static str = "ITEM_ASSOCIATION_DELETED";
6907 pub const ITEM_ASSOCIATION_UPDATED: &'static str = "ITEM_ASSOCIATION_UPDATED";
6908 pub const ITEM_COPY: &'static str = "ITEM_COPY";
6909 pub const ITEM_CREATE: &'static str = "ITEM_CREATE";
6910 pub const ITEM_DOWNLOAD: &'static str = "ITEM_DOWNLOAD";
6911 pub const ITEM_EMAIL_SEND: &'static str = "ITEM_EMAIL_SEND";
6912 pub const ITEM_MAKE_CURRENT_VERSION: &'static str = "ITEM_MAKE_CURRENT_VERSION";
6913 pub const ITEM_MODIFY: &'static str = "ITEM_MODIFY";
6914 pub const ITEM_MOVE: &'static str = "ITEM_MOVE";
6915 pub const ITEM_OPEN: &'static str = "ITEM_OPEN";
6916 pub const ITEM_PREVIEW: &'static str = "ITEM_PREVIEW";
6917 pub const ITEM_RENAME: &'static str = "ITEM_RENAME";
6918 pub const ITEM_SHARED: &'static str = "ITEM_SHARED";
6919 pub const ITEM_SHARED_CREATE: &'static str = "ITEM_SHARED_CREATE";
6920 pub const ITEM_SHARED_UNSHARE: &'static str = "ITEM_SHARED_UNSHARE";
6921 pub const ITEM_SHARED_UPDATE: &'static str = "ITEM_SHARED_UPDATE";
6922 pub const ITEM_SYNC: &'static str = "ITEM_SYNC";
6923 pub const ITEM_TRASH: &'static str = "ITEM_TRASH";
6924 pub const ITEM_UNDELETE_VIA_TRASH: &'static str = "ITEM_UNDELETE_VIA_TRASH";
6925 pub const ITEM_UNSYNC: &'static str = "ITEM_UNSYNC";
6926 pub const ITEM_UPLOAD: &'static str = "ITEM_UPLOAD";
6927 pub const LEGAL_HOLD_ASSIGNMENT_CREATE: &'static str = "LEGAL_HOLD_ASSIGNMENT_CREATE";
6928 pub const LEGAL_HOLD_ASSIGNMENT_DELETE: &'static str = "LEGAL_HOLD_ASSIGNMENT_DELETE";
6929 pub const LEGAL_HOLD_POLICY_CREATE: &'static str = "LEGAL_HOLD_POLICY_CREATE";
6930 pub const LEGAL_HOLD_POLICY_DELETE: &'static str = "LEGAL_HOLD_POLICY_DELETE";
6931 pub const LEGAL_HOLD_POLICY_UPDATE: &'static str = "LEGAL_HOLD_POLICY_UPDATE";
6932 pub const LOCK: &'static str = "LOCK";
6933 pub const LOCK_CREATE: &'static str = "LOCK_CREATE";
6934 pub const LOCK_DESTROY: &'static str = "LOCK_DESTROY";
6935 pub const LOGIN: &'static str = "LOGIN";
6936 pub const MASTER_INVITE_ACCEPT: &'static str = "MASTER_INVITE_ACCEPT";
6937 pub const MASTER_INVITE_REJECT: &'static str = "MASTER_INVITE_REJECT";
6938 pub const METADATA_CASCADE_POLICY_APPLY: &'static str = "METADATA_CASCADE_POLICY_APPLY";
6939 pub const METADATA_CASCADE_POLICY_CREATE: &'static str = "METADATA_CASCADE_POLICY_CREATE";
6940 pub const METADATA_INSTANCE_COPY: &'static str = "METADATA_INSTANCE_COPY";
6941 pub const METADATA_INSTANCE_CREATE: &'static str = "METADATA_INSTANCE_CREATE";
6942 pub const METADATA_INSTANCE_DELETE: &'static str = "METADATA_INSTANCE_DELETE";
6943 pub const METADATA_INSTANCE_UPDATE: &'static str = "METADATA_INSTANCE_UPDATE";
6944 pub const METADATA_TEMPLATE_CREATE: &'static str = "METADATA_TEMPLATE_CREATE";
6945 pub const METADATA_TEMPLATE_DELETE: &'static str = "METADATA_TEMPLATE_DELETE";
6946 pub const METADATA_TEMPLATE_UPDATE: &'static str = "METADATA_TEMPLATE_UPDATE";
6947 pub const MOVE: &'static str = "MOVE";
6948 pub const NEW_USER: &'static str = "NEW_USER";
6949 pub const OAUTH2_ACCESS_TOKEN_REVOKE: &'static str = "OAUTH2_ACCESS_TOKEN_REVOKE";
6950 pub const OAUTH2_REFRESH_TOKEN_REVOKE: &'static str = "OAUTH2_REFRESH_TOKEN_REVOKE";
6951 pub const PREVIEW: &'static str = "PREVIEW";
6952 pub const REMOVE_DEVICE_ASSOCIATION: &'static str = "REMOVE_DEVICE_ASSOCIATION";
6953 pub const REMOVE_LOGIN_ACTIVITY_DEVICE: &'static str = "REMOVE_LOGIN_ACTIVITY_DEVICE";
6954 pub const RENAME: &'static str = "RENAME";
6955 pub const RETENTION_POLICY_ASSIGNMENT_ADD: &'static str = "RETENTION_POLICY_ASSIGNMENT_ADD";
6956 pub const SHARE: &'static str = "SHARE";
6957 pub const SHARED_LINK_REDIRECT_OUT_OF_SHARED_CONTEXT: &'static str =
6958 "SHARED_LINK_REDIRECT_OUT_OF_SHARED_CONTEXT";
6959 pub const SHARED_LINK_SEND: &'static str = "SHARED_LINK_SEND";
6960 pub const SHARE_EXPIRATION: &'static str = "SHARE_EXPIRATION";
6961 pub const SHIELD_ACCESS_POLICY_CREATED: &'static str = "SHIELD_ACCESS_POLICY_CREATED";
6962 pub const SHIELD_ACCESS_POLICY_DELETED: &'static str = "SHIELD_ACCESS_POLICY_DELETED";
6963 pub const SHIELD_ACCESS_POLICY_UPDATED: &'static str = "SHIELD_ACCESS_POLICY_UPDATED";
6964 pub const SHIELD_ALERT: &'static str = "SHIELD_ALERT";
6965 pub const SHIELD_DOWNLOAD_BLOCKED: &'static str = "SHIELD_DOWNLOAD_BLOCKED";
6966 pub const SHIELD_EXTERNAL_COLLAB_ACCESS_BLOCKED: &'static str =
6967 "SHIELD_EXTERNAL_COLLAB_ACCESS_BLOCKED";
6968 pub const SHIELD_EXTERNAL_COLLAB_ACCESS_BLOCKED_MISSING_JUSTIFICATION: &'static str =
6969 "SHIELD_EXTERNAL_COLLAB_ACCESS_BLOCKED_MISSING_JUSTIFICATION";
6970 pub const SHIELD_EXTERNAL_COLLAB_INVITE_BLOCKED: &'static str =
6971 "SHIELD_EXTERNAL_COLLAB_INVITE_BLOCKED";
6972 pub const SHIELD_EXTERNAL_COLLAB_INVITE_BLOCKED_MISSING_JUSTIFICATION: &'static str =
6973 "SHIELD_EXTERNAL_COLLAB_INVITE_BLOCKED_MISSING_JUSTIFICATION";
6974 pub const SHIELD_EXTERNAL_COLLAB_INVITE_JUSTIFIED: &'static str =
6975 "SHIELD_EXTERNAL_COLLAB_INVITE_JUSTIFIED";
6976 pub const SHIELD_INFORMATION_BARRIER_COLLAB_BLOCKED: &'static str =
6977 "SHIELD_INFORMATION_BARRIER_COLLAB_BLOCKED";
6978 pub const SHIELD_INFORMATION_BARRIER_DISABLED: &'static str =
6979 "SHIELD_INFORMATION_BARRIER_DISABLED";
6980 pub const SHIELD_INFORMATION_BARRIER_ENABLED: &'static str =
6981 "SHIELD_INFORMATION_BARRIER_ENABLED";
6982 pub const SHIELD_INFORMATION_BARRIER_GROUP_ADD_USER_BLOCKED: &'static str =
6983 "SHIELD_INFORMATION_BARRIER_GROUP_ADD_USER_BLOCKED";
6984 pub const SHIELD_INFORMATION_BARRIER_ITEM_COPY_BLOCKED: &'static str =
6985 "SHIELD_INFORMATION_BARRIER_ITEM_COPY_BLOCKED";
6986 pub const SHIELD_INFORMATION_BARRIER_ITEM_MOVE_BLOCKED: &'static str =
6987 "SHIELD_INFORMATION_BARRIER_ITEM_MOVE_BLOCKED";
6988 pub const SHIELD_INFORMATION_BARRIER_ITEM_OWNER_TRANSFER_BLOCKED: &'static str =
6989 "SHIELD_INFORMATION_BARRIER_ITEM_OWNER_TRANSFER_BLOCKED";
6990 pub const SHIELD_INFORMATION_BARRIER_PENDING: &'static str =
6991 "SHIELD_INFORMATION_BARRIER_PENDING";
6992 pub const SHIELD_INFORMATION_BARRIER_SHARED_ITEM_ACCESS_BLOCKED: &'static str =
6993 "SHIELD_INFORMATION_BARRIER_SHARED_ITEM_ACCESS_BLOCKED";
6994 pub const SHIELD_JUSTIFICATION_APPROVAL: &'static str = "SHIELD_JUSTIFICATION_APPROVAL";
6995 pub const SHIELD_SHARED_LINK_ACCESS_BLOCKED: &'static str = "SHIELD_SHARED_LINK_ACCESS_BLOCKED";
6996 pub const SHIELD_SHARED_LINK_STATUS_RESTRICTED_ON_CREATE: &'static str =
6997 "SHIELD_SHARED_LINK_STATUS_RESTRICTED_ON_CREATE";
6998 pub const SHIELD_SHARED_LINK_STATUS_RESTRICTED_ON_UPDATE: &'static str =
6999 "SHIELD_SHARED_LINK_STATUS_RESTRICTED_ON_UPDATE";
7000 pub const SIGN_DOCUMENT_ASSIGNED: &'static str = "SIGN_DOCUMENT_ASSIGNED";
7001 pub const SIGN_DOCUMENT_CANCELLED: &'static str = "SIGN_DOCUMENT_CANCELLED";
7002 pub const SIGN_DOCUMENT_COMPLETED: &'static str = "SIGN_DOCUMENT_COMPLETED";
7003 pub const SIGN_DOCUMENT_CONVERTED: &'static str = "SIGN_DOCUMENT_CONVERTED";
7004 pub const SIGN_DOCUMENT_CREATED: &'static str = "SIGN_DOCUMENT_CREATED";
7005 pub const SIGN_DOCUMENT_DECLINED: &'static str = "SIGN_DOCUMENT_DECLINED";
7006 pub const SIGN_DOCUMENT_EXPIRED: &'static str = "SIGN_DOCUMENT_EXPIRED";
7007 pub const SIGN_DOCUMENT_SIGNED: &'static str = "SIGN_DOCUMENT_SIGNED";
7008 pub const SIGN_DOCUMENT_VIEWED_BY_SIGNED: &'static str = "SIGN_DOCUMENT_VIEWED_BY_SIGNED";
7009 pub const SIGN_DOCUMENT_VIEWED_BY_SIGNER: &'static str = "SIGN_DOCUMENT_VIEWED_BY_SIGNER";
7010 pub const SIGNER_DOWNLOADED: &'static str = "SIGNER_DOWNLOADED";
7011 pub const SIGNER_FORWARDED: &'static str = "SIGNER_FORWARDED";
7012 pub const STORAGE_EXPIRATION: &'static str = "STORAGE_EXPIRATION";
7013 pub const TAG_ITEM_CREATE: &'static str = "TAG_ITEM_CREATE";
7014 pub const TASK_ASSIGNMENT_CREATE: &'static str = "TASK_ASSIGNMENT_CREATE";
7015 pub const TASK_ASSIGNMENT_DELETE: &'static str = "TASK_ASSIGNMENT_DELETE";
7016 pub const TASK_ASSIGNMENT_UPDATE: &'static str = "TASK_ASSIGNMENT_UPDATE";
7017 pub const TASK_CREATE: &'static str = "TASK_CREATE";
7018 pub const TASK_UPDATE: &'static str = "TASK_UPDATE";
7019 pub const TERMS_OF_SERVICE_ACCEPT: &'static str = "TERMS_OF_SERVICE_ACCEPT";
7020 pub const TERMS_OF_SERVICE_REJECT: &'static str = "TERMS_OF_SERVICE_REJECT";
7021 pub const UNDELETE: &'static str = "UNDELETE";
7022 pub const UNFAVORITE: &'static str = "UNFAVORITE";
7023 pub const UNLOCK: &'static str = "UNLOCK";
7024 pub const UNSHARE: &'static str = "UNSHARE";
7025 pub const UPDATE_COLLABORATION_EXPIRATION: &'static str = "UPDATE_COLLABORATION_EXPIRATION";
7026 pub const UPDATE_SHARE_EXPIRATION: &'static str = "UPDATE_SHARE_EXPIRATION";
7027 pub const UPLOAD: &'static str = "UPLOAD";
7028 pub const USER_AUTHENTICATE_OAUTH2_ACCESS_TOKEN_CREATE: &'static str =
7029 "USER_AUTHENTICATE_OAUTH2_ACCESS_TOKEN_CREATE";
7030 pub const WATERMARK_LABEL_CREATE: &'static str = "WATERMARK_LABEL_CREATE";
7031 pub const WATERMARK_LABEL_DELETE: &'static str = "WATERMARK_LABEL_DELETE";
7032 pub const WORKFLOW_AUTOMATION_CREATE: &'static str = "WORKFLOW_AUTOMATION_CREATE";
7033 pub const WORKFLOW_AUTOMATION_DELETE: &'static str = "WORKFLOW_AUTOMATION_DELETE";
7034 pub const WORKFLOW_AUTOMATION_UPDATE: &'static str = "WORKFLOW_AUTOMATION_UPDATE";
7035}
7036
7037#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7038#[serde(transparent)]
7039pub struct EventsNextStreamPosition(pub serde_json::Value);
7040
7041#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7042#[serde(transparent)]
7043pub struct EventSourceItemType(pub String);
7044
7045impl EventSourceItemType {
7046 pub const FILE: &'static str = "file";
7047 pub const FOLDER: &'static str = "folder";
7048}
7049
7050#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7051pub struct EventSourceClassification {
7052 #[serde(default, skip_serializing_if = "Option::is_none")]
7053 pub name: Option<String>,
7054}
7055
7056#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7057pub struct FilePathCollection {
7058 pub total_count: i64,
7059 pub entries: Vec<FolderMini>,
7060}
7061
7062#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7063#[serde(transparent)]
7064pub struct SharedLinkAccess(pub String);
7065
7066impl SharedLinkAccess {
7067 pub const OPEN: &'static str = "open";
7068 pub const COMPANY: &'static str = "company";
7069 pub const COLLABORATORS: &'static str = "collaborators";
7070}
7071
7072#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7073#[serde(transparent)]
7074pub struct SharedLinkEffectivePermission(pub String);
7075
7076impl SharedLinkEffectivePermission {
7077 pub const CAN_EDIT: &'static str = "can_edit";
7078 pub const CAN_DOWNLOAD: &'static str = "can_download";
7079 pub const CAN_PREVIEW: &'static str = "can_preview";
7080 pub const NO_ACCESS: &'static str = "no_access";
7081}
7082
7083#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7084pub struct SharedLinkPermissions {
7085 #[serde(default, skip_serializing_if = "Option::is_none")]
7086 pub can_download: Option<bool>,
7087 #[serde(default, skip_serializing_if = "Option::is_none")]
7088 pub can_preview: Option<bool>,
7089 #[serde(default, skip_serializing_if = "Option::is_none")]
7090 pub can_edit: Option<bool>,
7091 #[serde(
7092 default,
7093 skip_serializing_if = "Option::is_none",
7094 deserialize_with = "double_option"
7095 )]
7096 pub shared_links_option: Option<Option<String>>,
7097 #[serde(
7098 default,
7099 skip_serializing_if = "Option::is_none",
7100 deserialize_with = "double_option"
7101 )]
7102 pub default_shared_link_type: Option<Option<String>>,
7103 #[serde(
7104 default,
7105 skip_serializing_if = "Option::is_none",
7106 deserialize_with = "double_option"
7107 )]
7108 pub notes_shared_link_option: Option<Option<String>>,
7109 #[serde(
7110 default,
7111 skip_serializing_if = "Option::is_none",
7112 deserialize_with = "double_option"
7113 )]
7114 pub default_notes_shared_link_type: Option<Option<String>>,
7115}
7116
7117#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7118pub struct FileSharedLink {
7119 pub url: String,
7120 #[serde(
7121 default,
7122 skip_serializing_if = "Option::is_none",
7123 deserialize_with = "double_option"
7124 )]
7125 pub download_url: Option<Option<String>>,
7126 #[serde(
7127 default,
7128 skip_serializing_if = "Option::is_none",
7129 deserialize_with = "double_option"
7130 )]
7131 pub vanity_url: Option<Option<String>>,
7132 #[serde(
7133 default,
7134 skip_serializing_if = "Option::is_none",
7135 deserialize_with = "double_option"
7136 )]
7137 pub vanity_name: Option<Option<String>>,
7138 #[serde(default, skip_serializing_if = "Option::is_none")]
7139 pub access: Option<SharedLinkAccess>,
7140 pub effective_access: SharedLinkAccess,
7141 pub effective_permission: SharedLinkEffectivePermission,
7142 #[serde(
7143 default,
7144 skip_serializing_if = "Option::is_none",
7145 deserialize_with = "double_option"
7146 )]
7147 pub unshared_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
7148 pub is_password_enabled: bool,
7149 #[serde(default, skip_serializing_if = "Option::is_none")]
7150 pub permissions: Option<SharedLinkPermissions>,
7151 pub download_count: i64,
7152 pub preview_count: i64,
7153}
7154
7155#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7156#[serde(transparent)]
7157pub struct FileItemStatus(pub String);
7158
7159impl FileItemStatus {
7160 pub const ACTIVE: &'static str = "active";
7161 pub const TRASHED: &'static str = "trashed";
7162 pub const DELETED: &'static str = "deleted";
7163}
7164
7165#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7166pub struct FileFullPermissions {
7167 pub can_delete: bool,
7168 pub can_download: bool,
7169 pub can_invite_collaborator: bool,
7170 pub can_rename: bool,
7171 pub can_set_share_access: bool,
7172 pub can_share: bool,
7173 pub can_annotate: bool,
7174 pub can_comment: bool,
7175 pub can_preview: bool,
7176 pub can_upload: bool,
7177 pub can_view_annotations_all: bool,
7178 pub can_view_annotations_self: bool,
7179 #[serde(default, skip_serializing_if = "Option::is_none")]
7180 pub can_apply_watermark: Option<bool>,
7181}
7182
7183#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7184#[serde(transparent)]
7185pub struct LockType(pub String);
7186
7187impl LockType {
7188 pub const LOCK: &'static str = "lock";
7189}
7190
7191#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7192#[serde(transparent)]
7193pub struct LockAppType(pub String);
7194
7195impl LockAppType {
7196 pub const GSUITE: &'static str = "gsuite";
7197 pub const OFFICE_WOPI: &'static str = "office_wopi";
7198 pub const OFFICE_WOPIPLUS: &'static str = "office_wopiplus";
7199 pub const OTHER: &'static str = "other";
7200}
7201
7202#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7203pub struct FileFullLock {
7204 #[serde(default, skip_serializing_if = "Option::is_none")]
7205 pub id: Option<String>,
7206 #[serde(default, skip_serializing_if = "Option::is_none")]
7207 pub r#type: Option<LockType>,
7208 #[serde(default, skip_serializing_if = "Option::is_none")]
7209 pub created_by: Option<UserMini>,
7210 #[serde(default, skip_serializing_if = "Option::is_none")]
7211 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
7212 #[serde(default, skip_serializing_if = "Option::is_none")]
7213 pub expired_at: Option<chrono::DateTime<chrono::Utc>>,
7214 #[serde(default, skip_serializing_if = "Option::is_none")]
7215 pub is_download_prevented: Option<bool>,
7216 #[serde(
7217 default,
7218 skip_serializing_if = "Option::is_none",
7219 deserialize_with = "double_option"
7220 )]
7221 pub app_type: Option<Option<LockAppType>>,
7222}
7223
7224#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7225pub struct FileFullExpiringEmbedLink {
7226 #[serde(default, skip_serializing_if = "Option::is_none")]
7227 pub access_token: Option<String>,
7228 #[serde(default, skip_serializing_if = "Option::is_none")]
7229 pub expires_in: Option<i64>,
7230 #[serde(default, skip_serializing_if = "Option::is_none")]
7231 pub token_type: Option<AccessTokenTokenType>,
7232 #[serde(default, skip_serializing_if = "Option::is_none")]
7233 pub restricted_to: Option<Vec<ResourceScope>>,
7234 #[serde(default, skip_serializing_if = "Option::is_none")]
7235 pub url: Option<String>,
7236}
7237
7238#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7239pub struct FileFullWatermarkInfo {
7240 #[serde(default, skip_serializing_if = "Option::is_none")]
7241 pub is_watermarked: Option<bool>,
7242 #[serde(default, skip_serializing_if = "Option::is_none")]
7243 pub is_watermark_inherited: Option<bool>,
7244 #[serde(default, skip_serializing_if = "Option::is_none")]
7245 pub is_watermarked_by_access_policy: Option<bool>,
7246}
7247
7248#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7249#[serde(transparent)]
7250pub struct FileFullAllowedInviteeRoles(pub String);
7251
7252impl FileFullAllowedInviteeRoles {
7253 pub const EDITOR: &'static str = "editor";
7254 pub const VIEWER: &'static str = "viewer";
7255 pub const PREVIEWER: &'static str = "previewer";
7256 pub const UPLOADER: &'static str = "uploader";
7257 pub const PREVIEWER_UPLOADER: &'static str = "previewer uploader";
7258 pub const VIEWER_UPLOADER: &'static str = "viewer uploader";
7259 pub const CO_OWNER: &'static str = "co-owner";
7260}
7261
7262#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7263pub struct EntriesContent {
7264 #[serde(default, skip_serializing_if = "Option::is_none")]
7265 pub url_template: Option<String>,
7266}
7267
7268#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7269pub struct EntriesInfo {
7270 #[serde(default, skip_serializing_if = "Option::is_none")]
7271 pub url: Option<String>,
7272}
7273
7274#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7275pub struct EntriesProperties {
7276 #[serde(default, skip_serializing_if = "Option::is_none")]
7277 pub dimensions: Option<String>,
7278 #[serde(default, skip_serializing_if = "Option::is_none")]
7279 pub paged: Option<String>,
7280 #[serde(default, skip_serializing_if = "Option::is_none")]
7281 pub thumb: Option<String>,
7282}
7283
7284#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7285#[serde(transparent)]
7286pub struct StatusState(pub String);
7287
7288impl StatusState {
7289 pub const SUCCESS: &'static str = "success";
7290 pub const VIEWABLE: &'static str = "viewable";
7291 pub const PENDING: &'static str = "pending";
7292 pub const NONE: &'static str = "none";
7293}
7294
7295#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7296pub struct EntriesStatus {
7297 #[serde(default, skip_serializing_if = "Option::is_none")]
7298 pub state: Option<StatusState>,
7299}
7300
7301#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7302pub struct RepresentationsEntries {
7303 #[serde(default, skip_serializing_if = "Option::is_none")]
7304 pub content: Option<EntriesContent>,
7305 #[serde(default, skip_serializing_if = "Option::is_none")]
7306 pub info: Option<EntriesInfo>,
7307 #[serde(default, skip_serializing_if = "Option::is_none")]
7308 pub properties: Option<EntriesProperties>,
7309 #[serde(default, skip_serializing_if = "Option::is_none")]
7310 pub representation: Option<String>,
7311 #[serde(default, skip_serializing_if = "Option::is_none")]
7312 pub status: Option<EntriesStatus>,
7313}
7314
7315#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7316pub struct FileFullRepresentations {
7317 #[serde(default, skip_serializing_if = "Option::is_none")]
7318 pub entries: Option<Vec<RepresentationsEntries>>,
7319}
7320
7321#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7322pub struct FileFullClassification {
7323 #[serde(default, skip_serializing_if = "Option::is_none")]
7324 pub name: Option<String>,
7325 #[serde(default, skip_serializing_if = "Option::is_none")]
7326 pub definition: Option<String>,
7327 #[serde(default, skip_serializing_if = "Option::is_none")]
7328 pub color: Option<String>,
7329}
7330
7331#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7332#[serde(transparent)]
7333pub struct FileFullSharedLinkPermissionOptions(pub String);
7334
7335impl FileFullSharedLinkPermissionOptions {
7336 pub const CAN_PREVIEW: &'static str = "can_preview";
7337 pub const CAN_DOWNLOAD: &'static str = "can_download";
7338 pub const CAN_EDIT: &'static str = "can_edit";
7339}
7340
7341#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7342#[serde(transparent)]
7343pub struct FileRequestType(pub String);
7344
7345impl FileRequestType {
7346 pub const FILE_REQUEST: &'static str = "file_request";
7347}
7348
7349#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7350#[serde(transparent)]
7351pub struct FileRequestStatus(pub String);
7352
7353impl FileRequestStatus {
7354 pub const ACTIVE: &'static str = "active";
7355 pub const INACTIVE: &'static str = "inactive";
7356}
7357
7358#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7359#[serde(transparent)]
7360pub struct FolderType(pub String);
7361
7362impl FolderType {
7363 pub const FOLDER: &'static str = "folder";
7364}
7365
7366#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7367pub struct FileRequestCopyRequestFolder {
7368 #[serde(default, skip_serializing_if = "Option::is_none")]
7369 pub r#type: Option<FolderType>,
7370 pub id: String,
7371}
7372
7373#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7374#[serde(transparent)]
7375pub struct FileVersionType(pub String);
7376
7377impl FileVersionType {
7378 pub const FILE_VERSION: &'static str = "file_version";
7379}
7380
7381#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7382#[serde(transparent)]
7383pub struct FileVersionLegalHoldType(pub String);
7384
7385impl FileVersionLegalHoldType {
7386 pub const FILE_VERSION_LEGAL_HOLD: &'static str = "file_version_legal_hold";
7387}
7388
7389#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7390#[serde(transparent)]
7391pub struct FileVersionRetentionType(pub String);
7392
7393impl FileVersionRetentionType {
7394 pub const FILE_VERSION_RETENTION: &'static str = "file_version_retention";
7395}
7396
7397#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7398#[serde(transparent)]
7399pub struct FolderUploadEmailAccess(pub String);
7400
7401impl FolderUploadEmailAccess {
7402 pub const OPEN: &'static str = "open";
7403 pub const COLLABORATORS: &'static str = "collaborators";
7404}
7405
7406#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7407pub struct FolderFolderUploadEmail {
7408 #[serde(default, skip_serializing_if = "Option::is_none")]
7409 pub access: Option<FolderUploadEmailAccess>,
7410 #[serde(default, skip_serializing_if = "Option::is_none")]
7411 pub email: Option<String>,
7412}
7413
7414#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7415#[serde(transparent)]
7416pub struct FolderFullSyncState(pub String);
7417
7418impl FolderFullSyncState {
7419 pub const SYNCED: &'static str = "synced";
7420 pub const NOT_SYNCED: &'static str = "not_synced";
7421 pub const PARTIALLY_SYNCED: &'static str = "partially_synced";
7422}
7423
7424#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7425pub struct FolderFullPermissions {
7426 pub can_delete: bool,
7427 pub can_download: bool,
7428 pub can_invite_collaborator: bool,
7429 pub can_rename: bool,
7430 pub can_set_share_access: bool,
7431 pub can_share: bool,
7432 pub can_upload: bool,
7433 #[serde(default, skip_serializing_if = "Option::is_none")]
7434 pub can_apply_watermark: Option<bool>,
7435}
7436
7437#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7438pub struct FolderLockLockedOperations {
7439 pub r#move: bool,
7440 pub delete: bool,
7441}
7442
7443#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7444#[serde(transparent)]
7445pub struct GroupType(pub String);
7446
7447impl GroupType {
7448 pub const GROUP: &'static str = "group";
7449}
7450
7451#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7452#[serde(transparent)]
7453pub struct GroupGroupType(pub String);
7454
7455impl GroupGroupType {
7456 pub const MANAGED_GROUP: &'static str = "managed_group";
7457 pub const ALL_USERS_GROUP: &'static str = "all_users_group";
7458}
7459
7460#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7461#[serde(transparent)]
7462pub struct GroupFullInvitabilityLevel(pub String);
7463
7464impl GroupFullInvitabilityLevel {
7465 pub const ADMINS_ONLY: &'static str = "admins_only";
7466 pub const ADMINS_AND_MEMBERS: &'static str = "admins_and_members";
7467 pub const ALL_MANAGED_USERS: &'static str = "all_managed_users";
7468}
7469
7470#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7471pub struct GroupFullPermissions {
7472 #[serde(default, skip_serializing_if = "Option::is_none")]
7473 pub can_invite_as_collaborator: Option<bool>,
7474}
7475
7476#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7477#[serde(transparent)]
7478pub struct GroupMembershipType(pub String);
7479
7480impl GroupMembershipType {
7481 pub const GROUP_MEMBERSHIP: &'static str = "group_membership";
7482}
7483
7484#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7485#[serde(transparent)]
7486pub struct GroupMembershipRole(pub String);
7487
7488impl GroupMembershipRole {
7489 pub const MEMBER: &'static str = "member";
7490 pub const ADMIN: &'static str = "admin";
7491}
7492
7493#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7494#[serde(transparent)]
7495pub struct IntegrationMappingType(pub String);
7496
7497impl IntegrationMappingType {
7498 pub const INTEGRATION_MAPPING: &'static str = "integration_mapping";
7499}
7500
7501#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7502#[serde(transparent)]
7503pub struct IntegrationMappingIntegrationType(pub String);
7504
7505impl IntegrationMappingIntegrationType {
7506 pub const SLACK: &'static str = "slack";
7507}
7508
7509#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7510#[serde(transparent)]
7511pub struct IntegrationMappingPartnerItemSlackType(pub String);
7512
7513impl IntegrationMappingPartnerItemSlackType {
7514 pub const CHANNEL: &'static str = "channel";
7515}
7516
7517#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7518#[serde(transparent)]
7519pub struct IntegrationMappingPartnerItemTeamsType(pub String);
7520
7521impl IntegrationMappingPartnerItemTeamsType {
7522 pub const CHANNEL: &'static str = "channel";
7523 pub const TEAM: &'static str = "team";
7524}
7525
7526#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7527#[serde(transparent)]
7528pub struct IntegrationMappingTeamsIntegrationType(pub String);
7529
7530impl IntegrationMappingTeamsIntegrationType {
7531 pub const TEAMS: &'static str = "teams";
7532}
7533
7534#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7535#[serde(transparent)]
7536pub struct InviteType(pub String);
7537
7538impl InviteType {
7539 pub const INVITE: &'static str = "invite";
7540}
7541
7542#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7543#[serde(transparent)]
7544pub struct KeywordSkillCardType(pub String);
7545
7546impl KeywordSkillCardType {
7547 pub const SKILL_CARD: &'static str = "skill_card";
7548}
7549
7550#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7551#[serde(transparent)]
7552pub struct KeywordSkillCardSkillCardType(pub String);
7553
7554impl KeywordSkillCardSkillCardType {
7555 pub const KEYWORD: &'static str = "keyword";
7556}
7557
7558#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7559pub struct KeywordSkillCardSkillCardTitle {
7560 #[serde(default, skip_serializing_if = "Option::is_none")]
7561 pub code: Option<String>,
7562 pub message: String,
7563}
7564
7565#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7566#[serde(transparent)]
7567pub struct SkillType(pub String);
7568
7569impl SkillType {
7570 pub const SERVICE: &'static str = "service";
7571}
7572
7573#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7574pub struct KeywordSkillCardSkill {
7575 pub r#type: SkillType,
7576 pub id: String,
7577}
7578
7579#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7580#[serde(transparent)]
7581pub struct InvocationType(pub String);
7582
7583impl InvocationType {
7584 pub const SKILL_INVOCATION: &'static str = "skill_invocation";
7585}
7586
7587#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7588pub struct KeywordSkillCardInvocation {
7589 pub r#type: InvocationType,
7590 pub id: String,
7591}
7592
7593#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7594pub struct KeywordSkillCardEntries {
7595 #[serde(default, skip_serializing_if = "Option::is_none")]
7596 pub text: Option<String>,
7597}
7598
7599#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7600#[serde(transparent)]
7601pub struct LegalHoldPolicyType(pub String);
7602
7603impl LegalHoldPolicyType {
7604 pub const LEGAL_HOLD_POLICY: &'static str = "legal_hold_policy";
7605}
7606
7607#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7608#[serde(transparent)]
7609pub struct LegalHoldPolicyStatus(pub String);
7610
7611impl LegalHoldPolicyStatus {
7612 pub const ACTIVE: &'static str = "active";
7613 pub const APPLYING: &'static str = "applying";
7614 pub const RELEASING: &'static str = "releasing";
7615 pub const RELEASED: &'static str = "released";
7616}
7617
7618#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7619pub struct LegalHoldPolicyAssignmentCounts {
7620 #[serde(default, skip_serializing_if = "Option::is_none")]
7621 pub user: Option<i64>,
7622 #[serde(default, skip_serializing_if = "Option::is_none")]
7623 pub folder: Option<i64>,
7624 #[serde(default, skip_serializing_if = "Option::is_none")]
7625 pub file: Option<i64>,
7626 #[serde(default, skip_serializing_if = "Option::is_none")]
7627 pub file_version: Option<i64>,
7628 #[serde(default, skip_serializing_if = "Option::is_none")]
7629 pub ownership: Option<i64>,
7630 #[serde(default, skip_serializing_if = "Option::is_none")]
7631 pub interactions: Option<i64>,
7632}
7633
7634#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7635#[serde(transparent)]
7636pub struct LegalHoldPolicyAssignedItemType(pub String);
7637
7638impl LegalHoldPolicyAssignedItemType {
7639 pub const FILE: &'static str = "file";
7640 pub const FILE_VERSION: &'static str = "file_version";
7641 pub const FOLDER: &'static str = "folder";
7642 pub const USER: &'static str = "user";
7643 pub const OWNERSHIP: &'static str = "ownership";
7644 pub const INTERACTIONS: &'static str = "interactions";
7645}
7646
7647#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7648#[serde(transparent)]
7649pub struct LegalHoldPolicyAssignmentType(pub String);
7650
7651impl LegalHoldPolicyAssignmentType {
7652 pub const LEGAL_HOLD_POLICY_ASSIGNMENT: &'static str = "legal_hold_policy_assignment";
7653}
7654
7655#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7656#[serde(transparent)]
7657pub struct MetadataCascadePolicyType(pub String);
7658
7659impl MetadataCascadePolicyType {
7660 pub const METADATA_CASCADE_POLICY: &'static str = "metadata_cascade_policy";
7661}
7662
7663#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7664pub struct MetadataCascadePolicyOwnerEnterprise {
7665 #[serde(default, skip_serializing_if = "Option::is_none")]
7666 pub r#type: Option<EnterpriseType>,
7667 #[serde(default, skip_serializing_if = "Option::is_none")]
7668 pub id: Option<String>,
7669}
7670
7671#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7672pub struct MetadataCascadePolicyParent {
7673 #[serde(default, skip_serializing_if = "Option::is_none")]
7674 pub r#type: Option<FolderType>,
7675 #[serde(default, skip_serializing_if = "Option::is_none")]
7676 pub id: Option<String>,
7677}
7678
7679#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7680#[serde(transparent)]
7681pub struct MetadataFilterScope(pub String);
7682
7683impl MetadataFilterScope {
7684 pub const GLOBAL: &'static str = "global";
7685 pub const ENTERPRISE: &'static str = "enterprise";
7686 pub const ENTERPRISE_ENTERPRISE_ID: &'static str = "enterprise_{enterprise_id}";
7687}
7688
7689#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7690#[serde(transparent)]
7691pub struct OrderByDirection(pub String);
7692
7693impl OrderByDirection {
7694 pub const ASC: &'static str = "ASC";
7695 pub const DESC: &'static str = "DESC";
7696 pub const ASC_2: &'static str = "asc";
7697 pub const DESC_2: &'static str = "desc";
7698}
7699
7700#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7701pub struct MetadataQueryOrderBy {
7702 #[serde(default, skip_serializing_if = "Option::is_none")]
7703 pub field_key: Option<String>,
7704 #[serde(default, skip_serializing_if = "Option::is_none")]
7705 pub direction: Option<OrderByDirection>,
7706}
7707
7708#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7709#[serde(transparent)]
7710pub struct FieldsType2(pub String);
7711
7712impl FieldsType2 {
7713 pub const STRING: &'static str = "string";
7714 pub const FLOAT: &'static str = "float";
7715 pub const DATE: &'static str = "date";
7716 pub const ENUM: &'static str = "enum";
7717 pub const MULTISELECT: &'static str = "multiSelect";
7718 pub const TAXONOMY: &'static str = "taxonomy";
7719 pub const INTEGER: &'static str = "integer";
7720}
7721
7722#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7723pub struct FieldsOptions3 {
7724 pub key: String,
7725 #[serde(default, skip_serializing_if = "Option::is_none")]
7726 pub id: Option<String>,
7727}
7728
7729#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7730pub struct FieldsOptionsRules {
7731 #[serde(
7732 rename = "multiSelect",
7733 default,
7734 skip_serializing_if = "Option::is_none"
7735 )]
7736 pub multi_select: Option<bool>,
7737 #[serde(
7738 rename = "selectableLevels",
7739 default,
7740 skip_serializing_if = "Option::is_none"
7741 )]
7742 pub selectable_levels: Option<Vec<i64>>,
7743}
7744
7745#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7746pub struct MetadataTemplateFields {
7747 pub r#type: FieldsType2,
7748 pub key: String,
7749 #[serde(rename = "displayName")]
7750 pub display_name: String,
7751 #[serde(default, skip_serializing_if = "Option::is_none")]
7752 pub description: Option<String>,
7753 #[serde(default, skip_serializing_if = "Option::is_none")]
7754 pub hidden: Option<bool>,
7755 #[serde(default, skip_serializing_if = "Option::is_none")]
7756 pub options: Option<Vec<FieldsOptions3>>,
7757 #[serde(
7758 rename = "taxonomyKey",
7759 default,
7760 skip_serializing_if = "Option::is_none"
7761 )]
7762 pub taxonomy_key: Option<String>,
7763 #[serde(
7764 rename = "taxonomyId",
7765 default,
7766 skip_serializing_if = "Option::is_none"
7767 )]
7768 pub taxonomy_id: Option<String>,
7769 #[serde(default, skip_serializing_if = "Option::is_none")]
7770 pub namespace: Option<String>,
7771 #[serde(
7772 rename = "optionsRules",
7773 default,
7774 skip_serializing_if = "Option::is_none"
7775 )]
7776 pub options_rules: Option<FieldsOptionsRules>,
7777 #[serde(default, skip_serializing_if = "Option::is_none")]
7778 pub id: Option<String>,
7779}
7780
7781#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7782#[serde(transparent)]
7783pub struct PostOAuth2TokenGrantType(pub String);
7784
7785impl PostOAuth2TokenGrantType {
7786 pub const AUTHORIZATION_CODE: &'static str = "authorization_code";
7787 pub const REFRESH_TOKEN: &'static str = "refresh_token";
7788 pub const CLIENT_CREDENTIALS: &'static str = "client_credentials";
7789 pub const URN_IETF_PARAMS_OAUTH_GRANT_TYPE_JWT_BEARER: &'static str =
7790 "urn:ietf:params:oauth:grant-type:jwt-bearer";
7791 pub const URN_IETF_PARAMS_OAUTH_GRANT_TYPE_TOKEN_EXCHANGE: &'static str =
7792 "urn:ietf:params:oauth:grant-type:token-exchange";
7793}
7794
7795#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7796#[serde(transparent)]
7797pub struct PostOAuth2TokenActorTokenType(pub String);
7798
7799impl PostOAuth2TokenActorTokenType {
7800 pub const URN_IETF_PARAMS_OAUTH_TOKEN_TYPE_ID_TOKEN: &'static str =
7801 "urn:ietf:params:oauth:token-type:id_token";
7802}
7803
7804#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7805#[serde(transparent)]
7806pub struct PostOAuth2TokenBoxSubjectType(pub String);
7807
7808impl PostOAuth2TokenBoxSubjectType {
7809 pub const ENTERPRISE: &'static str = "enterprise";
7810 pub const USER: &'static str = "user";
7811}
7812
7813#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7814#[serde(transparent)]
7815pub struct PostOAuth2TokenRefreshAccessTokenGrantType(pub String);
7816
7817impl PostOAuth2TokenRefreshAccessTokenGrantType {
7818 pub const REFRESH_TOKEN: &'static str = "refresh_token";
7819}
7820
7821#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7822#[serde(transparent)]
7823pub struct RecentItemInteractionType(pub String);
7824
7825impl RecentItemInteractionType {
7826 pub const ITEM_PREVIEW: &'static str = "item_preview";
7827 pub const ITEM_UPLOAD: &'static str = "item_upload";
7828 pub const ITEM_COMMENT: &'static str = "item_comment";
7829 pub const ITEM_OPEN: &'static str = "item_open";
7830 pub const ITEM_MODIFY: &'static str = "item_modify";
7831}
7832
7833#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7834#[serde(transparent)]
7835pub struct ResourceScopeScope(pub String);
7836
7837impl ResourceScopeScope {
7838 pub const ANNOTATION_EDIT: &'static str = "annotation_edit";
7839 pub const ANNOTATION_VIEW_ALL: &'static str = "annotation_view_all";
7840 pub const ANNOTATION_VIEW_SELF: &'static str = "annotation_view_self";
7841 pub const BASE_EXPLORER: &'static str = "base_explorer";
7842 pub const BASE_PICKER: &'static str = "base_picker";
7843 pub const BASE_PREVIEW: &'static str = "base_preview";
7844 pub const BASE_UPLOAD: &'static str = "base_upload";
7845 pub const ITEM_DELETE: &'static str = "item_delete";
7846 pub const ITEM_DOWNLOAD: &'static str = "item_download";
7847 pub const ITEM_PREVIEW: &'static str = "item_preview";
7848 pub const ITEM_RENAME: &'static str = "item_rename";
7849 pub const ITEM_SHARE: &'static str = "item_share";
7850 pub const ITEM_UPLOAD: &'static str = "item_upload";
7851 pub const ITEM_READ: &'static str = "item_read";
7852}
7853
7854#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7855#[serde(transparent)]
7856pub struct RetentionPolicyType(pub String);
7857
7858impl RetentionPolicyType {
7859 pub const RETENTION_POLICY: &'static str = "retention_policy";
7860}
7861
7862#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7863#[serde(transparent)]
7864pub struct RetentionPolicyDispositionAction(pub String);
7865
7866impl RetentionPolicyDispositionAction {
7867 pub const PERMANENTLY_DELETE: &'static str = "permanently_delete";
7868 pub const REMOVE_RETENTION: &'static str = "remove_retention";
7869}
7870
7871#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7872#[serde(transparent)]
7873pub struct RetentionPolicyPolicyType(pub String);
7874
7875impl RetentionPolicyPolicyType {
7876 pub const FINITE: &'static str = "finite";
7877 pub const INDEFINITE: &'static str = "indefinite";
7878}
7879
7880#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7881#[serde(transparent)]
7882pub struct RetentionPolicyRetentionType(pub String);
7883
7884impl RetentionPolicyRetentionType {
7885 pub const MODIFIABLE: &'static str = "modifiable";
7886 pub const NON_MODIFIABLE: &'static str = "non_modifiable";
7887}
7888
7889#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7890#[serde(transparent)]
7891pub struct RetentionPolicyStatus(pub String);
7892
7893impl RetentionPolicyStatus {
7894 pub const ACTIVE: &'static str = "active";
7895 pub const RETIRED: &'static str = "retired";
7896}
7897
7898#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7899pub struct RetentionPolicyAssignmentCounts {
7900 #[serde(default, skip_serializing_if = "Option::is_none")]
7901 pub enterprise: Option<i64>,
7902 #[serde(default, skip_serializing_if = "Option::is_none")]
7903 pub folder: Option<i64>,
7904 #[serde(default, skip_serializing_if = "Option::is_none")]
7905 pub metadata_template: Option<i64>,
7906}
7907
7908#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7909#[serde(transparent)]
7910pub struct RetentionPolicyAssignmentType(pub String);
7911
7912impl RetentionPolicyAssignmentType {
7913 pub const RETENTION_POLICY_ASSIGNMENT: &'static str = "retention_policy_assignment";
7914}
7915
7916#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7917#[serde(transparent)]
7918pub struct AssignedToType(pub String);
7919
7920impl AssignedToType {
7921 pub const FOLDER: &'static str = "folder";
7922 pub const ENTERPRISE: &'static str = "enterprise";
7923 pub const METADATA_TEMPLATE: &'static str = "metadata_template";
7924}
7925
7926#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7927pub struct RetentionPolicyAssignmentAssignedTo {
7928 #[serde(
7929 default,
7930 skip_serializing_if = "Option::is_none",
7931 deserialize_with = "double_option"
7932 )]
7933 pub id: Option<Option<String>>,
7934 #[serde(default, skip_serializing_if = "Option::is_none")]
7935 pub r#type: Option<AssignedToType>,
7936}
7937
7938#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
7939pub struct RetentionPolicyAssignmentFilterFields {
7940 #[serde(
7941 default,
7942 skip_serializing_if = "Option::is_none",
7943 deserialize_with = "double_option"
7944 )]
7945 pub field: Option<Option<String>>,
7946 #[serde(
7947 default,
7948 skip_serializing_if = "Option::is_none",
7949 deserialize_with = "double_option"
7950 )]
7951 pub value: Option<Option<String>>,
7952}
7953
7954#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7955#[serde(transparent)]
7956pub struct RetentionPolicyMaxExtensionLengthRequestVariant0(pub String);
7957
7958impl RetentionPolicyMaxExtensionLengthRequestVariant0 {
7959 pub const NONE: &'static str = "none";
7960}
7961
7962#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7963#[serde(transparent)]
7964pub struct RoleVariableVariableType(pub String);
7965
7966impl RoleVariableVariableType {
7967 pub const COLLABORATOR_ROLE: &'static str = "collaborator_role";
7968}
7969
7970#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7971#[serde(transparent)]
7972pub struct SearchResultsType(pub String);
7973
7974impl SearchResultsType {
7975 pub const SEARCH_RESULTS_ITEMS: &'static str = "search_results_items";
7976}
7977
7978#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7979#[serde(transparent)]
7980pub struct SearchResultsWithSharedLinksType(pub String);
7981
7982impl SearchResultsWithSharedLinksType {
7983 pub const SEARCH_RESULTS_WITH_SHARED_LINKS: &'static str = "search_results_with_shared_links";
7984}
7985
7986#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7987#[serde(transparent)]
7988pub struct ShieldInformationBarrierType(pub String);
7989
7990impl ShieldInformationBarrierType {
7991 pub const SHIELD_INFORMATION_BARRIER: &'static str = "shield_information_barrier";
7992}
7993
7994#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
7995#[serde(transparent)]
7996pub struct ShieldInformationBarrierStatus(pub String);
7997
7998impl ShieldInformationBarrierStatus {
7999 pub const DRAFT: &'static str = "draft";
8000 pub const PENDING: &'static str = "pending";
8001 pub const DISABLED: &'static str = "disabled";
8002 pub const ENABLED: &'static str = "enabled";
8003 pub const INVALID: &'static str = "invalid";
8004}
8005
8006#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8007#[serde(transparent)]
8008pub struct ShieldInformationBarrierReportType(pub String);
8009
8010impl ShieldInformationBarrierReportType {
8011 pub const SHIELD_INFORMATION_BARRIER_REPORT: &'static str = "shield_information_barrier_report";
8012}
8013
8014#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8015#[serde(transparent)]
8016pub struct ShieldInformationBarrierReportStatus(pub String);
8017
8018impl ShieldInformationBarrierReportStatus {
8019 pub const PENDING: &'static str = "pending";
8020 pub const ERROR: &'static str = "error";
8021 pub const DONE: &'static str = "done";
8022 pub const CANCELLED: &'static str = "cancelled";
8023}
8024
8025#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8026pub struct ShieldInformationBarrierReportDetailsDetails {
8027 #[serde(default, skip_serializing_if = "Option::is_none")]
8028 pub folder_id: Option<String>,
8029}
8030
8031#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8032#[serde(transparent)]
8033pub struct ShieldInformationBarrierSegmentType(pub String);
8034
8035impl ShieldInformationBarrierSegmentType {
8036 pub const SHIELD_INFORMATION_BARRIER_SEGMENT: &'static str =
8037 "shield_information_barrier_segment";
8038}
8039
8040#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8041#[serde(transparent)]
8042pub struct ShieldInformationBarrierSegmentMemberType(pub String);
8043
8044impl ShieldInformationBarrierSegmentMemberType {
8045 pub const SHIELD_INFORMATION_BARRIER_SEGMENT_MEMBER: &'static str =
8046 "shield_information_barrier_segment_member";
8047}
8048
8049#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8050pub struct ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment {
8051 #[serde(default, skip_serializing_if = "Option::is_none")]
8052 pub id: Option<String>,
8053 #[serde(default, skip_serializing_if = "Option::is_none")]
8054 pub r#type: Option<ShieldInformationBarrierSegmentType>,
8055}
8056
8057#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8058#[serde(transparent)]
8059pub struct ShieldInformationBarrierSegmentRestrictionType(pub String);
8060
8061impl ShieldInformationBarrierSegmentRestrictionType {
8062 pub const SHIELD_INFORMATION_BARRIER_SEGMENT_RESTRICTION: &'static str =
8063 "shield_information_barrier_segment_restriction";
8064}
8065
8066#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8067#[serde(transparent)]
8068pub struct SignRequestType(pub String);
8069
8070impl SignRequestType {
8071 pub const SIGN_REQUEST: &'static str = "sign-request";
8072}
8073
8074#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8075#[serde(transparent)]
8076pub struct SignRequestStatus(pub String);
8077
8078impl SignRequestStatus {
8079 pub const CONVERTING: &'static str = "converting";
8080 pub const CREATED: &'static str = "created";
8081 pub const SENT: &'static str = "sent";
8082 pub const VIEWED: &'static str = "viewed";
8083 pub const SIGNED: &'static str = "signed";
8084 pub const CANCELLED: &'static str = "cancelled";
8085 pub const DECLINED: &'static str = "declined";
8086 pub const ERROR: &'static str = "error";
8087 pub const ERROR_CONVERTING: &'static str = "error_converting";
8088 pub const ERROR_SENDING: &'static str = "error_sending";
8089 pub const EXPIRED: &'static str = "expired";
8090 pub const FINALIZING: &'static str = "finalizing";
8091 pub const ERROR_FINALIZING: &'static str = "error_finalizing";
8092}
8093
8094#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8095pub struct SignRequestSignFiles {
8096 #[serde(default, skip_serializing_if = "Option::is_none")]
8097 pub files: Option<Vec<FileMini>>,
8098 #[serde(default, skip_serializing_if = "Option::is_none")]
8099 pub is_ready_for_download: Option<bool>,
8100}
8101
8102#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8103#[serde(transparent)]
8104pub struct SignRequestCreateRequestSignatureColor(pub String);
8105
8106impl SignRequestCreateRequestSignatureColor {
8107 pub const BLUE: &'static str = "blue";
8108 pub const BLACK: &'static str = "black";
8109 pub const RED: &'static str = "red";
8110}
8111
8112#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8113#[serde(transparent)]
8114pub struct SignRequestCreateSignerRole(pub String);
8115
8116impl SignRequestCreateSignerRole {
8117 pub const SIGNER: &'static str = "signer";
8118 pub const APPROVER: &'static str = "approver";
8119 pub const FINAL_COPY_READER: &'static str = "final_copy_reader";
8120}
8121
8122#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8123#[serde(transparent)]
8124pub struct SignerDecisionType(pub String);
8125
8126impl SignerDecisionType {
8127 pub const SIGNED: &'static str = "signed";
8128 pub const DECLINED: &'static str = "declined";
8129}
8130
8131#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8132pub struct SignRequestSignerSignerDecision {
8133 #[serde(default, skip_serializing_if = "Option::is_none")]
8134 pub r#type: Option<SignerDecisionType>,
8135 #[serde(default, skip_serializing_if = "Option::is_none")]
8136 pub finalized_at: Option<chrono::DateTime<chrono::Utc>>,
8137 #[serde(
8138 default,
8139 skip_serializing_if = "Option::is_none",
8140 deserialize_with = "double_option"
8141 )]
8142 pub additional_info: Option<Option<String>>,
8143}
8144
8145#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8146#[serde(transparent)]
8147pub struct SignRequestSignerInputType(pub String);
8148
8149impl SignRequestSignerInputType {
8150 pub const SIGNATURE: &'static str = "signature";
8151 pub const DATE: &'static str = "date";
8152 pub const TEXT: &'static str = "text";
8153 pub const CHECKBOX: &'static str = "checkbox";
8154 pub const RADIO: &'static str = "radio";
8155 pub const DROPDOWN: &'static str = "dropdown";
8156}
8157
8158#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8159#[serde(transparent)]
8160pub struct SignRequestSignerInputContentType(pub String);
8161
8162impl SignRequestSignerInputContentType {
8163 pub const SIGNATURE: &'static str = "signature";
8164 pub const INITIAL: &'static str = "initial";
8165 pub const STAMP: &'static str = "stamp";
8166 pub const DATE: &'static str = "date";
8167 pub const CHECKBOX: &'static str = "checkbox";
8168 pub const TEXT: &'static str = "text";
8169 pub const FULL_NAME: &'static str = "full_name";
8170 pub const FIRST_NAME: &'static str = "first_name";
8171 pub const LAST_NAME: &'static str = "last_name";
8172 pub const COMPANY: &'static str = "company";
8173 pub const TITLE: &'static str = "title";
8174 pub const EMAIL: &'static str = "email";
8175 pub const ATTACHMENT: &'static str = "attachment";
8176 pub const RADIO: &'static str = "radio";
8177 pub const DROPDOWN: &'static str = "dropdown";
8178}
8179
8180#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8181#[serde(transparent)]
8182pub struct SignRequestSignerInputValidation2(pub serde_json::Value);
8183
8184#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8185#[serde(transparent)]
8186pub struct SignRequestSignerInputCustomValidationValidationType(pub String);
8187
8188impl SignRequestSignerInputCustomValidationValidationType {
8189 pub const CUSTOM: &'static str = "custom";
8190}
8191
8192#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8193#[serde(transparent)]
8194pub struct SignRequestSignerInputDateAsiaValidationValidationType(pub String);
8195
8196impl SignRequestSignerInputDateAsiaValidationValidationType {
8197 pub const DATE_ASIA: &'static str = "date_asia";
8198}
8199
8200#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8201#[serde(transparent)]
8202pub struct SignRequestSignerInputDateEUValidationValidationType(pub String);
8203
8204impl SignRequestSignerInputDateEUValidationValidationType {
8205 pub const DATE_EU: &'static str = "date_eu";
8206}
8207
8208#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8209#[serde(transparent)]
8210pub struct SignRequestSignerInputDateISOValidationValidationType(pub String);
8211
8212impl SignRequestSignerInputDateISOValidationValidationType {
8213 pub const DATE_ISO: &'static str = "date_iso";
8214}
8215
8216#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8217#[serde(transparent)]
8218pub struct SignRequestSignerInputDateUSValidationValidationType(pub String);
8219
8220impl SignRequestSignerInputDateUSValidationValidationType {
8221 pub const DATE_US: &'static str = "date_us";
8222}
8223
8224#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8225#[serde(transparent)]
8226pub struct SignRequestSignerInputEmailValidationValidationType(pub String);
8227
8228impl SignRequestSignerInputEmailValidationValidationType {
8229 pub const EMAIL: &'static str = "email";
8230}
8231
8232#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8233#[serde(transparent)]
8234pub struct SignRequestSignerInputNumberWithCommaValidationValidationType(pub String);
8235
8236impl SignRequestSignerInputNumberWithCommaValidationValidationType {
8237 pub const NUMBER_WITH_COMMA: &'static str = "number_with_comma";
8238}
8239
8240#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8241#[serde(transparent)]
8242pub struct SignRequestSignerInputNumberWithPeriodValidationValidationType(pub String);
8243
8244impl SignRequestSignerInputNumberWithPeriodValidationValidationType {
8245 pub const NUMBER_WITH_PERIOD: &'static str = "number_with_period";
8246}
8247
8248#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8249#[serde(transparent)]
8250pub struct SignRequestSignerInputSSNValidationValidationType(pub String);
8251
8252impl SignRequestSignerInputSSNValidationValidationType {
8253 pub const SSN: &'static str = "ssn";
8254}
8255
8256#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8257#[serde(transparent)]
8258pub struct SignRequestSignerInputZIP4ValidationValidationType(pub String);
8259
8260impl SignRequestSignerInputZIP4ValidationValidationType {
8261 pub const ZIP_4: &'static str = "zip_4";
8262}
8263
8264#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8265#[serde(transparent)]
8266pub struct SignRequestSignerInputZIPValidationValidationType(pub String);
8267
8268impl SignRequestSignerInputZIPValidationValidationType {
8269 pub const ZIP: &'static str = "zip";
8270}
8271
8272#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8273#[serde(transparent)]
8274pub struct SignTemplateType(pub String);
8275
8276impl SignTemplateType {
8277 pub const SIGN_TEMPLATE: &'static str = "sign-template";
8278}
8279
8280#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8281#[serde(transparent)]
8282pub struct AdditionalInfoNonEditable(pub String);
8283
8284impl AdditionalInfoNonEditable {
8285 pub const EMAIL_SUBJECT: &'static str = "email_subject";
8286 pub const EMAIL_MESSAGE: &'static str = "email_message";
8287 pub const NAME: &'static str = "name";
8288 pub const DAYS_VALID: &'static str = "days_valid";
8289 pub const SIGNERS: &'static str = "signers";
8290 pub const SOURCE_FILES: &'static str = "source_files";
8291}
8292
8293#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8294pub struct AdditionalInfoRequired {
8295 #[serde(default, skip_serializing_if = "Option::is_none")]
8296 pub signers: Option<Vec<Vec<SignRequestSignerInputEmailValidationValidationType>>>,
8297}
8298
8299#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8300pub struct SignTemplateAdditionalInfo {
8301 #[serde(default, skip_serializing_if = "Option::is_none")]
8302 pub non_editable: Option<Vec<AdditionalInfoNonEditable>>,
8303 #[serde(default, skip_serializing_if = "Option::is_none")]
8304 pub required: Option<AdditionalInfoRequired>,
8305}
8306
8307#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8308pub struct SignTemplateReadySignLink {
8309 #[serde(default, skip_serializing_if = "Option::is_none")]
8310 pub url: Option<String>,
8311 #[serde(
8312 default,
8313 skip_serializing_if = "Option::is_none",
8314 deserialize_with = "double_option"
8315 )]
8316 pub name: Option<Option<String>>,
8317 #[serde(
8318 default,
8319 skip_serializing_if = "Option::is_none",
8320 deserialize_with = "double_option"
8321 )]
8322 pub instructions: Option<Option<String>>,
8323 #[serde(
8324 default,
8325 skip_serializing_if = "Option::is_none",
8326 deserialize_with = "double_option"
8327 )]
8328 pub folder_id: Option<Option<String>>,
8329 #[serde(default, skip_serializing_if = "Option::is_none")]
8330 pub is_notification_disabled: Option<bool>,
8331 #[serde(default, skip_serializing_if = "Option::is_none")]
8332 pub is_active: Option<bool>,
8333}
8334
8335#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8336pub struct SignTemplateCustomBranding {
8337 #[serde(
8338 default,
8339 skip_serializing_if = "Option::is_none",
8340 deserialize_with = "double_option"
8341 )]
8342 pub company_name: Option<Option<String>>,
8343 #[serde(
8344 default,
8345 skip_serializing_if = "Option::is_none",
8346 deserialize_with = "double_option"
8347 )]
8348 pub logo_uri: Option<Option<String>>,
8349 #[serde(
8350 default,
8351 skip_serializing_if = "Option::is_none",
8352 deserialize_with = "double_option"
8353 )]
8354 pub branding_color: Option<Option<String>>,
8355 #[serde(
8356 default,
8357 skip_serializing_if = "Option::is_none",
8358 deserialize_with = "double_option"
8359 )]
8360 pub email_footer_text: Option<Option<String>>,
8361}
8362
8363#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8364#[serde(transparent)]
8365pub struct StatusSkillCardSkillCardType(pub String);
8366
8367impl StatusSkillCardSkillCardType {
8368 pub const STATUS: &'static str = "status";
8369}
8370
8371#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8372#[serde(transparent)]
8373pub struct StatusCode(pub String);
8374
8375impl StatusCode {
8376 pub const INVOKED: &'static str = "invoked";
8377 pub const PROCESSING: &'static str = "processing";
8378 pub const SUCCESS: &'static str = "success";
8379 pub const TRANSIENT_FAILURE: &'static str = "transient_failure";
8380 pub const PERMANENT_FAILURE: &'static str = "permanent_failure";
8381}
8382
8383#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8384pub struct StatusSkillCardStatus {
8385 pub code: StatusCode,
8386 #[serde(default, skip_serializing_if = "Option::is_none")]
8387 pub message: Option<String>,
8388}
8389
8390#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8391#[serde(transparent)]
8392pub struct StoragePolicyType(pub String);
8393
8394impl StoragePolicyType {
8395 pub const STORAGE_POLICY: &'static str = "storage_policy";
8396}
8397
8398#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8399#[serde(transparent)]
8400pub struct StoragePolicyAssignmentType(pub String);
8401
8402impl StoragePolicyAssignmentType {
8403 pub const STORAGE_POLICY_ASSIGNMENT: &'static str = "storage_policy_assignment";
8404}
8405
8406#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8407#[serde(transparent)]
8408pub struct TaskType(pub String);
8409
8410impl TaskType {
8411 pub const TASK: &'static str = "task";
8412}
8413
8414#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8415#[serde(transparent)]
8416pub struct TaskAction(pub String);
8417
8418impl TaskAction {
8419 pub const REVIEW: &'static str = "review";
8420 pub const COMPLETE: &'static str = "complete";
8421}
8422
8423#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8424#[serde(transparent)]
8425pub struct TaskCompletionRule(pub String);
8426
8427impl TaskCompletionRule {
8428 pub const ALL_ASSIGNEES: &'static str = "all_assignees";
8429 pub const ANY_ASSIGNEE: &'static str = "any_assignee";
8430}
8431
8432#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8433#[serde(transparent)]
8434pub struct TaskAssignmentType(pub String);
8435
8436impl TaskAssignmentType {
8437 pub const TASK_ASSIGNMENT: &'static str = "task_assignment";
8438}
8439
8440#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8441#[serde(transparent)]
8442pub struct TaskAssignmentResolutionState(pub String);
8443
8444impl TaskAssignmentResolutionState {
8445 pub const COMPLETED: &'static str = "completed";
8446 pub const INCOMPLETE: &'static str = "incomplete";
8447 pub const APPROVED: &'static str = "approved";
8448 pub const REJECTED: &'static str = "rejected";
8449}
8450
8451#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8452#[serde(transparent)]
8453pub struct TemplateSignerInputType(pub String);
8454
8455impl TemplateSignerInputType {
8456 pub const SIGNATURE: &'static str = "signature";
8457 pub const DATE: &'static str = "date";
8458 pub const TEXT: &'static str = "text";
8459 pub const CHECKBOX: &'static str = "checkbox";
8460 pub const ATTACHMENT: &'static str = "attachment";
8461 pub const RADIO: &'static str = "radio";
8462 pub const DROPDOWN: &'static str = "dropdown";
8463}
8464
8465#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8466pub struct TemplateSignerInputCoordinates {
8467 #[serde(default, skip_serializing_if = "Option::is_none")]
8468 pub x: Option<f64>,
8469 #[serde(default, skip_serializing_if = "Option::is_none")]
8470 pub y: Option<f64>,
8471}
8472
8473#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8474pub struct TemplateSignerInputDimensions {
8475 #[serde(default, skip_serializing_if = "Option::is_none")]
8476 pub width: Option<f64>,
8477 #[serde(default, skip_serializing_if = "Option::is_none")]
8478 pub height: Option<f64>,
8479}
8480
8481#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8482#[serde(transparent)]
8483pub struct TermsOfServiceType(pub String);
8484
8485impl TermsOfServiceType {
8486 pub const TERMS_OF_SERVICE: &'static str = "terms_of_service";
8487}
8488
8489#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8490#[serde(transparent)]
8491pub struct TermsOfServiceStatus(pub String);
8492
8493impl TermsOfServiceStatus {
8494 pub const ENABLED: &'static str = "enabled";
8495 pub const DISABLED: &'static str = "disabled";
8496}
8497
8498#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8499#[serde(transparent)]
8500pub struct TermsOfServiceTosType(pub String);
8501
8502impl TermsOfServiceTosType {
8503 pub const MANAGED: &'static str = "managed";
8504 pub const EXTERNAL: &'static str = "external";
8505}
8506
8507#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8508#[serde(transparent)]
8509pub struct TermsOfServiceUserStatusType(pub String);
8510
8511impl TermsOfServiceUserStatusType {
8512 pub const TERMS_OF_SERVICE_USER_STATUS: &'static str = "terms_of_service_user_status";
8513}
8514
8515#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8516#[serde(transparent)]
8517pub struct TimelineSkillCardSkillCardType(pub String);
8518
8519impl TimelineSkillCardSkillCardType {
8520 pub const TIMELINE: &'static str = "timeline";
8521}
8522
8523#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8524pub struct EntriesAppears {
8525 #[serde(default, skip_serializing_if = "Option::is_none")]
8526 pub start: Option<i64>,
8527 #[serde(default, skip_serializing_if = "Option::is_none")]
8528 pub end: Option<i64>,
8529}
8530
8531#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8532pub struct TimelineSkillCardEntries {
8533 #[serde(default, skip_serializing_if = "Option::is_none")]
8534 pub text: Option<String>,
8535 #[serde(default, skip_serializing_if = "Option::is_none")]
8536 pub appears: Option<Vec<EntriesAppears>>,
8537 #[serde(default, skip_serializing_if = "Option::is_none")]
8538 pub image_url: Option<String>,
8539}
8540
8541#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8542#[serde(transparent)]
8543pub struct TrackingCodeType(pub String);
8544
8545impl TrackingCodeType {
8546 pub const TRACKING_CODE: &'static str = "tracking_code";
8547}
8548
8549#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8550#[serde(transparent)]
8551pub struct TranscriptSkillCardSkillCardType(pub String);
8552
8553impl TranscriptSkillCardSkillCardType {
8554 pub const TRANSCRIPT: &'static str = "transcript";
8555}
8556
8557#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8558pub struct EntriesAppears2 {
8559 #[serde(default, skip_serializing_if = "Option::is_none")]
8560 pub start: Option<i64>,
8561}
8562
8563#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8564pub struct TranscriptSkillCardEntries {
8565 #[serde(default, skip_serializing_if = "Option::is_none")]
8566 pub text: Option<String>,
8567 #[serde(default, skip_serializing_if = "Option::is_none")]
8568 pub appears: Option<Vec<EntriesAppears2>>,
8569}
8570
8571#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8572pub struct PathCollectionEntries {
8573 #[serde(default, skip_serializing_if = "Option::is_none")]
8574 pub r#type: Option<FolderType>,
8575 #[serde(default, skip_serializing_if = "Option::is_none")]
8576 pub id: Option<String>,
8577 #[serde(
8578 default,
8579 skip_serializing_if = "Option::is_none",
8580 deserialize_with = "double_option"
8581 )]
8582 pub sequence_id: Option<Option<String>>,
8583 #[serde(
8584 default,
8585 skip_serializing_if = "Option::is_none",
8586 deserialize_with = "double_option"
8587 )]
8588 pub etag: Option<Option<String>>,
8589 #[serde(default, skip_serializing_if = "Option::is_none")]
8590 pub name: Option<String>,
8591}
8592
8593#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8594pub struct TrashFilePathCollection {
8595 pub total_count: i64,
8596 pub entries: Vec<PathCollectionEntries>,
8597}
8598
8599#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8600#[serde(transparent)]
8601pub struct TrashWebLinkType(pub String);
8602
8603impl TrashWebLinkType {
8604 pub const WEB_LINK: &'static str = "web_link";
8605}
8606
8607#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8608#[serde(transparent)]
8609pub struct UploadSessionType(pub String);
8610
8611impl UploadSessionType {
8612 pub const UPLOAD_SESSION: &'static str = "upload_session";
8613}
8614
8615#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8616pub struct UploadSessionSessionEndpoints {
8617 #[serde(default, skip_serializing_if = "Option::is_none")]
8618 pub upload_part: Option<String>,
8619 #[serde(default, skip_serializing_if = "Option::is_none")]
8620 pub commit: Option<String>,
8621 #[serde(default, skip_serializing_if = "Option::is_none")]
8622 pub abort: Option<String>,
8623 #[serde(default, skip_serializing_if = "Option::is_none")]
8624 pub list_parts: Option<String>,
8625 #[serde(default, skip_serializing_if = "Option::is_none")]
8626 pub status: Option<String>,
8627 #[serde(default, skip_serializing_if = "Option::is_none")]
8628 pub log_event: Option<String>,
8629}
8630
8631#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8632#[serde(transparent)]
8633pub struct UserStatus(pub String);
8634
8635impl UserStatus {
8636 pub const ACTIVE: &'static str = "active";
8637 pub const INACTIVE: &'static str = "inactive";
8638 pub const CANNOT_DELETE_EDIT: &'static str = "cannot_delete_edit";
8639 pub const CANNOT_DELETE_EDIT_UPLOAD: &'static str = "cannot_delete_edit_upload";
8640}
8641
8642#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8643pub struct UserNotificationEmail {
8644 #[serde(default, skip_serializing_if = "Option::is_none")]
8645 pub email: Option<String>,
8646 #[serde(default, skip_serializing_if = "Option::is_none")]
8647 pub is_confirmed: Option<bool>,
8648}
8649
8650#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8651#[serde(transparent)]
8652pub struct UserFullRole(pub String);
8653
8654impl UserFullRole {
8655 pub const ADMIN: &'static str = "admin";
8656 pub const COADMIN: &'static str = "coadmin";
8657 pub const USER: &'static str = "user";
8658}
8659
8660#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8661pub struct UserAvatarPicUrls {
8662 #[serde(default, skip_serializing_if = "Option::is_none")]
8663 pub small: Option<String>,
8664 #[serde(default, skip_serializing_if = "Option::is_none")]
8665 pub large: Option<String>,
8666 #[serde(default, skip_serializing_if = "Option::is_none")]
8667 pub preview: Option<String>,
8668}
8669
8670#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8671pub struct WatermarkWatermark {
8672 #[serde(default, skip_serializing_if = "Option::is_none")]
8673 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
8674 #[serde(default, skip_serializing_if = "Option::is_none")]
8675 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
8676}
8677
8678#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8679#[serde(transparent)]
8680pub struct WebhookType(pub String);
8681
8682impl WebhookType {
8683 pub const WEBHOOK: &'static str = "webhook";
8684}
8685
8686#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8687pub struct WebhookTarget {
8688 #[serde(default, skip_serializing_if = "Option::is_none")]
8689 pub id: Option<String>,
8690 #[serde(default, skip_serializing_if = "Option::is_none")]
8691 pub r#type: Option<EventSourceItemType>,
8692}
8693
8694#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8695#[serde(transparent)]
8696pub struct WebhookTriggers(pub String);
8697
8698impl WebhookTriggers {
8699 pub const FILE_UPLOADED: &'static str = "FILE.UPLOADED";
8700 pub const FILE_PREVIEWED: &'static str = "FILE.PREVIEWED";
8701 pub const FILE_DOWNLOADED: &'static str = "FILE.DOWNLOADED";
8702 pub const FILE_TRASHED: &'static str = "FILE.TRASHED";
8703 pub const FILE_DELETED: &'static str = "FILE.DELETED";
8704 pub const FILE_RESTORED: &'static str = "FILE.RESTORED";
8705 pub const FILE_COPIED: &'static str = "FILE.COPIED";
8706 pub const FILE_MOVED: &'static str = "FILE.MOVED";
8707 pub const FILE_LOCKED: &'static str = "FILE.LOCKED";
8708 pub const FILE_UNLOCKED: &'static str = "FILE.UNLOCKED";
8709 pub const FILE_RENAMED: &'static str = "FILE.RENAMED";
8710 pub const COMMENT_CREATED: &'static str = "COMMENT.CREATED";
8711 pub const COMMENT_UPDATED: &'static str = "COMMENT.UPDATED";
8712 pub const COMMENT_DELETED: &'static str = "COMMENT.DELETED";
8713 pub const TASK_ASSIGNMENT_CREATED: &'static str = "TASK_ASSIGNMENT.CREATED";
8714 pub const TASK_ASSIGNMENT_UPDATED: &'static str = "TASK_ASSIGNMENT.UPDATED";
8715 pub const METADATA_INSTANCE_CREATED: &'static str = "METADATA_INSTANCE.CREATED";
8716 pub const METADATA_INSTANCE_UPDATED: &'static str = "METADATA_INSTANCE.UPDATED";
8717 pub const METADATA_INSTANCE_DELETED: &'static str = "METADATA_INSTANCE.DELETED";
8718 pub const FOLDER_CREATED: &'static str = "FOLDER.CREATED";
8719 pub const FOLDER_RENAMED: &'static str = "FOLDER.RENAMED";
8720 pub const FOLDER_DOWNLOADED: &'static str = "FOLDER.DOWNLOADED";
8721 pub const FOLDER_RESTORED: &'static str = "FOLDER.RESTORED";
8722 pub const FOLDER_DELETED: &'static str = "FOLDER.DELETED";
8723 pub const FOLDER_COPIED: &'static str = "FOLDER.COPIED";
8724 pub const FOLDER_MOVED: &'static str = "FOLDER.MOVED";
8725 pub const FOLDER_TRASHED: &'static str = "FOLDER.TRASHED";
8726 pub const WEBHOOK_DELETED: &'static str = "WEBHOOK.DELETED";
8727 pub const COLLABORATION_CREATED: &'static str = "COLLABORATION.CREATED";
8728 pub const COLLABORATION_ACCEPTED: &'static str = "COLLABORATION.ACCEPTED";
8729 pub const COLLABORATION_REJECTED: &'static str = "COLLABORATION.REJECTED";
8730 pub const COLLABORATION_REMOVED: &'static str = "COLLABORATION.REMOVED";
8731 pub const COLLABORATION_UPDATED: &'static str = "COLLABORATION.UPDATED";
8732 pub const SHARED_LINK_DELETED: &'static str = "SHARED_LINK.DELETED";
8733 pub const SHARED_LINK_CREATED: &'static str = "SHARED_LINK.CREATED";
8734 pub const SHARED_LINK_UPDATED: &'static str = "SHARED_LINK.UPDATED";
8735 pub const SIGN_REQUEST_COMPLETED: &'static str = "SIGN_REQUEST.COMPLETED";
8736 pub const SIGN_REQUEST_DECLINED: &'static str = "SIGN_REQUEST.DECLINED";
8737 pub const SIGN_REQUEST_EXPIRED: &'static str = "SIGN_REQUEST.EXPIRED";
8738 pub const SIGN_REQUEST_SIGNER_EMAIL_BOUNCED: &'static str = "SIGN_REQUEST.SIGNER_EMAIL_BOUNCED";
8739 pub const SIGN_REQUEST_SIGN_SIGNER_SIGNED: &'static str = "SIGN_REQUEST.SIGN_SIGNER_SIGNED";
8740 pub const SIGN_REQUEST_SIGN_DOCUMENT_CREATED: &'static str =
8741 "SIGN_REQUEST.SIGN_DOCUMENT_CREATED";
8742 pub const SIGN_REQUEST_SIGN_ERROR_FINALIZING: &'static str =
8743 "SIGN_REQUEST.SIGN_ERROR_FINALIZING";
8744}
8745
8746#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8747#[serde(transparent)]
8748pub struct WorkflowType(pub String);
8749
8750impl WorkflowType {
8751 pub const WORKFLOW: &'static str = "workflow";
8752}
8753
8754#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8755#[serde(transparent)]
8756pub struct FlowsType(pub String);
8757
8758impl FlowsType {
8759 pub const FLOW: &'static str = "flow";
8760}
8761
8762#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8763#[serde(transparent)]
8764pub struct TriggerType(pub String);
8765
8766impl TriggerType {
8767 pub const TRIGGER: &'static str = "trigger";
8768}
8769
8770#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8771#[serde(transparent)]
8772pub struct TriggerTriggerType(pub String);
8773
8774impl TriggerTriggerType {
8775 pub const WORKFLOW_MANUAL_START: &'static str = "WORKFLOW_MANUAL_START";
8776}
8777
8778#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8779#[serde(transparent)]
8780pub struct ScopeType(pub String);
8781
8782impl ScopeType {
8783 pub const TRIGGER_SCOPE: &'static str = "trigger_scope";
8784}
8785
8786#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8787pub struct TriggerScope {
8788 #[serde(default, skip_serializing_if = "Option::is_none")]
8789 pub r#type: Option<ScopeType>,
8790 #[serde(default, skip_serializing_if = "Option::is_none")]
8791 pub r#ref: Option<String>,
8792 #[serde(default, skip_serializing_if = "Option::is_none")]
8793 pub object: Option<MetadataCascadePolicyParent>,
8794}
8795
8796#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8797pub struct FlowsTrigger {
8798 #[serde(default, skip_serializing_if = "Option::is_none")]
8799 pub r#type: Option<TriggerType>,
8800 #[serde(default, skip_serializing_if = "Option::is_none")]
8801 pub trigger_type: Option<TriggerTriggerType>,
8802 #[serde(default, skip_serializing_if = "Option::is_none")]
8803 pub scope: Option<Vec<TriggerScope>>,
8804}
8805
8806#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8807#[serde(transparent)]
8808pub struct OutcomesType(pub String);
8809
8810impl OutcomesType {
8811 pub const OUTCOME: &'static str = "outcome";
8812}
8813
8814#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8815#[serde(transparent)]
8816pub struct OutcomesActionType(pub String);
8817
8818impl OutcomesActionType {
8819 pub const ADD_METADATA: &'static str = "add_metadata";
8820 pub const ASSIGN_TASK: &'static str = "assign_task";
8821 pub const COPY_FILE: &'static str = "copy_file";
8822 pub const COPY_FOLDER: &'static str = "copy_folder";
8823 pub const CREATE_FOLDER: &'static str = "create_folder";
8824 pub const DELETE_FILE: &'static str = "delete_file";
8825 pub const DELETE_FOLDER: &'static str = "delete_folder";
8826 pub const LOCK_FILE: &'static str = "lock_file";
8827 pub const MOVE_FILE: &'static str = "move_file";
8828 pub const MOVE_FOLDER: &'static str = "move_folder";
8829 pub const REMOVE_WATERMARK_FILE: &'static str = "remove_watermark_file";
8830 pub const RENAME_FOLDER: &'static str = "rename_folder";
8831 pub const RESTORE_FOLDER: &'static str = "restore_folder";
8832 pub const SHARE_FILE: &'static str = "share_file";
8833 pub const SHARE_FOLDER: &'static str = "share_folder";
8834 pub const UNLOCK_FILE: &'static str = "unlock_file";
8835 pub const UPLOAD_FILE: &'static str = "upload_file";
8836 pub const WAIT_FOR_TASK: &'static str = "wait_for_task";
8837 pub const WATERMARK_FILE: &'static str = "watermark_file";
8838 pub const GO_BACK_TO_STEP: &'static str = "go_back_to_step";
8839 pub const APPLY_FILE_CLASSIFICATION: &'static str = "apply_file_classification";
8840 pub const APPLY_FOLDER_CLASSIFICATION: &'static str = "apply_folder_classification";
8841 pub const SEND_NOTIFICATION: &'static str = "send_notification";
8842}
8843
8844#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8845pub struct OutcomesIfRejected {
8846 #[serde(default, skip_serializing_if = "Option::is_none")]
8847 pub id: Option<String>,
8848 #[serde(default, skip_serializing_if = "Option::is_none")]
8849 pub r#type: Option<OutcomesType>,
8850 #[serde(default, skip_serializing_if = "Option::is_none")]
8851 pub name: Option<String>,
8852 #[serde(default, skip_serializing_if = "Option::is_none")]
8853 pub action_type: Option<OutcomesActionType>,
8854}
8855
8856#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8857pub struct FlowsOutcomes {
8858 #[serde(default, skip_serializing_if = "Option::is_none")]
8859 pub id: Option<String>,
8860 #[serde(default, skip_serializing_if = "Option::is_none")]
8861 pub r#type: Option<OutcomesType>,
8862 #[serde(default, skip_serializing_if = "Option::is_none")]
8863 pub name: Option<String>,
8864 #[serde(default, skip_serializing_if = "Option::is_none")]
8865 pub action_type: Option<OutcomesActionType>,
8866 #[serde(default, skip_serializing_if = "Option::is_none")]
8867 pub if_rejected: Option<Vec<OutcomesIfRejected>>,
8868}
8869
8870#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8871pub struct WorkflowFlows {
8872 #[serde(default, skip_serializing_if = "Option::is_none")]
8873 pub id: Option<String>,
8874 #[serde(default, skip_serializing_if = "Option::is_none")]
8875 pub r#type: Option<FlowsType>,
8876 #[serde(default, skip_serializing_if = "Option::is_none")]
8877 pub trigger: Option<FlowsTrigger>,
8878 #[serde(default, skip_serializing_if = "Option::is_none")]
8879 pub outcomes: Option<Vec<FlowsOutcomes>>,
8880 #[serde(default, skip_serializing_if = "Option::is_none")]
8881 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
8882 #[serde(default, skip_serializing_if = "Option::is_none")]
8883 pub created_by: Option<UserBase>,
8884}
8885
8886#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8887pub struct ZipDownloadNameConflicts {
8888 #[serde(default, skip_serializing_if = "Option::is_none")]
8889 pub id: Option<String>,
8890 #[serde(default, skip_serializing_if = "Option::is_none")]
8891 pub r#type: Option<EventSourceItemType>,
8892 #[serde(default, skip_serializing_if = "Option::is_none")]
8893 pub original_name: Option<String>,
8894 #[serde(default, skip_serializing_if = "Option::is_none")]
8895 pub download_name: Option<String>,
8896}
8897
8898#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8899pub struct ZipDownloadRequestItems {
8900 pub r#type: EventSourceItemType,
8901 pub id: String,
8902}
8903
8904#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8905#[serde(transparent)]
8906pub struct ZipDownloadStatusState(pub String);
8907
8908impl ZipDownloadStatusState {
8909 pub const IN_PROGRESS: &'static str = "in_progress";
8910 pub const FAILED: &'static str = "failed";
8911 pub const SUCCEEDED: &'static str = "succeeded";
8912}
8913
8914#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8915#[serde(transparent)]
8916pub struct GetAuthorizeResponseType(pub String);
8917
8918impl GetAuthorizeResponseType {
8919 pub const CODE: &'static str = "code";
8920}
8921
8922#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8923pub struct PutIdParent {
8924 #[serde(default, skip_serializing_if = "Option::is_none")]
8925 pub id: Option<String>,
8926 #[serde(default, skip_serializing_if = "Option::is_none")]
8927 pub user_id: Option<String>,
8928}
8929
8930#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8931pub struct SharedLinkPermissions2 {
8932 #[serde(default, skip_serializing_if = "Option::is_none")]
8933 pub can_download: Option<bool>,
8934}
8935
8936#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8937pub struct PutIdSharedLink {
8938 #[serde(default, skip_serializing_if = "Option::is_none")]
8939 pub access: Option<SharedLinkAccess>,
8940 #[serde(
8941 default,
8942 skip_serializing_if = "Option::is_none",
8943 deserialize_with = "double_option"
8944 )]
8945 pub password: Option<Option<String>>,
8946 #[serde(default, skip_serializing_if = "Option::is_none")]
8947 pub vanity_name: Option<String>,
8948 #[serde(default, skip_serializing_if = "Option::is_none")]
8949 pub unshared_at: Option<chrono::DateTime<chrono::Utc>>,
8950 #[serde(default, skip_serializing_if = "Option::is_none")]
8951 pub permissions: Option<SharedLinkPermissions2>,
8952}
8953
8954#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8955pub struct PutIdLock {
8956 #[serde(default, skip_serializing_if = "Option::is_none")]
8957 pub access: Option<LockType>,
8958 #[serde(default, skip_serializing_if = "Option::is_none")]
8959 pub expires_at: Option<chrono::DateTime<chrono::Utc>>,
8960 #[serde(default, skip_serializing_if = "Option::is_none")]
8961 pub is_download_prevented: Option<bool>,
8962}
8963
8964#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
8965#[serde(transparent)]
8966pub struct PermissionsCanDownload(pub String);
8967
8968impl PermissionsCanDownload {
8969 pub const OPEN: &'static str = "open";
8970 pub const COMPANY: &'static str = "company";
8971}
8972
8973#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8974pub struct PutIdPermissions {
8975 #[serde(default, skip_serializing_if = "Option::is_none")]
8976 pub can_download: Option<PermissionsCanDownload>,
8977}
8978
8979#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
8980pub struct FileUpdateRequest {
8981 #[serde(default, skip_serializing_if = "Option::is_none")]
8982 pub name: Option<String>,
8983 #[serde(default, skip_serializing_if = "Option::is_none")]
8984 pub description: Option<String>,
8985 #[serde(default, skip_serializing_if = "Option::is_none")]
8986 pub parent: Option<PutIdParent>,
8987 #[serde(
8988 default,
8989 skip_serializing_if = "Option::is_none",
8990 deserialize_with = "double_option"
8991 )]
8992 pub shared_link: Option<Option<PutIdSharedLink>>,
8993 #[serde(
8994 default,
8995 skip_serializing_if = "Option::is_none",
8996 deserialize_with = "double_option"
8997 )]
8998 pub lock: Option<Option<PutIdLock>>,
8999 #[serde(default, skip_serializing_if = "Option::is_none")]
9000 pub disposition_at: Option<chrono::DateTime<chrono::Utc>>,
9001 #[serde(default, skip_serializing_if = "Option::is_none")]
9002 pub permissions: Option<PutIdPermissions>,
9003 #[serde(
9004 default,
9005 skip_serializing_if = "Option::is_none",
9006 deserialize_with = "double_option"
9007 )]
9008 pub collections: Option<Option<Vec<CommentItem>>>,
9009 #[serde(default, skip_serializing_if = "Option::is_none")]
9010 pub tags: Option<Vec<String>>,
9011}
9012
9013#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9014pub struct PostFileIdParent {
9015 #[serde(default, skip_serializing_if = "Option::is_none")]
9016 pub id: Option<String>,
9017}
9018
9019#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9020pub struct FileCreateRequest {
9021 #[serde(default, skip_serializing_if = "Option::is_none")]
9022 pub name: Option<String>,
9023 #[serde(default, skip_serializing_if = "Option::is_none")]
9024 pub parent: Option<PostFileIdParent>,
9025}
9026
9027#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9028pub struct PostFileIdContentAttributes {
9029 pub name: String,
9030 #[serde(default, skip_serializing_if = "Option::is_none")]
9031 pub content_modified_at: Option<chrono::DateTime<chrono::Utc>>,
9032}
9033
9034#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9035pub struct FileIdContentCreateRequest {
9036 pub attributes: PostFileIdContentAttributes,
9037 #[serde(skip)]
9038 pub file: Vec<u8>,
9039}
9040
9041#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9042pub struct AttributesParent {
9043 pub id: String,
9044}
9045
9046#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9047pub struct PostFileContentAttributes {
9048 pub name: String,
9049 pub parent: AttributesParent,
9050 #[serde(default, skip_serializing_if = "Option::is_none")]
9051 pub content_created_at: Option<chrono::DateTime<chrono::Utc>>,
9052 #[serde(default, skip_serializing_if = "Option::is_none")]
9053 pub content_modified_at: Option<chrono::DateTime<chrono::Utc>>,
9054}
9055
9056#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9057pub struct FileContentCreateRequest {
9058 pub attributes: PostFileContentAttributes,
9059 #[serde(skip)]
9060 pub file: Vec<u8>,
9061}
9062
9063#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9064pub struct OptionFileContentRequest {
9065 #[serde(default, skip_serializing_if = "Option::is_none")]
9066 pub name: Option<String>,
9067 #[serde(default, skip_serializing_if = "Option::is_none")]
9068 pub size: Option<i64>,
9069 #[serde(default, skip_serializing_if = "Option::is_none")]
9070 pub parent: Option<PostFileIdParent>,
9071}
9072
9073#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9074pub struct FileUploadSessionCreateRequest {
9075 pub folder_id: String,
9076 pub file_size: i64,
9077 pub file_name: String,
9078}
9079
9080#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9081pub struct FileVersionUploadSessionCreateRequest {
9082 pub file_size: i64,
9083 #[serde(default, skip_serializing_if = "Option::is_none")]
9084 pub file_name: Option<String>,
9085}
9086
9087#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9088pub struct FileUploadSessionCommitRequest {
9089 pub parts: Vec<UploadPart>,
9090}
9091
9092#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9093pub struct FileCopyRequest {
9094 #[serde(default, skip_serializing_if = "Option::is_none")]
9095 pub name: Option<String>,
9096 #[serde(default, skip_serializing_if = "Option::is_none")]
9097 pub version: Option<String>,
9098 pub parent: AttributesParent,
9099}
9100
9101#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9102#[serde(transparent)]
9103pub struct GetIdThumbnailIdExtension(pub String);
9104
9105impl GetIdThumbnailIdExtension {
9106 pub const PNG: &'static str = "png";
9107 pub const JPG: &'static str = "jpg";
9108}
9109
9110#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9111pub struct FileVersionUpdateRequest {
9112 #[serde(
9113 default,
9114 skip_serializing_if = "Option::is_none",
9115 deserialize_with = "double_option"
9116 )]
9117 pub trashed_at: Option<Option<String>>,
9118}
9119
9120#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9121pub struct FileVersionCurrentCreateRequest {
9122 #[serde(default, skip_serializing_if = "Option::is_none")]
9123 pub id: Option<String>,
9124 #[serde(default, skip_serializing_if = "Option::is_none")]
9125 pub r#type: Option<FileVersionType>,
9126}
9127
9128#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9129#[serde(transparent)]
9130pub struct PutOp(pub String);
9131
9132impl PutOp {
9133 pub const REPLACE: &'static str = "replace";
9134}
9135
9136#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9137#[serde(transparent)]
9138pub struct PutPath(pub String);
9139
9140impl PutPath {
9141 pub const BOX_SECURITY_CLASSIFICATION_KEY: &'static str = "/Box__Security__Classification__Key";
9142}
9143
9144#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9145pub struct FileClassificationUpdateRequest {
9146 pub op: PutOp,
9147 pub path: PutPath,
9148 pub value: String,
9149}
9150
9151#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9152pub struct FileClassificationCreateRequest {
9153 #[serde(
9154 rename = "Box__Security__Classification__Key",
9155 default,
9156 skip_serializing_if = "Option::is_none"
9157 )]
9158 pub box_security_classification_key: Option<String>,
9159}
9160
9161#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9162#[serde(transparent)]
9163pub struct GetFileIdMetadataIdIdScope(pub String);
9164
9165impl GetFileIdMetadataIdIdScope {
9166 pub const GLOBAL: &'static str = "global";
9167 pub const ENTERPRISE: &'static str = "enterprise";
9168}
9169
9170#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9171#[serde(transparent)]
9172pub struct PutFileIdMetadataIdIdOp(pub String);
9173
9174impl PutFileIdMetadataIdIdOp {
9175 pub const ADD: &'static str = "add";
9176 pub const REPLACE: &'static str = "replace";
9177 pub const REMOVE: &'static str = "remove";
9178 pub const TEST: &'static str = "test";
9179 pub const MOVE: &'static str = "move";
9180 pub const COPY: &'static str = "copy";
9181}
9182
9183#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9184pub struct FileMetadataUpdateRequest {
9185 #[serde(default, skip_serializing_if = "Option::is_none")]
9186 pub op: Option<PutFileIdMetadataIdIdOp>,
9187 #[serde(default, skip_serializing_if = "Option::is_none")]
9188 pub path: Option<String>,
9189 #[serde(default, skip_serializing_if = "Option::is_none")]
9190 pub value: Option<MetadataInstanceValue>,
9191 #[serde(default, skip_serializing_if = "Option::is_none")]
9192 pub from: Option<String>,
9193}
9194
9195#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9196pub struct SkillUpdateRequest {
9197 #[serde(default, skip_serializing_if = "Option::is_none")]
9198 pub op: Option<PutOp>,
9199 #[serde(default, skip_serializing_if = "Option::is_none")]
9200 pub path: Option<String>,
9201 #[serde(default, skip_serializing_if = "Option::is_none")]
9202 pub value: Option<SkillCard>,
9203}
9204
9205#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9206pub struct SkillCreateRequest {
9207 pub cards: Vec<SkillCard>,
9208}
9209
9210#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9211#[serde(transparent)]
9212pub struct WatermarkImprint(pub String);
9213
9214impl WatermarkImprint {
9215 pub const DEFAULT: &'static str = "default";
9216}
9217
9218#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9219pub struct PutFileIdWatermarkWatermark {
9220 pub imprint: WatermarkImprint,
9221}
9222
9223#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9224pub struct FileWatermarkUpdateRequest {
9225 pub watermark: PutFileIdWatermarkWatermark,
9226}
9227
9228#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9229#[serde(transparent)]
9230pub struct GetIdSort(pub String);
9231
9232impl GetIdSort {
9233 pub const ID: &'static str = "id";
9234 pub const NAME: &'static str = "name";
9235 pub const DATE: &'static str = "date";
9236 pub const SIZE: &'static str = "size";
9237}
9238
9239#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9240pub struct PutIdFolderUploadEmail {
9241 #[serde(default, skip_serializing_if = "Option::is_none")]
9242 pub access: Option<FolderUploadEmailAccess>,
9243}
9244
9245#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9246pub struct FolderUpdateRequest {
9247 #[serde(default, skip_serializing_if = "Option::is_none")]
9248 pub name: Option<String>,
9249 #[serde(default, skip_serializing_if = "Option::is_none")]
9250 pub description: Option<String>,
9251 #[serde(default, skip_serializing_if = "Option::is_none")]
9252 pub sync_state: Option<FolderFullSyncState>,
9253 #[serde(default, skip_serializing_if = "Option::is_none")]
9254 pub can_non_owners_invite: Option<bool>,
9255 #[serde(default, skip_serializing_if = "Option::is_none")]
9256 pub parent: Option<PutIdParent>,
9257 #[serde(default, skip_serializing_if = "Option::is_none")]
9258 pub shared_link: Option<PutIdSharedLink>,
9259 #[serde(
9260 default,
9261 skip_serializing_if = "Option::is_none",
9262 deserialize_with = "double_option"
9263 )]
9264 pub folder_upload_email: Option<Option<PutIdFolderUploadEmail>>,
9265 #[serde(default, skip_serializing_if = "Option::is_none")]
9266 pub tags: Option<Vec<String>>,
9267 #[serde(default, skip_serializing_if = "Option::is_none")]
9268 pub is_collaboration_restricted_to_enterprise: Option<bool>,
9269 #[serde(
9270 default,
9271 skip_serializing_if = "Option::is_none",
9272 deserialize_with = "double_option"
9273 )]
9274 pub collections: Option<Option<Vec<CommentItem>>>,
9275 #[serde(default, skip_serializing_if = "Option::is_none")]
9276 pub can_non_owners_view_collaborators: Option<bool>,
9277}
9278
9279#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9280pub struct FolderCreateRequest {
9281 pub name: String,
9282 pub parent: AttributesParent,
9283 #[serde(default, skip_serializing_if = "Option::is_none")]
9284 pub folder_upload_email: Option<PutIdFolderUploadEmail>,
9285 #[serde(default, skip_serializing_if = "Option::is_none")]
9286 pub sync_state: Option<FolderFullSyncState>,
9287}
9288
9289#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9290pub struct FolderCopyRequest {
9291 #[serde(default, skip_serializing_if = "Option::is_none")]
9292 pub name: Option<String>,
9293 pub parent: AttributesParent,
9294}
9295
9296#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9297#[serde(transparent)]
9298pub struct GetFolderTrashItemsSort(pub String);
9299
9300impl GetFolderTrashItemsSort {
9301 pub const NAME: &'static str = "name";
9302 pub const DATE: &'static str = "date";
9303 pub const SIZE: &'static str = "size";
9304}
9305
9306#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9307pub struct PostFolder {
9308 pub r#type: String,
9309 pub id: String,
9310}
9311
9312#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9313pub struct FolderLockCreateRequest {
9314 #[serde(default, skip_serializing_if = "Option::is_none")]
9315 pub locked_operations: Option<FolderLockLockedOperations>,
9316 pub folder: PostFolder,
9317}
9318
9319#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9320#[serde(transparent)]
9321pub struct PutAddOp(pub String);
9322
9323impl PutAddOp {
9324 pub const ADDENUMOPTION: &'static str = "addEnumOption";
9325}
9326
9327#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9328pub struct PutAddData {
9329 pub key: String,
9330 #[serde(
9331 rename = "staticConfig",
9332 default,
9333 skip_serializing_if = "Option::is_none"
9334 )]
9335 pub static_config: Option<OptionsStaticConfig>,
9336}
9337
9338#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9339pub struct ClassificationUpdateRequest {
9340 pub op: PutAddOp,
9341 #[serde(rename = "fieldKey")]
9342 pub field_key: FieldsKey,
9343 pub data: PutAddData,
9344}
9345
9346#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9347#[serde(transparent)]
9348pub struct PutUpdateOp(pub String);
9349
9350impl PutUpdateOp {
9351 pub const EDITENUMOPTION: &'static str = "editEnumOption";
9352}
9353
9354#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9355pub struct ClassificationUpdateRequest2 {
9356 pub op: PutUpdateOp,
9357 #[serde(rename = "fieldKey")]
9358 pub field_key: FieldsKey,
9359 #[serde(rename = "enumOptionKey")]
9360 pub enum_option_key: String,
9361 pub data: PutAddData,
9362}
9363
9364#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9365#[serde(transparent)]
9366pub struct PutIdIdSchemaOp(pub String);
9367
9368impl PutIdIdSchemaOp {
9369 pub const EDITTEMPLATE: &'static str = "editTemplate";
9370 pub const ADDFIELD: &'static str = "addField";
9371 pub const REORDERFIELDS: &'static str = "reorderFields";
9372 pub const ADDENUMOPTION: &'static str = "addEnumOption";
9373 pub const REORDERENUMOPTIONS: &'static str = "reorderEnumOptions";
9374 pub const REORDERMULTISELECTOPTIONS: &'static str = "reorderMultiSelectOptions";
9375 pub const ADDMULTISELECTOPTION: &'static str = "addMultiSelectOption";
9376 pub const EDITFIELD: &'static str = "editField";
9377 pub const REMOVEFIELD: &'static str = "removeField";
9378 pub const EDITENUMOPTION: &'static str = "editEnumOption";
9379 pub const REMOVEENUMOPTION: &'static str = "removeEnumOption";
9380 pub const EDITMULTISELECTOPTION: &'static str = "editMultiSelectOption";
9381 pub const REMOVEMULTISELECTOPTION: &'static str = "removeMultiSelectOption";
9382}
9383
9384#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9385pub struct SchemaUpdateRequest {
9386 pub op: PutIdIdSchemaOp,
9387 #[serde(default, skip_serializing_if = "Option::is_none")]
9388 pub data: Option<std::collections::HashMap<String, serde_json::Value>>,
9389 #[serde(rename = "fieldKey", default, skip_serializing_if = "Option::is_none")]
9390 pub field_key: Option<String>,
9391 #[serde(rename = "fieldKeys", default, skip_serializing_if = "Option::is_none")]
9392 pub field_keys: Option<Vec<String>>,
9393 #[serde(
9394 rename = "enumOptionKey",
9395 default,
9396 skip_serializing_if = "Option::is_none"
9397 )]
9398 pub enum_option_key: Option<String>,
9399 #[serde(
9400 rename = "enumOptionKeys",
9401 default,
9402 skip_serializing_if = "Option::is_none"
9403 )]
9404 pub enum_option_keys: Option<Vec<String>>,
9405 #[serde(
9406 rename = "multiSelectOptionKey",
9407 default,
9408 skip_serializing_if = "Option::is_none"
9409 )]
9410 pub multi_select_option_key: Option<String>,
9411 #[serde(
9412 rename = "multiSelectOptionKeys",
9413 default,
9414 skip_serializing_if = "Option::is_none"
9415 )]
9416 pub multi_select_option_keys: Option<Vec<String>>,
9417}
9418
9419#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9420#[serde(transparent)]
9421pub struct FieldsType3(pub String);
9422
9423impl FieldsType3 {
9424 pub const STRING: &'static str = "string";
9425 pub const FLOAT: &'static str = "float";
9426 pub const DATE: &'static str = "date";
9427 pub const ENUM: &'static str = "enum";
9428 pub const MULTISELECT: &'static str = "multiSelect";
9429 pub const TAXONOMY: &'static str = "taxonomy";
9430}
9431
9432#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9433pub struct PostSchemaFields {
9434 pub r#type: FieldsType3,
9435 pub key: String,
9436 #[serde(rename = "displayName")]
9437 pub display_name: String,
9438 #[serde(default, skip_serializing_if = "Option::is_none")]
9439 pub description: Option<String>,
9440 #[serde(default, skip_serializing_if = "Option::is_none")]
9441 pub hidden: Option<bool>,
9442 #[serde(default, skip_serializing_if = "Option::is_none")]
9443 pub options: Option<Vec<FieldsOptions>>,
9444 #[serde(
9445 rename = "taxonomyKey",
9446 default,
9447 skip_serializing_if = "Option::is_none"
9448 )]
9449 pub taxonomy_key: Option<String>,
9450 #[serde(
9451 rename = "taxonomyId",
9452 default,
9453 skip_serializing_if = "Option::is_none"
9454 )]
9455 pub taxonomy_id: Option<String>,
9456 #[serde(default, skip_serializing_if = "Option::is_none")]
9457 pub namespace: Option<String>,
9458 #[serde(
9459 rename = "optionsRules",
9460 default,
9461 skip_serializing_if = "Option::is_none"
9462 )]
9463 pub options_rules: Option<FieldsOptionsRules>,
9464}
9465
9466#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9467pub struct SchemaCreateRequest {
9468 pub scope: String,
9469 #[serde(
9470 rename = "templateKey",
9471 default,
9472 skip_serializing_if = "Option::is_none"
9473 )]
9474 pub template_key: Option<String>,
9475 #[serde(rename = "displayName")]
9476 pub display_name: String,
9477 #[serde(default, skip_serializing_if = "Option::is_none")]
9478 pub hidden: Option<bool>,
9479 #[serde(default, skip_serializing_if = "Option::is_none")]
9480 pub fields: Option<Vec<PostSchemaFields>>,
9481 #[serde(
9482 rename = "copyInstanceOnItemCopy",
9483 default,
9484 skip_serializing_if = "Option::is_none"
9485 )]
9486 pub copy_instance_on_item_copy: Option<bool>,
9487}
9488
9489#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9490pub struct PostMetadataTemplateSchemaClassificationsFields {
9491 pub r#type: FieldsType,
9492 pub key: FieldsKey,
9493 #[serde(rename = "displayName")]
9494 pub display_name: ClassificationTemplateDisplayName,
9495 #[serde(default, skip_serializing_if = "Option::is_none")]
9496 pub hidden: Option<bool>,
9497 pub options: Vec<PutAddData>,
9498}
9499
9500#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9501pub struct MetadataTemplateSchemaCreateRequest {
9502 pub scope: EnterpriseType,
9503 #[serde(rename = "templateKey")]
9504 pub template_key: ClassificationTemplate2,
9505 #[serde(rename = "displayName")]
9506 pub display_name: ClassificationTemplateDisplayName,
9507 #[serde(default, skip_serializing_if = "Option::is_none")]
9508 pub hidden: Option<bool>,
9509 #[serde(
9510 rename = "copyInstanceOnItemCopy",
9511 default,
9512 skip_serializing_if = "Option::is_none"
9513 )]
9514 pub copy_instance_on_item_copy: Option<bool>,
9515 pub fields: Vec<PostMetadataTemplateSchemaClassificationsFields>,
9516}
9517
9518#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9519pub struct MetadataCascadePolicyCreateRequest {
9520 pub folder_id: String,
9521 pub scope: GetFileIdMetadataIdIdScope,
9522 #[serde(rename = "templateKey")]
9523 pub template_key: String,
9524}
9525
9526#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9527#[serde(transparent)]
9528pub struct PostIdApplyConflictResolution(pub String);
9529
9530impl PostIdApplyConflictResolution {
9531 pub const NONE: &'static str = "none";
9532 pub const OVERWRITE: &'static str = "overwrite";
9533}
9534
9535#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9536pub struct MetadataCascadePolicyApplyRequest {
9537 pub conflict_resolution: PostIdApplyConflictResolution,
9538}
9539
9540#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9541pub struct CommentUpdateRequest {
9542 #[serde(default, skip_serializing_if = "Option::is_none")]
9543 pub message: Option<String>,
9544}
9545
9546#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9547#[serde(transparent)]
9548pub struct ItemType(pub String);
9549
9550impl ItemType {
9551 pub const FILE: &'static str = "file";
9552 pub const COMMENT: &'static str = "comment";
9553}
9554
9555#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9556pub struct PostItem {
9557 pub id: String,
9558 pub r#type: ItemType,
9559}
9560
9561#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9562pub struct CommentCreateRequest {
9563 pub message: String,
9564 #[serde(default, skip_serializing_if = "Option::is_none")]
9565 pub tagged_message: Option<String>,
9566 pub item: PostItem,
9567}
9568
9569#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9570#[serde(transparent)]
9571pub struct PutCollaborationIdStatus(pub String);
9572
9573impl PutCollaborationIdStatus {
9574 pub const PENDING: &'static str = "pending";
9575 pub const ACCEPTED: &'static str = "accepted";
9576 pub const REJECTED: &'static str = "rejected";
9577}
9578
9579#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9580pub struct CollaborationUpdateRequest {
9581 #[serde(default, skip_serializing_if = "Option::is_none")]
9582 pub role: Option<CollaborationRole>,
9583 #[serde(default, skip_serializing_if = "Option::is_none")]
9584 pub status: Option<PutCollaborationIdStatus>,
9585 #[serde(default, skip_serializing_if = "Option::is_none")]
9586 pub expires_at: Option<chrono::DateTime<chrono::Utc>>,
9587 #[serde(default, skip_serializing_if = "Option::is_none")]
9588 pub can_view_path: Option<bool>,
9589}
9590
9591#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9592#[serde(transparent)]
9593pub struct GetCollaborationsStatus(pub String);
9594
9595impl GetCollaborationsStatus {
9596 pub const PENDING: &'static str = "pending";
9597}
9598
9599#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9600pub struct PostCollaborationsItem {
9601 #[serde(default, skip_serializing_if = "Option::is_none")]
9602 pub r#type: Option<EventSourceItemType>,
9603 #[serde(default, skip_serializing_if = "Option::is_none")]
9604 pub id: Option<String>,
9605}
9606
9607#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9608#[serde(transparent)]
9609pub struct AccessibleByType(pub String);
9610
9611impl AccessibleByType {
9612 pub const USER: &'static str = "user";
9613 pub const GROUP: &'static str = "group";
9614}
9615
9616#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9617pub struct PostCollaborationsAccessibleBy {
9618 pub r#type: AccessibleByType,
9619 #[serde(default, skip_serializing_if = "Option::is_none")]
9620 pub id: Option<String>,
9621 #[serde(default, skip_serializing_if = "Option::is_none")]
9622 pub login: Option<String>,
9623}
9624
9625#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9626pub struct CollaborationsCreateRequest {
9627 pub item: PostCollaborationsItem,
9628 pub accessible_by: PostCollaborationsAccessibleBy,
9629 pub role: FileFullAllowedInviteeRoles,
9630 #[serde(default, skip_serializing_if = "Option::is_none")]
9631 pub is_access_only: Option<bool>,
9632 #[serde(default, skip_serializing_if = "Option::is_none")]
9633 pub can_view_path: Option<bool>,
9634 #[serde(default, skip_serializing_if = "Option::is_none")]
9635 pub expires_at: Option<chrono::DateTime<chrono::Utc>>,
9636}
9637
9638#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9639#[serde(transparent)]
9640pub struct GetScope(pub String);
9641
9642impl GetScope {
9643 pub const USER_CONTENT: &'static str = "user_content";
9644 pub const ENTERPRISE_CONTENT: &'static str = "enterprise_content";
9645}
9646
9647#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9648#[serde(transparent)]
9649pub struct GetContentTypes(pub String);
9650
9651impl GetContentTypes {
9652 pub const NAME: &'static str = "name";
9653 pub const DESCRIPTION: &'static str = "description";
9654 pub const FILE_CONTENT: &'static str = "file_content";
9655 pub const COMMENTS: &'static str = "comments";
9656 pub const TAGS: &'static str = "tags";
9657}
9658
9659#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9660#[serde(transparent)]
9661pub struct GetType(pub String);
9662
9663impl GetType {
9664 pub const FILE: &'static str = "file";
9665 pub const FOLDER: &'static str = "folder";
9666 pub const WEB_LINK: &'static str = "web_link";
9667}
9668
9669#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9670#[serde(transparent)]
9671pub struct GetTrashContent(pub String);
9672
9673impl GetTrashContent {
9674 pub const NON_TRASHED_ONLY: &'static str = "non_trashed_only";
9675 pub const TRASHED_ONLY: &'static str = "trashed_only";
9676 pub const ALL_ITEMS: &'static str = "all_items";
9677}
9678
9679#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9680#[serde(transparent)]
9681pub struct GetSort(pub String);
9682
9683impl GetSort {
9684 pub const MODIFIED_AT: &'static str = "modified_at";
9685 pub const RELEVANCE: &'static str = "relevance";
9686}
9687
9688#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9689#[serde(transparent)]
9690pub struct GetDirection(pub String);
9691
9692impl GetDirection {
9693 pub const DESC: &'static str = "DESC";
9694 pub const ASC: &'static str = "ASC";
9695}
9696
9697#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9698pub struct PostItem2 {
9699 #[serde(default, skip_serializing_if = "Option::is_none")]
9700 pub id: Option<String>,
9701 #[serde(default, skip_serializing_if = "Option::is_none")]
9702 pub r#type: Option<AiCitationType>,
9703}
9704
9705#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9706pub struct TaskCreateRequest {
9707 pub item: PostItem2,
9708 #[serde(default, skip_serializing_if = "Option::is_none")]
9709 pub action: Option<TaskAction>,
9710 #[serde(default, skip_serializing_if = "Option::is_none")]
9711 pub message: Option<String>,
9712 #[serde(default, skip_serializing_if = "Option::is_none")]
9713 pub due_at: Option<chrono::DateTime<chrono::Utc>>,
9714 #[serde(default, skip_serializing_if = "Option::is_none")]
9715 pub completion_rule: Option<TaskCompletionRule>,
9716}
9717
9718#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9719pub struct TaskUpdateRequest {
9720 #[serde(default, skip_serializing_if = "Option::is_none")]
9721 pub action: Option<TaskAction>,
9722 #[serde(default, skip_serializing_if = "Option::is_none")]
9723 pub message: Option<String>,
9724 #[serde(default, skip_serializing_if = "Option::is_none")]
9725 pub due_at: Option<chrono::DateTime<chrono::Utc>>,
9726 #[serde(default, skip_serializing_if = "Option::is_none")]
9727 pub completion_rule: Option<TaskCompletionRule>,
9728}
9729
9730#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9731pub struct PostTask {
9732 pub id: String,
9733 pub r#type: TaskType,
9734}
9735
9736#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9737pub struct PostAssignTo {
9738 #[serde(default, skip_serializing_if = "Option::is_none")]
9739 pub id: Option<String>,
9740 #[serde(default, skip_serializing_if = "Option::is_none")]
9741 pub login: Option<String>,
9742}
9743
9744#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9745pub struct TaskAssignmentCreateRequest {
9746 pub task: PostTask,
9747 pub assign_to: PostAssignTo,
9748}
9749
9750#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9751pub struct TaskAssignmentUpdateRequest {
9752 #[serde(default, skip_serializing_if = "Option::is_none")]
9753 pub message: Option<String>,
9754 #[serde(default, skip_serializing_if = "Option::is_none")]
9755 pub resolution_state: Option<TaskAssignmentResolutionState>,
9756}
9757
9758#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9759pub struct SharedLinkPermissions3 {
9760 #[serde(default, skip_serializing_if = "Option::is_none")]
9761 pub can_download: Option<bool>,
9762 #[serde(default, skip_serializing_if = "Option::is_none")]
9763 pub can_preview: Option<bool>,
9764 #[serde(default, skip_serializing_if = "Option::is_none")]
9765 pub can_edit: Option<bool>,
9766}
9767
9768#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9769pub struct PutFileIdAddSharedLinkSharedLink {
9770 #[serde(default, skip_serializing_if = "Option::is_none")]
9771 pub access: Option<SharedLinkAccess>,
9772 #[serde(
9773 default,
9774 skip_serializing_if = "Option::is_none",
9775 deserialize_with = "double_option"
9776 )]
9777 pub password: Option<Option<String>>,
9778 #[serde(default, skip_serializing_if = "Option::is_none")]
9779 pub vanity_name: Option<String>,
9780 #[serde(default, skip_serializing_if = "Option::is_none")]
9781 pub unshared_at: Option<chrono::DateTime<chrono::Utc>>,
9782 #[serde(default, skip_serializing_if = "Option::is_none")]
9783 pub permissions: Option<SharedLinkPermissions3>,
9784}
9785
9786#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9787pub struct FileUpdateRequest2 {
9788 #[serde(default, skip_serializing_if = "Option::is_none")]
9789 pub shared_link: Option<PutFileIdAddSharedLinkSharedLink>,
9790}
9791
9792#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9793pub struct FileUpdateRequest3 {
9794 #[serde(
9795 default,
9796 skip_serializing_if = "Option::is_none",
9797 deserialize_with = "double_option"
9798 )]
9799 pub shared_link: Option<Option<std::collections::HashMap<String, serde_json::Value>>>,
9800}
9801
9802#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9803pub struct PutFolderIdUpdateSharedLinkSharedLink {
9804 #[serde(default, skip_serializing_if = "Option::is_none")]
9805 pub access: Option<SharedLinkAccess>,
9806 #[serde(default, skip_serializing_if = "Option::is_none")]
9807 pub password: Option<String>,
9808 #[serde(default, skip_serializing_if = "Option::is_none")]
9809 pub vanity_name: Option<String>,
9810 #[serde(default, skip_serializing_if = "Option::is_none")]
9811 pub unshared_at: Option<chrono::DateTime<chrono::Utc>>,
9812 #[serde(default, skip_serializing_if = "Option::is_none")]
9813 pub permissions: Option<SharedLinkPermissions3>,
9814}
9815
9816#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9817pub struct FolderUpdateRequest2 {
9818 #[serde(default, skip_serializing_if = "Option::is_none")]
9819 pub shared_link: Option<PutFolderIdUpdateSharedLinkSharedLink>,
9820}
9821
9822#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9823pub struct WebLinkCreateRequest {
9824 pub url: String,
9825 pub parent: AttributesParent,
9826 #[serde(default, skip_serializing_if = "Option::is_none")]
9827 pub name: Option<String>,
9828 #[serde(default, skip_serializing_if = "Option::is_none")]
9829 pub description: Option<String>,
9830}
9831
9832#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9833pub struct PutIdSharedLink2 {
9834 #[serde(default, skip_serializing_if = "Option::is_none")]
9835 pub access: Option<SharedLinkAccess>,
9836 #[serde(
9837 default,
9838 skip_serializing_if = "Option::is_none",
9839 deserialize_with = "double_option"
9840 )]
9841 pub password: Option<Option<String>>,
9842 #[serde(default, skip_serializing_if = "Option::is_none")]
9843 pub vanity_name: Option<String>,
9844 #[serde(default, skip_serializing_if = "Option::is_none")]
9845 pub unshared_at: Option<chrono::DateTime<chrono::Utc>>,
9846}
9847
9848#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9849pub struct WebLinkUpdateRequest {
9850 #[serde(default, skip_serializing_if = "Option::is_none")]
9851 pub url: Option<String>,
9852 #[serde(default, skip_serializing_if = "Option::is_none")]
9853 pub parent: Option<PutIdParent>,
9854 #[serde(default, skip_serializing_if = "Option::is_none")]
9855 pub name: Option<String>,
9856 #[serde(default, skip_serializing_if = "Option::is_none")]
9857 pub description: Option<String>,
9858 #[serde(default, skip_serializing_if = "Option::is_none")]
9859 pub shared_link: Option<PutIdSharedLink2>,
9860}
9861
9862#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9863#[serde(transparent)]
9864pub struct GetUserType(pub String);
9865
9866impl GetUserType {
9867 pub const ALL: &'static str = "all";
9868 pub const MANAGED: &'static str = "managed";
9869 pub const EXTERNAL: &'static str = "external";
9870}
9871
9872#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
9873#[serde(transparent)]
9874pub struct PostRole(pub String);
9875
9876impl PostRole {
9877 pub const COADMIN: &'static str = "coadmin";
9878 pub const USER: &'static str = "user";
9879}
9880
9881#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9882pub struct UserCreateRequest {
9883 pub name: String,
9884 #[serde(default, skip_serializing_if = "Option::is_none")]
9885 pub login: Option<String>,
9886 #[serde(default, skip_serializing_if = "Option::is_none")]
9887 pub is_platform_access_only: Option<bool>,
9888 #[serde(default, skip_serializing_if = "Option::is_none")]
9889 pub role: Option<PostRole>,
9890 #[serde(default, skip_serializing_if = "Option::is_none")]
9891 pub language: Option<String>,
9892 #[serde(default, skip_serializing_if = "Option::is_none")]
9893 pub is_sync_enabled: Option<bool>,
9894 #[serde(default, skip_serializing_if = "Option::is_none")]
9895 pub job_title: Option<String>,
9896 #[serde(default, skip_serializing_if = "Option::is_none")]
9897 pub phone: Option<String>,
9898 #[serde(default, skip_serializing_if = "Option::is_none")]
9899 pub address: Option<String>,
9900 #[serde(default, skip_serializing_if = "Option::is_none")]
9901 pub space_amount: Option<i64>,
9902 #[serde(default, skip_serializing_if = "Option::is_none")]
9903 pub tracking_codes: Option<Vec<TrackingCode>>,
9904 #[serde(default, skip_serializing_if = "Option::is_none")]
9905 pub can_see_managed_users: Option<bool>,
9906 #[serde(default, skip_serializing_if = "Option::is_none")]
9907 pub timezone: Option<String>,
9908 #[serde(default, skip_serializing_if = "Option::is_none")]
9909 pub is_external_collab_restricted: Option<bool>,
9910 #[serde(default, skip_serializing_if = "Option::is_none")]
9911 pub is_exempt_from_device_limits: Option<bool>,
9912 #[serde(default, skip_serializing_if = "Option::is_none")]
9913 pub is_exempt_from_login_verification: Option<bool>,
9914 #[serde(default, skip_serializing_if = "Option::is_none")]
9915 pub status: Option<UserStatus>,
9916 #[serde(default, skip_serializing_if = "Option::is_none")]
9917 pub external_app_user_id: Option<String>,
9918}
9919
9920#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9921pub struct UserTerminateSessionsCreateRequest {
9922 pub user_ids: Vec<String>,
9923 pub user_logins: Vec<String>,
9924}
9925
9926#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9927pub struct PutIdNotificationEmail {
9928 #[serde(default, skip_serializing_if = "Option::is_none")]
9929 pub email: Option<String>,
9930}
9931
9932#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9933pub struct UserUpdateRequest {
9934 #[serde(
9935 default,
9936 skip_serializing_if = "Option::is_none",
9937 deserialize_with = "double_option"
9938 )]
9939 pub enterprise: Option<Option<String>>,
9940 #[serde(default, skip_serializing_if = "Option::is_none")]
9941 pub notify: Option<bool>,
9942 #[serde(default, skip_serializing_if = "Option::is_none")]
9943 pub name: Option<String>,
9944 #[serde(default, skip_serializing_if = "Option::is_none")]
9945 pub login: Option<String>,
9946 #[serde(default, skip_serializing_if = "Option::is_none")]
9947 pub role: Option<PostRole>,
9948 #[serde(default, skip_serializing_if = "Option::is_none")]
9949 pub language: Option<String>,
9950 #[serde(default, skip_serializing_if = "Option::is_none")]
9951 pub is_sync_enabled: Option<bool>,
9952 #[serde(default, skip_serializing_if = "Option::is_none")]
9953 pub job_title: Option<String>,
9954 #[serde(default, skip_serializing_if = "Option::is_none")]
9955 pub phone: Option<String>,
9956 #[serde(default, skip_serializing_if = "Option::is_none")]
9957 pub address: Option<String>,
9958 #[serde(default, skip_serializing_if = "Option::is_none")]
9959 pub tracking_codes: Option<Vec<TrackingCode>>,
9960 #[serde(default, skip_serializing_if = "Option::is_none")]
9961 pub can_see_managed_users: Option<bool>,
9962 #[serde(default, skip_serializing_if = "Option::is_none")]
9963 pub timezone: Option<String>,
9964 #[serde(default, skip_serializing_if = "Option::is_none")]
9965 pub is_external_collab_restricted: Option<bool>,
9966 #[serde(default, skip_serializing_if = "Option::is_none")]
9967 pub is_exempt_from_device_limits: Option<bool>,
9968 #[serde(default, skip_serializing_if = "Option::is_none")]
9969 pub is_exempt_from_login_verification: Option<bool>,
9970 #[serde(default, skip_serializing_if = "Option::is_none")]
9971 pub is_password_reset_required: Option<bool>,
9972 #[serde(default, skip_serializing_if = "Option::is_none")]
9973 pub status: Option<UserStatus>,
9974 #[serde(default, skip_serializing_if = "Option::is_none")]
9975 pub space_amount: Option<i64>,
9976 #[serde(
9977 default,
9978 skip_serializing_if = "Option::is_none",
9979 deserialize_with = "double_option"
9980 )]
9981 pub notification_email: Option<Option<PutIdNotificationEmail>>,
9982 #[serde(default, skip_serializing_if = "Option::is_none")]
9983 pub external_app_user_id: Option<String>,
9984}
9985
9986#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9987pub struct UserAvatarCreateRequest {
9988 #[serde(skip)]
9989 pub pic: Vec<u8>,
9990}
9991
9992#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9993pub struct UserFolder0UpdateRequest {
9994 pub owned_by: AttributesParent,
9995}
9996
9997#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
9998pub struct UserIdCreateRequest {
9999 pub email: String,
10000}
10001
10002#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10003pub struct PostActionableBy {
10004 #[serde(default, skip_serializing_if = "Option::is_none")]
10005 pub login: Option<String>,
10006}
10007
10008#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10009pub struct InviteCreateRequest {
10010 pub enterprise: AttributesParent,
10011 pub actionable_by: PostActionableBy,
10012}
10013
10014#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10015pub struct GroupCreateRequest {
10016 pub name: String,
10017 #[serde(default, skip_serializing_if = "Option::is_none")]
10018 pub provenance: Option<String>,
10019 #[serde(default, skip_serializing_if = "Option::is_none")]
10020 pub external_sync_identifier: Option<String>,
10021 #[serde(default, skip_serializing_if = "Option::is_none")]
10022 pub description: Option<String>,
10023 #[serde(default, skip_serializing_if = "Option::is_none")]
10024 pub invitability_level: Option<GroupFullInvitabilityLevel>,
10025 #[serde(default, skip_serializing_if = "Option::is_none")]
10026 pub member_viewability_level: Option<GroupFullInvitabilityLevel>,
10027}
10028
10029#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10030pub struct GroupTerminateSessionsCreateRequest {
10031 pub group_ids: Vec<String>,
10032}
10033
10034#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10035pub struct GroupUpdateRequest {
10036 #[serde(default, skip_serializing_if = "Option::is_none")]
10037 pub name: Option<String>,
10038 #[serde(default, skip_serializing_if = "Option::is_none")]
10039 pub provenance: Option<String>,
10040 #[serde(default, skip_serializing_if = "Option::is_none")]
10041 pub external_sync_identifier: Option<String>,
10042 #[serde(default, skip_serializing_if = "Option::is_none")]
10043 pub description: Option<String>,
10044 #[serde(default, skip_serializing_if = "Option::is_none")]
10045 pub invitability_level: Option<GroupFullInvitabilityLevel>,
10046 #[serde(default, skip_serializing_if = "Option::is_none")]
10047 pub member_viewability_level: Option<GroupFullInvitabilityLevel>,
10048}
10049
10050#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10051pub struct GroupCreateRequest2 {
10052 pub user: AttributesParent,
10053 pub group: AttributesParent,
10054 #[serde(default, skip_serializing_if = "Option::is_none")]
10055 pub role: Option<GroupMembershipRole>,
10056 #[serde(
10057 default,
10058 skip_serializing_if = "Option::is_none",
10059 deserialize_with = "double_option"
10060 )]
10061 pub configurable_permissions: Option<Option<std::collections::HashMap<String, bool>>>,
10062}
10063
10064#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10065pub struct GroupUpdateRequest2 {
10066 #[serde(default, skip_serializing_if = "Option::is_none")]
10067 pub role: Option<GroupMembershipRole>,
10068 #[serde(
10069 default,
10070 skip_serializing_if = "Option::is_none",
10071 deserialize_with = "double_option"
10072 )]
10073 pub configurable_permissions: Option<Option<std::collections::HashMap<String, bool>>>,
10074}
10075
10076#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10077pub struct WebhookCreateRequest {
10078 pub target: WebhookTarget,
10079 pub address: String,
10080 pub triggers: Vec<WebhookTriggers>,
10081}
10082
10083#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10084pub struct WebhookUpdateRequest {
10085 #[serde(default, skip_serializing_if = "Option::is_none")]
10086 pub target: Option<WebhookTarget>,
10087 #[serde(default, skip_serializing_if = "Option::is_none")]
10088 pub address: Option<String>,
10089 #[serde(default, skip_serializing_if = "Option::is_none")]
10090 pub triggers: Option<Vec<WebhookTriggers>>,
10091}
10092
10093#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10094pub struct PutSkillInvocationIdMetadata {
10095 #[serde(default, skip_serializing_if = "Option::is_none")]
10096 pub cards: Option<Vec<SkillCard>>,
10097}
10098
10099#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10100pub struct PutSkillInvocationIdFile {
10101 #[serde(default, skip_serializing_if = "Option::is_none")]
10102 pub r#type: Option<AiCitationType>,
10103 #[serde(default, skip_serializing_if = "Option::is_none")]
10104 pub id: Option<String>,
10105}
10106
10107#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10108pub struct PutSkillInvocationIdFileVersion {
10109 #[serde(default, skip_serializing_if = "Option::is_none")]
10110 pub r#type: Option<FileVersionType>,
10111 #[serde(default, skip_serializing_if = "Option::is_none")]
10112 pub id: Option<String>,
10113}
10114
10115#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10116pub struct PutSkillInvocationIdUsage {
10117 #[serde(default, skip_serializing_if = "Option::is_none")]
10118 pub unit: Option<String>,
10119 #[serde(default, skip_serializing_if = "Option::is_none")]
10120 pub value: Option<f64>,
10121}
10122
10123#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10124pub struct SkillInvocationUpdateRequest {
10125 pub status: StatusCode,
10126 pub metadata: PutSkillInvocationIdMetadata,
10127 pub file: PutSkillInvocationIdFile,
10128 #[serde(default, skip_serializing_if = "Option::is_none")]
10129 pub file_version: Option<PutSkillInvocationIdFileVersion>,
10130 #[serde(default, skip_serializing_if = "Option::is_none")]
10131 pub usage: Option<PutSkillInvocationIdUsage>,
10132}
10133
10134#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
10135#[serde(transparent)]
10136pub struct GetStreamType(pub String);
10137
10138impl GetStreamType {
10139 pub const ALL: &'static str = "all";
10140 pub const CHANGES: &'static str = "changes";
10141 pub const SYNC: &'static str = "sync";
10142 pub const ADMIN_LOGS: &'static str = "admin_logs";
10143 pub const ADMIN_LOGS_STREAMING: &'static str = "admin_logs_streaming";
10144}
10145
10146#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
10147#[serde(transparent)]
10148pub struct GetEventType(pub String);
10149
10150impl GetEventType {
10151 pub const ACCESS_GRANTED: &'static str = "ACCESS_GRANTED";
10152 pub const ACCESS_REVOKED: &'static str = "ACCESS_REVOKED";
10153 pub const ADD_DEVICE_ASSOCIATION: &'static str = "ADD_DEVICE_ASSOCIATION";
10154 pub const ADD_LOGIN_ACTIVITY_DEVICE: &'static str = "ADD_LOGIN_ACTIVITY_DEVICE";
10155 pub const ADMIN_LOGIN: &'static str = "ADMIN_LOGIN";
10156 pub const ADVANCED_FOLDER_SETTINGS_UPDATE: &'static str = "ADVANCED_FOLDER_SETTINGS_UPDATE";
10157 pub const APPLICATION_CREATED: &'static str = "APPLICATION_CREATED";
10158 pub const APPLICATION_PUBLIC_KEY_ADDED: &'static str = "APPLICATION_PUBLIC_KEY_ADDED";
10159 pub const APPLICATION_PUBLIC_KEY_DELETED: &'static str = "APPLICATION_PUBLIC_KEY_DELETED";
10160 pub const CHANGE_ADMIN_ROLE: &'static str = "CHANGE_ADMIN_ROLE";
10161 pub const CHANGE_FOLDER_PERMISSION: &'static str = "CHANGE_FOLDER_PERMISSION";
10162 pub const COLLABORATION_ACCEPT: &'static str = "COLLABORATION_ACCEPT";
10163 pub const COLLABORATION_EXPIRATION: &'static str = "COLLABORATION_EXPIRATION";
10164 pub const COLLABORATION_INVITE: &'static str = "COLLABORATION_INVITE";
10165 pub const COLLABORATION_REMOVE: &'static str = "COLLABORATION_REMOVE";
10166 pub const COLLABORATION_ROLE_CHANGE: &'static str = "COLLABORATION_ROLE_CHANGE";
10167 pub const COMMENT_CREATE: &'static str = "COMMENT_CREATE";
10168 pub const COMMENT_DELETE: &'static str = "COMMENT_DELETE";
10169 pub const COMMENT_EDIT: &'static str = "COMMENT_EDIT";
10170 pub const CONTENT_WORKFLOW_ABNORMAL_DOWNLOAD_ACTIVITY: &'static str =
10171 "CONTENT_WORKFLOW_ABNORMAL_DOWNLOAD_ACTIVITY";
10172 pub const CONTENT_WORKFLOW_AUTOMATION_ADD: &'static str = "CONTENT_WORKFLOW_AUTOMATION_ADD";
10173 pub const CONTENT_WORKFLOW_AUTOMATION_DELETE: &'static str =
10174 "CONTENT_WORKFLOW_AUTOMATION_DELETE";
10175 pub const CONTENT_WORKFLOW_POLICY_ADD: &'static str = "CONTENT_WORKFLOW_POLICY_ADD";
10176 pub const CONTENT_WORKFLOW_SHARING_POLICY_VIOLATION: &'static str =
10177 "CONTENT_WORKFLOW_SHARING_POLICY_VIOLATION";
10178 pub const CONTENT_WORKFLOW_UPLOAD_POLICY_VIOLATION: &'static str =
10179 "CONTENT_WORKFLOW_UPLOAD_POLICY_VIOLATION";
10180 pub const COPY: &'static str = "COPY";
10181 pub const DATA_RETENTION_CREATE_RETENTION: &'static str = "DATA_RETENTION_CREATE_RETENTION";
10182 pub const DATA_RETENTION_REMOVE_RETENTION: &'static str = "DATA_RETENTION_REMOVE_RETENTION";
10183 pub const DELETE: &'static str = "DELETE";
10184 pub const DELETE_USER: &'static str = "DELETE_USER";
10185 pub const DEVICE_TRUST_CHECK_FAILED: &'static str = "DEVICE_TRUST_CHECK_FAILED";
10186 pub const DOWNLOAD: &'static str = "DOWNLOAD";
10187 pub const EDIT: &'static str = "EDIT";
10188 pub const EDIT_USER: &'static str = "EDIT_USER";
10189 pub const EMAIL_ALIAS_CONFIRM: &'static str = "EMAIL_ALIAS_CONFIRM";
10190 pub const EMAIL_ALIAS_PRIMARY: &'static str = "EMAIL_ALIAS_PRIMARY";
10191 pub const EMAIL_ALIAS_REMOVE: &'static str = "EMAIL_ALIAS_REMOVE";
10192 pub const EMAIL_UPLOAD_DISABLED: &'static str = "EMAIL_UPLOAD_DISABLED";
10193 pub const EMAIL_UPLOAD_ENABLED: &'static str = "EMAIL_UPLOAD_ENABLED";
10194 pub const ENTERPRISE_APP_AUTHORIZATION_UPDATE: &'static str =
10195 "ENTERPRISE_APP_AUTHORIZATION_UPDATE";
10196 pub const EXTERNAL_COLLAB_SECURITY_SETTINGS: &'static str = "EXTERNAL_COLLAB_SECURITY_SETTINGS";
10197 pub const FAILED_LOGIN: &'static str = "FAILED_LOGIN";
10198 pub const FAVORITE: &'static str = "FAVORITE";
10199 pub const FILE_MARKED_MALICIOUS: &'static str = "FILE_MARKED_MALICIOUS";
10200 pub const FILE_REQUEST_CREATE: &'static str = "FILE_REQUEST_CREATE";
10201 pub const FILE_REQUEST_DELETE: &'static str = "FILE_REQUEST_DELETE";
10202 pub const FILE_REQUEST_UPDATE: &'static str = "FILE_REQUEST_UPDATE";
10203 pub const FILE_VERSION_RESTORE: &'static str = "FILE_VERSION_RESTORE";
10204 pub const FILE_WATERMARKED_DOWNLOAD: &'static str = "FILE_WATERMARKED_DOWNLOAD";
10205 pub const GROUP_ADD_ITEM: &'static str = "GROUP_ADD_ITEM";
10206 pub const GROUP_ADD_USER: &'static str = "GROUP_ADD_USER";
10207 pub const GROUP_CREATION: &'static str = "GROUP_CREATION";
10208 pub const GROUP_DELETION: &'static str = "GROUP_DELETION";
10209 pub const GROUP_EDITED: &'static str = "GROUP_EDITED";
10210 pub const GROUP_REMOVE_ITEM: &'static str = "GROUP_REMOVE_ITEM";
10211 pub const GROUP_REMOVE_USER: &'static str = "GROUP_REMOVE_USER";
10212 pub const ILLEGAL_ITEM_OWNERSHIP_TRANSFER_BY_USER: &'static str =
10213 "ILLEGAL_ITEM_OWNERSHIP_TRANSFER_BY_USER";
10214 pub const ITEM_EMAIL_SEND: &'static str = "ITEM_EMAIL_SEND";
10215 pub const ITEM_MODIFY: &'static str = "ITEM_MODIFY";
10216 pub const ITEM_OPEN: &'static str = "ITEM_OPEN";
10217 pub const ITEM_SHARED_UPDATE: &'static str = "ITEM_SHARED_UPDATE";
10218 pub const ITEM_SYNC: &'static str = "ITEM_SYNC";
10219 pub const ITEM_UNSYNC: &'static str = "ITEM_UNSYNC";
10220 pub const LEGAL_HOLD_ASSIGNMENT_CREATE: &'static str = "LEGAL_HOLD_ASSIGNMENT_CREATE";
10221 pub const LEGAL_HOLD_ASSIGNMENT_DELETE: &'static str = "LEGAL_HOLD_ASSIGNMENT_DELETE";
10222 pub const LEGAL_HOLD_POLICY_CREATE: &'static str = "LEGAL_HOLD_POLICY_CREATE";
10223 pub const LEGAL_HOLD_POLICY_DELETE: &'static str = "LEGAL_HOLD_POLICY_DELETE";
10224 pub const LEGAL_HOLD_POLICY_UPDATE: &'static str = "LEGAL_HOLD_POLICY_UPDATE";
10225 pub const LOCK: &'static str = "LOCK";
10226 pub const LOGIN: &'static str = "LOGIN";
10227 pub const METADATA_CASCADE_POLICY_APPLY: &'static str = "METADATA_CASCADE_POLICY_APPLY";
10228 pub const METADATA_CASCADE_POLICY_CREATE: &'static str = "METADATA_CASCADE_POLICY_CREATE";
10229 pub const METADATA_INSTANCE_COPY: &'static str = "METADATA_INSTANCE_COPY";
10230 pub const METADATA_INSTANCE_CREATE: &'static str = "METADATA_INSTANCE_CREATE";
10231 pub const METADATA_INSTANCE_DELETE: &'static str = "METADATA_INSTANCE_DELETE";
10232 pub const METADATA_INSTANCE_UPDATE: &'static str = "METADATA_INSTANCE_UPDATE";
10233 pub const METADATA_TEMPLATE_CREATE: &'static str = "METADATA_TEMPLATE_CREATE";
10234 pub const METADATA_TEMPLATE_DELETE: &'static str = "METADATA_TEMPLATE_DELETE";
10235 pub const METADATA_TEMPLATE_UPDATE: &'static str = "METADATA_TEMPLATE_UPDATE";
10236 pub const MOVE: &'static str = "MOVE";
10237 pub const NEW_USER: &'static str = "NEW_USER";
10238 pub const OAUTH2_ACCESS_TOKEN_REVOKE: &'static str = "OAUTH2_ACCESS_TOKEN_REVOKE";
10239 pub const OAUTH2_REFRESH_TOKEN_REVOKE: &'static str = "OAUTH2_REFRESH_TOKEN_REVOKE";
10240 pub const PREVIEW: &'static str = "PREVIEW";
10241 pub const REMOVE_DEVICE_ASSOCIATION: &'static str = "REMOVE_DEVICE_ASSOCIATION";
10242 pub const REMOVE_LOGIN_ACTIVITY_DEVICE: &'static str = "REMOVE_LOGIN_ACTIVITY_DEVICE";
10243 pub const RENAME: &'static str = "RENAME";
10244 pub const RETENTION_POLICY_ASSIGNMENT_ADD: &'static str = "RETENTION_POLICY_ASSIGNMENT_ADD";
10245 pub const SHARE: &'static str = "SHARE";
10246 pub const SHARED_LINK_SEND: &'static str = "SHARED_LINK_SEND";
10247 pub const SHARE_EXPIRATION: &'static str = "SHARE_EXPIRATION";
10248 pub const SHIELD_ALERT: &'static str = "SHIELD_ALERT";
10249 pub const SHIELD_EXTERNAL_COLLAB_ACCESS_BLOCKED: &'static str =
10250 "SHIELD_EXTERNAL_COLLAB_ACCESS_BLOCKED";
10251 pub const SHIELD_EXTERNAL_COLLAB_ACCESS_BLOCKED_MISSING_JUSTIFICATION: &'static str =
10252 "SHIELD_EXTERNAL_COLLAB_ACCESS_BLOCKED_MISSING_JUSTIFICATION";
10253 pub const SHIELD_EXTERNAL_COLLAB_INVITE_BLOCKED: &'static str =
10254 "SHIELD_EXTERNAL_COLLAB_INVITE_BLOCKED";
10255 pub const SHIELD_EXTERNAL_COLLAB_INVITE_BLOCKED_MISSING_JUSTIFICATION: &'static str =
10256 "SHIELD_EXTERNAL_COLLAB_INVITE_BLOCKED_MISSING_JUSTIFICATION";
10257 pub const SHIELD_JUSTIFICATION_APPROVAL: &'static str = "SHIELD_JUSTIFICATION_APPROVAL";
10258 pub const SHIELD_SHARED_LINK_ACCESS_BLOCKED: &'static str = "SHIELD_SHARED_LINK_ACCESS_BLOCKED";
10259 pub const SHIELD_SHARED_LINK_STATUS_RESTRICTED_ON_CREATE: &'static str =
10260 "SHIELD_SHARED_LINK_STATUS_RESTRICTED_ON_CREATE";
10261 pub const SHIELD_SHARED_LINK_STATUS_RESTRICTED_ON_UPDATE: &'static str =
10262 "SHIELD_SHARED_LINK_STATUS_RESTRICTED_ON_UPDATE";
10263 pub const SIGN_DOCUMENT_ASSIGNED: &'static str = "SIGN_DOCUMENT_ASSIGNED";
10264 pub const SIGN_DOCUMENT_CANCELLED: &'static str = "SIGN_DOCUMENT_CANCELLED";
10265 pub const SIGN_DOCUMENT_COMPLETED: &'static str = "SIGN_DOCUMENT_COMPLETED";
10266 pub const SIGN_DOCUMENT_CONVERTED: &'static str = "SIGN_DOCUMENT_CONVERTED";
10267 pub const SIGN_DOCUMENT_CREATED: &'static str = "SIGN_DOCUMENT_CREATED";
10268 pub const SIGN_DOCUMENT_DECLINED: &'static str = "SIGN_DOCUMENT_DECLINED";
10269 pub const SIGN_DOCUMENT_EXPIRED: &'static str = "SIGN_DOCUMENT_EXPIRED";
10270 pub const SIGN_DOCUMENT_SIGNED: &'static str = "SIGN_DOCUMENT_SIGNED";
10271 pub const SIGN_DOCUMENT_VIEWED_BY_SIGNED: &'static str = "SIGN_DOCUMENT_VIEWED_BY_SIGNED";
10272 pub const SIGNER_DOWNLOADED: &'static str = "SIGNER_DOWNLOADED";
10273 pub const SIGNER_FORWARDED: &'static str = "SIGNER_FORWARDED";
10274 pub const STORAGE_EXPIRATION: &'static str = "STORAGE_EXPIRATION";
10275 pub const TASK_ASSIGNMENT_CREATE: &'static str = "TASK_ASSIGNMENT_CREATE";
10276 pub const TASK_ASSIGNMENT_DELETE: &'static str = "TASK_ASSIGNMENT_DELETE";
10277 pub const TASK_ASSIGNMENT_UPDATE: &'static str = "TASK_ASSIGNMENT_UPDATE";
10278 pub const TASK_CREATE: &'static str = "TASK_CREATE";
10279 pub const TASK_UPDATE: &'static str = "TASK_UPDATE";
10280 pub const TERMS_OF_SERVICE_ACCEPT: &'static str = "TERMS_OF_SERVICE_ACCEPT";
10281 pub const TERMS_OF_SERVICE_REJECT: &'static str = "TERMS_OF_SERVICE_REJECT";
10282 pub const UNDELETE: &'static str = "UNDELETE";
10283 pub const UNFAVORITE: &'static str = "UNFAVORITE";
10284 pub const UNLOCK: &'static str = "UNLOCK";
10285 pub const UNSHARE: &'static str = "UNSHARE";
10286 pub const UPDATE_COLLABORATION_EXPIRATION: &'static str = "UPDATE_COLLABORATION_EXPIRATION";
10287 pub const UPDATE_SHARE_EXPIRATION: &'static str = "UPDATE_SHARE_EXPIRATION";
10288 pub const UPLOAD: &'static str = "UPLOAD";
10289 pub const USER_AUTHENTICATE_OAUTH2_ACCESS_TOKEN_CREATE: &'static str =
10290 "USER_AUTHENTICATE_OAUTH2_ACCESS_TOKEN_CREATE";
10291 pub const WATERMARK_LABEL_CREATE: &'static str = "WATERMARK_LABEL_CREATE";
10292 pub const WATERMARK_LABEL_DELETE: &'static str = "WATERMARK_LABEL_DELETE";
10293 pub const WORKFLOW_AUTOMATION_CREATE: &'static str = "WORKFLOW_AUTOMATION_CREATE";
10294 pub const WORKFLOW_AUTOMATION_DELETE: &'static str = "WORKFLOW_AUTOMATION_DELETE";
10295 pub const WORKFLOW_AUTOMATION_UPDATE: &'static str = "WORKFLOW_AUTOMATION_UPDATE";
10296}
10297
10298#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10299#[serde(transparent)]
10300pub struct PostRetentionLength(pub serde_json::Value);
10301
10302#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10303pub struct RetentionPolicyCreateRequest {
10304 pub policy_name: String,
10305 #[serde(default, skip_serializing_if = "Option::is_none")]
10306 pub description: Option<String>,
10307 pub policy_type: RetentionPolicyPolicyType,
10308 pub disposition_action: RetentionPolicyDispositionAction,
10309 #[serde(default, skip_serializing_if = "Option::is_none")]
10310 pub retention_length: Option<PostRetentionLength>,
10311 #[serde(default, skip_serializing_if = "Option::is_none")]
10312 pub retention_type: Option<RetentionPolicyRetentionType>,
10313 #[serde(default, skip_serializing_if = "Option::is_none")]
10314 pub can_owner_extend_retention: Option<bool>,
10315 #[serde(default, skip_serializing_if = "Option::is_none")]
10316 pub max_extension_length: Option<RetentionPolicyMaxExtensionLengthRequest>,
10317 #[serde(default, skip_serializing_if = "Option::is_none")]
10318 pub are_owners_notified: Option<bool>,
10319 #[serde(default, skip_serializing_if = "Option::is_none")]
10320 pub custom_notification_recipients: Option<Vec<UserMini>>,
10321}
10322
10323#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10324#[serde(transparent)]
10325pub struct PutIdDispositionAction(pub serde_json::Value);
10326
10327#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10328pub struct RetentionPolicyUpdateRequest {
10329 #[serde(
10330 default,
10331 skip_serializing_if = "Option::is_none",
10332 deserialize_with = "double_option"
10333 )]
10334 pub policy_name: Option<Option<String>>,
10335 #[serde(
10336 default,
10337 skip_serializing_if = "Option::is_none",
10338 deserialize_with = "double_option"
10339 )]
10340 pub description: Option<Option<String>>,
10341 #[serde(default, skip_serializing_if = "Option::is_none")]
10342 pub disposition_action: Option<PutIdDispositionAction>,
10343 #[serde(
10344 default,
10345 skip_serializing_if = "Option::is_none",
10346 deserialize_with = "double_option"
10347 )]
10348 pub retention_type: Option<Option<String>>,
10349 #[serde(default, skip_serializing_if = "Option::is_none")]
10350 pub retention_length: Option<PostRetentionLength>,
10351 #[serde(
10352 default,
10353 skip_serializing_if = "Option::is_none",
10354 deserialize_with = "double_option"
10355 )]
10356 pub status: Option<Option<String>>,
10357 #[serde(
10358 default,
10359 skip_serializing_if = "Option::is_none",
10360 deserialize_with = "double_option"
10361 )]
10362 pub can_owner_extend_retention: Option<Option<bool>>,
10363 #[serde(default, skip_serializing_if = "Option::is_none")]
10364 pub max_extension_length: Option<RetentionPolicyMaxExtensionLengthRequest>,
10365 #[serde(
10366 default,
10367 skip_serializing_if = "Option::is_none",
10368 deserialize_with = "double_option"
10369 )]
10370 pub are_owners_notified: Option<Option<bool>>,
10371 #[serde(
10372 default,
10373 skip_serializing_if = "Option::is_none",
10374 deserialize_with = "double_option"
10375 )]
10376 pub custom_notification_recipients: Option<Option<Vec<UserBase>>>,
10377}
10378
10379#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
10380#[serde(transparent)]
10381pub struct AssignToType(pub String);
10382
10383impl AssignToType {
10384 pub const ENTERPRISE: &'static str = "enterprise";
10385 pub const FOLDER: &'static str = "folder";
10386 pub const METADATA_TEMPLATE: &'static str = "metadata_template";
10387}
10388
10389#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10390pub struct PostAssignTo2 {
10391 pub r#type: AssignToType,
10392 #[serde(
10393 default,
10394 skip_serializing_if = "Option::is_none",
10395 deserialize_with = "double_option"
10396 )]
10397 pub id: Option<Option<String>>,
10398}
10399
10400#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10401pub struct PostFilterFields {
10402 #[serde(default, skip_serializing_if = "Option::is_none")]
10403 pub field: Option<String>,
10404 #[serde(default, skip_serializing_if = "Option::is_none")]
10405 pub value: Option<String>,
10406}
10407
10408#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10409pub struct RetentionPolicyAssignmentCreateRequest {
10410 pub policy_id: String,
10411 pub assign_to: PostAssignTo2,
10412 #[serde(default, skip_serializing_if = "Option::is_none")]
10413 pub filter_fields: Option<Vec<PostFilterFields>>,
10414 #[serde(default, skip_serializing_if = "Option::is_none")]
10415 pub start_date_field: Option<String>,
10416}
10417
10418#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10419pub struct LegalHoldPolicyCreateRequest {
10420 pub policy_name: String,
10421 #[serde(default, skip_serializing_if = "Option::is_none")]
10422 pub description: Option<String>,
10423 #[serde(default, skip_serializing_if = "Option::is_none")]
10424 pub filter_started_at: Option<chrono::DateTime<chrono::Utc>>,
10425 #[serde(default, skip_serializing_if = "Option::is_none")]
10426 pub filter_ended_at: Option<chrono::DateTime<chrono::Utc>>,
10427 #[serde(default, skip_serializing_if = "Option::is_none")]
10428 pub is_ongoing: Option<bool>,
10429}
10430
10431#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10432pub struct LegalHoldPolicyUpdateRequest {
10433 #[serde(default, skip_serializing_if = "Option::is_none")]
10434 pub policy_name: Option<String>,
10435 #[serde(default, skip_serializing_if = "Option::is_none")]
10436 pub description: Option<String>,
10437 #[serde(default, skip_serializing_if = "Option::is_none")]
10438 pub release_notes: Option<String>,
10439}
10440
10441#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10442pub struct PostAssignTo3 {
10443 pub r#type: LegalHoldPolicyAssignedItemType,
10444 pub id: String,
10445}
10446
10447#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10448pub struct LegalHoldPolicyAssignmentCreateRequest {
10449 pub policy_id: String,
10450 pub assign_to: PostAssignTo3,
10451}
10452
10453#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
10454#[serde(transparent)]
10455pub struct PostChangeStatusStatus(pub String);
10456
10457impl PostChangeStatusStatus {
10458 pub const PENDING: &'static str = "pending";
10459 pub const DISABLED: &'static str = "disabled";
10460}
10461
10462#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10463pub struct ChangeStatusCreateRequest {
10464 pub id: String,
10465 pub status: PostChangeStatusStatus,
10466}
10467
10468#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10469pub struct ShieldInformationBarrierCreateRequest {
10470 pub enterprise: EnterpriseBase,
10471}
10472
10473#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10474pub struct ShieldInformationBarrierSegmentUpdateRequest {
10475 #[serde(default, skip_serializing_if = "Option::is_none")]
10476 pub name: Option<String>,
10477 #[serde(
10478 default,
10479 skip_serializing_if = "Option::is_none",
10480 deserialize_with = "double_option"
10481 )]
10482 pub description: Option<Option<String>>,
10483}
10484
10485#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10486pub struct ShieldInformationBarrierSegmentCreateRequest {
10487 pub shield_information_barrier: ShieldInformationBarrierBase,
10488 pub name: String,
10489 #[serde(default, skip_serializing_if = "Option::is_none")]
10490 pub description: Option<String>,
10491}
10492
10493#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10494pub struct ShieldInformationBarrierSegmentMemberCreateRequest {
10495 #[serde(default, skip_serializing_if = "Option::is_none")]
10496 pub r#type: Option<ShieldInformationBarrierSegmentMemberType>,
10497 #[serde(default, skip_serializing_if = "Option::is_none")]
10498 pub shield_information_barrier: Option<ShieldInformationBarrierBase>,
10499 pub shield_information_barrier_segment:
10500 ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment,
10501 pub user: UserBase,
10502}
10503
10504#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10505pub struct ShieldInformationBarrierSegmentRestrictionCreateRequest {
10506 pub r#type: ShieldInformationBarrierSegmentRestrictionType,
10507 #[serde(default, skip_serializing_if = "Option::is_none")]
10508 pub shield_information_barrier: Option<ShieldInformationBarrierBase>,
10509 pub shield_information_barrier_segment:
10510 ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment,
10511 pub restricted_segment: ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment,
10512}
10513
10514#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
10515#[serde(transparent)]
10516pub struct GetTosType(pub String);
10517
10518impl GetTosType {
10519 pub const EXTERNAL: &'static str = "external";
10520 pub const MANAGED: &'static str = "managed";
10521}
10522
10523#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10524pub struct TermsOfServiceCreateRequest {
10525 pub status: TermsOfServiceStatus,
10526 #[serde(default, skip_serializing_if = "Option::is_none")]
10527 pub tos_type: Option<GetTosType>,
10528 pub text: String,
10529}
10530
10531#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10532pub struct TermsOfServiceUpdateRequest {
10533 pub status: TermsOfServiceStatus,
10534 pub text: String,
10535}
10536
10537#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10538pub struct PostTos {
10539 pub r#type: TermsOfServiceType,
10540 pub id: String,
10541}
10542
10543#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10544pub struct TermsOfServiceUserStatuseCreateRequest {
10545 pub tos: PostTos,
10546 pub user: CollaboratorVariableVariableValue,
10547 pub is_accepted: bool,
10548}
10549
10550#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10551pub struct TermsOfServiceUserStatuseUpdateRequest {
10552 pub is_accepted: bool,
10553}
10554
10555#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10556pub struct CollaborationWhitelistEntriesCreateRequest {
10557 pub domain: String,
10558 pub direction: CollaborationAllowlistEntryDirection,
10559}
10560
10561#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10562pub struct CollaborationWhitelistExemptTargetsCreateRequest {
10563 pub user: AttributesParent,
10564}
10565
10566#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
10567#[serde(transparent)]
10568pub struct GetResolvedForType(pub String);
10569
10570impl GetResolvedForType {
10571 pub const USER: &'static str = "user";
10572 pub const ENTERPRISE: &'static str = "enterprise";
10573}
10574
10575#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10576pub struct PostStoragePolicy {
10577 pub r#type: StoragePolicyType,
10578 pub id: String,
10579}
10580
10581#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10582pub struct PostAssignedTo {
10583 pub r#type: GetResolvedForType,
10584 pub id: String,
10585}
10586
10587#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10588pub struct StoragePolicyAssignmentCreateRequest {
10589 pub storage_policy: PostStoragePolicy,
10590 pub assigned_to: PostAssignedTo,
10591}
10592
10593#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10594pub struct StoragePolicyAssignmentUpdateRequest {
10595 pub storage_policy: PostStoragePolicy,
10596}
10597
10598#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
10599#[serde(transparent)]
10600pub struct PostIdStartType(pub String);
10601
10602impl PostIdStartType {
10603 pub const WORKFLOW_PARAMETERS: &'static str = "workflow_parameters";
10604}
10605
10606#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10607pub struct PostIdStartFlow {
10608 #[serde(default, skip_serializing_if = "Option::is_none")]
10609 pub r#type: Option<String>,
10610 #[serde(default, skip_serializing_if = "Option::is_none")]
10611 pub id: Option<String>,
10612}
10613
10614#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10615pub struct WorkflowStartRequest {
10616 #[serde(default, skip_serializing_if = "Option::is_none")]
10617 pub r#type: Option<PostIdStartType>,
10618 pub flow: PostIdStartFlow,
10619 pub files: Vec<PutSkillInvocationIdFile>,
10620 pub folder: MetadataCascadePolicyParent,
10621 #[serde(default, skip_serializing_if = "Option::is_none")]
10622 pub outcomes: Option<Vec<Outcome>>,
10623}
10624
10625#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10626pub struct SlackUpdateRequest {
10627 #[serde(default, skip_serializing_if = "Option::is_none")]
10628 pub box_item: Option<IntegrationMappingBoxItemSlack>,
10629 #[serde(default, skip_serializing_if = "Option::is_none")]
10630 pub options: Option<IntegrationMappingSlackOptions>,
10631}
10632
10633#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10634pub struct TeamUpdateRequest {
10635 #[serde(default, skip_serializing_if = "Option::is_none")]
10636 pub box_item: Option<FolderReference>,
10637}
10638
10639#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
10640#[serde(transparent)]
10641pub struct GetAgentDefaultMode(pub String);
10642
10643impl GetAgentDefaultMode {
10644 pub const ASK: &'static str = "ask";
10645 pub const TEXT_GEN: &'static str = "text_gen";
10646 pub const EXTRACT: &'static str = "extract";
10647 pub const EXTRACT_STRUCTURED: &'static str = "extract_structured";
10648}
10649
10650#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10651pub struct MetadataTaxonomyCreateRequest {
10652 #[serde(default, skip_serializing_if = "Option::is_none")]
10653 pub key: Option<String>,
10654 #[serde(rename = "displayName")]
10655 pub display_name: String,
10656 pub namespace: String,
10657}
10658
10659#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10660pub struct MetadataTaxonomyUpdateRequest {
10661 #[serde(rename = "displayName")]
10662 pub display_name: String,
10663}
10664
10665#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10666pub struct LevelUpdateRequest {
10667 #[serde(rename = "displayName")]
10668 pub display_name: String,
10669 #[serde(default, skip_serializing_if = "Option::is_none")]
10670 pub description: Option<String>,
10671}
10672
10673#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10674pub struct NodesCreateRequest {
10675 #[serde(rename = "displayName")]
10676 pub display_name: String,
10677 pub level: i64,
10678 #[serde(rename = "parentId", default, skip_serializing_if = "Option::is_none")]
10679 pub parent_id: Option<String>,
10680}
10681
10682#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10683pub struct NodeUpdateRequest {
10684 #[serde(
10685 rename = "displayName",
10686 default,
10687 skip_serializing_if = "Option::is_none"
10688 )]
10689 pub display_name: Option<String>,
10690}
10691
10692#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10693pub struct Archive {
10694 pub id: String,
10695 pub r#type: ArchiveType,
10696 pub name: String,
10697 pub size: i64,
10698 #[serde(
10699 default,
10700 skip_serializing_if = "Option::is_none",
10701 deserialize_with = "double_option"
10702 )]
10703 pub description: Option<Option<String>>,
10704 #[serde(default, skip_serializing_if = "Option::is_none")]
10705 pub owned_by: Option<ArchiveOwnedBy>,
10706}
10707
10708#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10709pub struct Archives {
10710 #[serde(default, skip_serializing_if = "Option::is_none")]
10711 pub entries: Option<Vec<Archive>>,
10712 #[serde(default, skip_serializing_if = "Option::is_none")]
10713 pub limit: Option<i64>,
10714 #[serde(
10715 default,
10716 skip_serializing_if = "Option::is_none",
10717 deserialize_with = "double_option"
10718 )]
10719 pub next_marker: Option<Option<String>>,
10720}
10721
10722#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10723pub struct CollaborationPermissions {
10724 #[serde(default, skip_serializing_if = "Option::is_none")]
10725 pub is_co_owner_role_enabled: Option<bool>,
10726 #[serde(default, skip_serializing_if = "Option::is_none")]
10727 pub is_editor_role_enabled: Option<bool>,
10728 #[serde(default, skip_serializing_if = "Option::is_none")]
10729 pub is_previewer_role_enabled: Option<bool>,
10730 #[serde(default, skip_serializing_if = "Option::is_none")]
10731 pub is_previewer_uploader_role_enabled: Option<bool>,
10732 #[serde(default, skip_serializing_if = "Option::is_none")]
10733 pub is_uploader_role_enabled: Option<bool>,
10734 #[serde(default, skip_serializing_if = "Option::is_none")]
10735 pub is_viewer_role_enabled: Option<bool>,
10736 #[serde(default, skip_serializing_if = "Option::is_none")]
10737 pub is_viewer_uploader_role_enabled: Option<bool>,
10738}
10739
10740#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10741pub struct CustomSessionDurationGroupItem {
10742 #[serde(default, skip_serializing_if = "Option::is_none")]
10743 pub id: Option<String>,
10744 #[serde(default, skip_serializing_if = "Option::is_none")]
10745 pub name: Option<String>,
10746}
10747
10748#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10749pub struct DocGenBatchBase {
10750 pub id: String,
10751 pub r#type: DocGenBatchBaseType,
10752}
10753
10754#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10755pub struct DocGenBatchCreateRequest {
10756 pub file: FileReference,
10757 #[serde(default, skip_serializing_if = "Option::is_none")]
10758 pub file_version: Option<FileVersionBase>,
10759 pub input_source: String,
10760 pub destination_folder: DocGenBatchCreateRequestDestinationFolder,
10761 pub output_type: String,
10762 pub document_generation_data: Vec<DocGenDocumentGenerationData>,
10763}
10764
10765#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10766pub struct DocGenDocumentGenerationData {
10767 pub generated_file_name: String,
10768 pub user_input: std::collections::HashMap<String, serde_json::Value>,
10769}
10770
10771#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10772pub struct DocGenJob {
10773 pub id: String,
10774 pub r#type: DocGenJobType,
10775 pub batch: DocGenBatchBase,
10776 pub template_file: FileReference,
10777 pub template_file_version: FileVersionBase,
10778 #[serde(default, skip_serializing_if = "Option::is_none")]
10779 pub output_file: Option<DocGenJobOutputFile>,
10780 #[serde(default, skip_serializing_if = "Option::is_none")]
10781 pub output_file_version: Option<DocGenJobOutputFileVersion>,
10782 pub status: DocGenJobStatus,
10783 pub output_type: String,
10784 #[serde(
10785 default,
10786 skip_serializing_if = "Option::is_none",
10787 deserialize_with = "double_option"
10788 )]
10789 pub failures: Option<Option<DocGenJobFailures>>,
10790}
10791
10792#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10793pub struct DocGenJobBase {
10794 pub id: String,
10795 pub r#type: DocGenJobType,
10796}
10797
10798#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10799pub struct DocGenJobFull {
10800 pub id: String,
10801 pub r#type: DocGenJobType,
10802 pub batch: DocGenBatchBase,
10803 pub template_file: FileReference,
10804 pub template_file_version: FileVersionBase,
10805 #[serde(default, skip_serializing_if = "Option::is_none")]
10806 pub output_file: Option<DocGenJobOutputFile>,
10807 #[serde(default, skip_serializing_if = "Option::is_none")]
10808 pub output_file_version: Option<DocGenJobOutputFileVersion>,
10809 pub status: DocGenJobStatus,
10810 pub output_type: String,
10811 #[serde(
10812 default,
10813 skip_serializing_if = "Option::is_none",
10814 deserialize_with = "double_option"
10815 )]
10816 pub failures: Option<Option<DocGenJobFailures>>,
10817 #[serde(default, skip_serializing_if = "Option::is_none")]
10818 pub created_at: Option<String>,
10819 pub created_by: UserBase,
10820 pub enterprise: EnterpriseReference,
10821 pub source: String,
10822}
10823
10824#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10825pub struct DocGenJobs {
10826 #[serde(default, skip_serializing_if = "Option::is_none")]
10827 pub limit: Option<i64>,
10828 #[serde(
10829 default,
10830 skip_serializing_if = "Option::is_none",
10831 deserialize_with = "double_option"
10832 )]
10833 pub next_marker: Option<Option<String>>,
10834 #[serde(
10835 default,
10836 skip_serializing_if = "Option::is_none",
10837 deserialize_with = "double_option"
10838 )]
10839 pub prev_marker: Option<Option<String>>,
10840 #[serde(default, skip_serializing_if = "Option::is_none")]
10841 pub entries: Option<Vec<DocGenJob>>,
10842}
10843
10844#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10845pub struct DocGenJobsFull {
10846 #[serde(default, skip_serializing_if = "Option::is_none")]
10847 pub limit: Option<i64>,
10848 #[serde(
10849 default,
10850 skip_serializing_if = "Option::is_none",
10851 deserialize_with = "double_option"
10852 )]
10853 pub next_marker: Option<Option<String>>,
10854 #[serde(
10855 default,
10856 skip_serializing_if = "Option::is_none",
10857 deserialize_with = "double_option"
10858 )]
10859 pub prev_marker: Option<Option<String>>,
10860 #[serde(default, skip_serializing_if = "Option::is_none")]
10861 pub entries: Option<Vec<DocGenJobFull>>,
10862}
10863
10864#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10865pub struct DocGenTag {
10866 pub tag_content: String,
10867 pub tag_type: DocGenTagTagType,
10868 pub json_paths: Vec<String>,
10869}
10870
10871#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10872pub struct DocGenTags {
10873 #[serde(default, skip_serializing_if = "Option::is_none")]
10874 pub limit: Option<i64>,
10875 #[serde(
10876 default,
10877 skip_serializing_if = "Option::is_none",
10878 deserialize_with = "double_option"
10879 )]
10880 pub next_marker: Option<Option<String>>,
10881 #[serde(
10882 default,
10883 skip_serializing_if = "Option::is_none",
10884 deserialize_with = "double_option"
10885 )]
10886 pub prev_marker: Option<Option<String>>,
10887 #[serde(default, skip_serializing_if = "Option::is_none")]
10888 pub entries: Option<Vec<DocGenTag>>,
10889}
10890
10891#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10892pub struct DocGenTagsProcessingMessage {
10893 pub message: String,
10894}
10895
10896#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10897pub struct DocGenTemplate {
10898 #[serde(default, skip_serializing_if = "Option::is_none")]
10899 pub file: Option<FileReference>,
10900 #[serde(
10901 default,
10902 skip_serializing_if = "Option::is_none",
10903 deserialize_with = "double_option"
10904 )]
10905 pub file_name: Option<Option<String>>,
10906}
10907
10908#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10909pub struct DocGenTemplateBase {
10910 #[serde(default, skip_serializing_if = "Option::is_none")]
10911 pub file: Option<FileReference>,
10912}
10913
10914#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10915pub struct DocGenTemplateCreateRequest {
10916 pub file: FileReference,
10917}
10918
10919#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10920pub struct DocGenTemplates {
10921 #[serde(default, skip_serializing_if = "Option::is_none")]
10922 pub limit: Option<i64>,
10923 #[serde(
10924 default,
10925 skip_serializing_if = "Option::is_none",
10926 deserialize_with = "double_option"
10927 )]
10928 pub next_marker: Option<Option<String>>,
10929 #[serde(
10930 default,
10931 skip_serializing_if = "Option::is_none",
10932 deserialize_with = "double_option"
10933 )]
10934 pub prev_marker: Option<Option<String>>,
10935 #[serde(default, skip_serializing_if = "Option::is_none")]
10936 pub entries: Option<Vec<DocGenTemplate>>,
10937}
10938
10939#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10940pub struct EnterpriseConfiguration {
10941 #[serde(default, skip_serializing_if = "Option::is_none")]
10942 pub id: Option<String>,
10943 #[serde(default, skip_serializing_if = "Option::is_none")]
10944 pub r#type: Option<EnterpriseConfigurationType>,
10945 #[serde(default, skip_serializing_if = "Option::is_none")]
10946 pub security: Option<EnterpriseConfigurationSecurity2>,
10947 #[serde(default, skip_serializing_if = "Option::is_none")]
10948 pub content_and_sharing: Option<EnterpriseConfigurationContentAndSharing2>,
10949 #[serde(default, skip_serializing_if = "Option::is_none")]
10950 pub user_settings: Option<EnterpriseConfigurationUserSettings2>,
10951 #[serde(default, skip_serializing_if = "Option::is_none")]
10952 pub shield: Option<EnterpriseConfigurationShield2>,
10953}
10954
10955#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10956pub struct EnterpriseConfigurationContentAndSharing {
10957 #[serde(default, skip_serializing_if = "Option::is_none")]
10958 pub enterprise_feature_settings: Option<Vec<EnterpriseFeatureSettingsItem>>,
10959 #[serde(default, skip_serializing_if = "Option::is_none")]
10960 pub sharing_item_type: Option<EnterpriseConfigurationItemString>,
10961 #[serde(default, skip_serializing_if = "Option::is_none")]
10962 pub shared_link_company_definition: Option<EnterpriseConfigurationItemString>,
10963 #[serde(default, skip_serializing_if = "Option::is_none")]
10964 pub shared_link_access: Option<EnterpriseConfigurationItemString>,
10965 #[serde(default, skip_serializing_if = "Option::is_none")]
10966 pub shared_link_default_access: Option<EnterpriseConfigurationItemString>,
10967 #[serde(default, skip_serializing_if = "Option::is_none")]
10968 pub shared_link_default_permissions_selected:
10969 Option<EnterpriseConfigurationContentAndSharingSharedLinkDefaultPermissionsSelected>,
10970 #[serde(default, skip_serializing_if = "Option::is_none")]
10971 pub is_open_custom_urls_disabled: Option<EnterpriseConfigurationItemBoolean>,
10972 #[serde(default, skip_serializing_if = "Option::is_none")]
10973 pub is_custom_domain_hidden_in_shared_link: Option<EnterpriseConfigurationItemBoolean>,
10974 #[serde(default, skip_serializing_if = "Option::is_none")]
10975 pub collaboration_permissions:
10976 Option<EnterpriseConfigurationContentAndSharingCollaborationPermissions>,
10977 #[serde(default, skip_serializing_if = "Option::is_none")]
10978 pub default_collaboration_role: Option<EnterpriseConfigurationItemString>,
10979 #[serde(default, skip_serializing_if = "Option::is_none")]
10980 pub is_invite_privilege_restricted: Option<EnterpriseConfigurationItemBoolean>,
10981 #[serde(default, skip_serializing_if = "Option::is_none")]
10982 pub collaboration_restrictions:
10983 Option<EnterpriseConfigurationContentAndSharingCollaborationRestrictions>,
10984 #[serde(default, skip_serializing_if = "Option::is_none")]
10985 pub is_collaborator_invite_links_disabled: Option<EnterpriseConfigurationItemBoolean>,
10986 #[serde(default, skip_serializing_if = "Option::is_none")]
10987 pub is_invite_group_collaborator_disabled: Option<EnterpriseConfigurationItemBoolean>,
10988 #[serde(default, skip_serializing_if = "Option::is_none")]
10989 pub is_ownership_transfer_restricted: Option<EnterpriseConfigurationItemBoolean>,
10990 #[serde(default, skip_serializing_if = "Option::is_none")]
10991 pub external_collaboration_status:
10992 Option<EnterpriseConfigurationContentAndSharingExternalCollaborationStatus>,
10993 #[serde(default, skip_serializing_if = "Option::is_none")]
10994 pub external_collaboration_allowlist_users:
10995 Option<EnterpriseConfigurationContentAndSharingExternalCollaborationAllowlistUsers>,
10996 #[serde(default, skip_serializing_if = "Option::is_none")]
10997 pub is_watermarking_enterprise_feature_enabled: Option<EnterpriseConfigurationItemBoolean>,
10998 #[serde(default, skip_serializing_if = "Option::is_none")]
10999 pub is_root_content_creation_restricted: Option<EnterpriseConfigurationItemBoolean>,
11000 #[serde(default, skip_serializing_if = "Option::is_none")]
11001 pub is_tag_creation_restricted: Option<EnterpriseConfigurationItemBoolean>,
11002 #[serde(default, skip_serializing_if = "Option::is_none")]
11003 pub tag_creation_restriction: Option<EnterpriseConfigurationItemString>,
11004 #[serde(default, skip_serializing_if = "Option::is_none")]
11005 pub is_email_uploads_enabled: Option<EnterpriseConfigurationItemBoolean>,
11006 #[serde(default, skip_serializing_if = "Option::is_none")]
11007 pub is_custom_settings_enabled: Option<EnterpriseConfigurationItemBoolean>,
11008 #[serde(default, skip_serializing_if = "Option::is_none")]
11009 pub is_forms_login_required: Option<EnterpriseConfigurationItemBoolean>,
11010 #[serde(default, skip_serializing_if = "Option::is_none")]
11011 pub is_forms_branding_default_enabled: Option<EnterpriseConfigurationItemBoolean>,
11012 #[serde(default, skip_serializing_if = "Option::is_none")]
11013 pub is_cc_free_trial_active: Option<EnterpriseConfigurationItemBoolean>,
11014 #[serde(default, skip_serializing_if = "Option::is_none")]
11015 pub is_file_request_editors_allowed: Option<EnterpriseConfigurationItemBoolean>,
11016 #[serde(default, skip_serializing_if = "Option::is_none")]
11017 pub is_file_request_branding_default_enabled: Option<EnterpriseConfigurationItemBoolean>,
11018 #[serde(default, skip_serializing_if = "Option::is_none")]
11019 pub is_file_request_login_required: Option<EnterpriseConfigurationItemBoolean>,
11020 #[serde(default, skip_serializing_if = "Option::is_none")]
11021 pub is_shared_links_expiration_enabled: Option<EnterpriseConfigurationItemBoolean>,
11022 #[serde(default, skip_serializing_if = "Option::is_none")]
11023 pub shared_links_expiration_days: Option<EnterpriseConfigurationItemInteger>,
11024 #[serde(default, skip_serializing_if = "Option::is_none")]
11025 pub is_public_shared_links_expiration_enabled: Option<EnterpriseConfigurationItemBoolean>,
11026 #[serde(default, skip_serializing_if = "Option::is_none")]
11027 pub public_shared_links_expiration_days: Option<EnterpriseConfigurationItemInteger>,
11028 #[serde(default, skip_serializing_if = "Option::is_none")]
11029 pub shared_expiration_target: Option<EnterpriseConfigurationItemString>,
11030 #[serde(default, skip_serializing_if = "Option::is_none")]
11031 pub is_shared_links_expiration_notification_enabled: Option<EnterpriseConfigurationItemBoolean>,
11032 #[serde(default, skip_serializing_if = "Option::is_none")]
11033 pub shared_links_expiration_notification_days: Option<EnterpriseConfigurationItemInteger>,
11034 #[serde(default, skip_serializing_if = "Option::is_none")]
11035 pub is_shared_links_expiration_notification_prevented:
11036 Option<EnterpriseConfigurationItemBoolean>,
11037 #[serde(default, skip_serializing_if = "Option::is_none")]
11038 pub is_auto_delete_enabled: Option<EnterpriseConfigurationItemBoolean>,
11039 #[serde(default, skip_serializing_if = "Option::is_none")]
11040 pub auto_delete_days: Option<EnterpriseConfigurationItemInteger>,
11041 #[serde(default, skip_serializing_if = "Option::is_none")]
11042 pub is_auto_delete_expiration_modification_prevented:
11043 Option<EnterpriseConfigurationItemBoolean>,
11044 #[serde(default, skip_serializing_if = "Option::is_none")]
11045 pub auto_delete_target: Option<EnterpriseConfigurationItemString>,
11046 #[serde(default, skip_serializing_if = "Option::is_none")]
11047 pub is_collaboration_expiration_enabled: Option<EnterpriseConfigurationItemBoolean>,
11048 #[serde(default, skip_serializing_if = "Option::is_none")]
11049 pub collaboration_expiration_days: Option<EnterpriseConfigurationItemInteger>,
11050 #[serde(default, skip_serializing_if = "Option::is_none")]
11051 pub is_collaboration_expiration_modification_prevented:
11052 Option<EnterpriseConfigurationItemBoolean>,
11053 #[serde(default, skip_serializing_if = "Option::is_none")]
11054 pub is_collaboration_expiration_notification_enabled:
11055 Option<EnterpriseConfigurationItemBoolean>,
11056 #[serde(default, skip_serializing_if = "Option::is_none")]
11057 pub collaboration_expiration_target: Option<EnterpriseConfigurationItemString>,
11058 #[serde(default, skip_serializing_if = "Option::is_none")]
11059 pub trash_auto_clear_time: Option<EnterpriseConfigurationItemInteger>,
11060 #[serde(default, skip_serializing_if = "Option::is_none")]
11061 pub permanent_deletion_access: Option<EnterpriseConfigurationItemString>,
11062 #[serde(default, skip_serializing_if = "Option::is_none")]
11063 pub permanent_deletion_allowlist_users:
11064 Option<EnterpriseConfigurationContentAndSharingExternalCollaborationAllowlistUsers>,
11065}
11066
11067#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11068pub struct EnterpriseConfigurationItem {
11069 #[serde(default, skip_serializing_if = "Option::is_none")]
11070 pub is_used: Option<bool>,
11071}
11072
11073#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11074pub struct EnterpriseConfigurationItemBoolean {
11075 #[serde(default, skip_serializing_if = "Option::is_none")]
11076 pub is_used: Option<bool>,
11077 #[serde(
11078 default,
11079 skip_serializing_if = "Option::is_none",
11080 deserialize_with = "double_option"
11081 )]
11082 pub value: Option<Option<bool>>,
11083}
11084
11085#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11086pub struct EnterpriseConfigurationItemInteger {
11087 #[serde(default, skip_serializing_if = "Option::is_none")]
11088 pub is_used: Option<bool>,
11089 #[serde(
11090 default,
11091 skip_serializing_if = "Option::is_none",
11092 deserialize_with = "double_option"
11093 )]
11094 pub value: Option<Option<i64>>,
11095}
11096
11097#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11098pub struct EnterpriseConfigurationItemString {
11099 #[serde(default, skip_serializing_if = "Option::is_none")]
11100 pub is_used: Option<bool>,
11101 #[serde(
11102 default,
11103 skip_serializing_if = "Option::is_none",
11104 deserialize_with = "double_option"
11105 )]
11106 pub value: Option<Option<String>>,
11107}
11108
11109#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11110pub struct EnterpriseConfigurationSecurity {
11111 #[serde(default, skip_serializing_if = "Option::is_none")]
11112 pub is_managed_user_signup_enabled: Option<EnterpriseConfigurationItemBoolean>,
11113 #[serde(default, skip_serializing_if = "Option::is_none")]
11114 pub is_managed_user_signup_notification_enabled: Option<EnterpriseConfigurationItemBoolean>,
11115 #[serde(default, skip_serializing_if = "Option::is_none")]
11116 pub is_managed_user_signup_corporate_email_enabled: Option<EnterpriseConfigurationItemBoolean>,
11117 #[serde(default, skip_serializing_if = "Option::is_none")]
11118 pub is_new_user_notification_daily_digest_enabled: Option<EnterpriseConfigurationItemBoolean>,
11119 #[serde(default, skip_serializing_if = "Option::is_none")]
11120 pub is_managed_user_email_change_disabled: Option<EnterpriseConfigurationItemBoolean>,
11121 #[serde(default, skip_serializing_if = "Option::is_none")]
11122 pub is_multi_factor_auth_required: Option<EnterpriseConfigurationItemBoolean>,
11123 #[serde(default, skip_serializing_if = "Option::is_none")]
11124 pub is_weak_password_prevention_enabled: Option<EnterpriseConfigurationItemBoolean>,
11125 #[serde(default, skip_serializing_if = "Option::is_none")]
11126 pub is_password_leak_detection_enabled: Option<EnterpriseConfigurationItemBoolean>,
11127 #[serde(default, skip_serializing_if = "Option::is_none")]
11128 pub last_password_reset_at: Option<EnterpriseConfigurationSecurityLastPasswordResetAt>,
11129 #[serde(default, skip_serializing_if = "Option::is_none")]
11130 pub is_password_request_notification_enabled: Option<EnterpriseConfigurationItemBoolean>,
11131 #[serde(default, skip_serializing_if = "Option::is_none")]
11132 pub is_password_change_notification_enabled: Option<EnterpriseConfigurationItemBoolean>,
11133 #[serde(default, skip_serializing_if = "Option::is_none")]
11134 pub is_strong_password_for_ext_collab_enabled: Option<EnterpriseConfigurationItemBoolean>,
11135 #[serde(default, skip_serializing_if = "Option::is_none")]
11136 pub is_managed_user_migration_disabled: Option<EnterpriseConfigurationItemBoolean>,
11137 #[serde(default, skip_serializing_if = "Option::is_none")]
11138 pub join_link: Option<EnterpriseConfigurationItemString>,
11139 #[serde(default, skip_serializing_if = "Option::is_none")]
11140 pub join_url: Option<EnterpriseConfigurationItemString>,
11141 #[serde(default, skip_serializing_if = "Option::is_none")]
11142 pub failed_login_attempts_to_trigger_admin_notification:
11143 Option<EnterpriseConfigurationItemInteger>,
11144 #[serde(default, skip_serializing_if = "Option::is_none")]
11145 pub password_min_length: Option<EnterpriseConfigurationItemInteger>,
11146 #[serde(default, skip_serializing_if = "Option::is_none")]
11147 pub password_min_uppercase_characters: Option<EnterpriseConfigurationItemInteger>,
11148 #[serde(default, skip_serializing_if = "Option::is_none")]
11149 pub password_min_numeric_characters: Option<EnterpriseConfigurationItemInteger>,
11150 #[serde(default, skip_serializing_if = "Option::is_none")]
11151 pub password_min_special_characters: Option<EnterpriseConfigurationItemInteger>,
11152 #[serde(default, skip_serializing_if = "Option::is_none")]
11153 pub password_reset_frequency: Option<EnterpriseConfigurationItemString>,
11154 #[serde(default, skip_serializing_if = "Option::is_none")]
11155 pub previous_password_reuse_limit: Option<EnterpriseConfigurationItemString>,
11156 #[serde(default, skip_serializing_if = "Option::is_none")]
11157 pub session_duration: Option<EnterpriseConfigurationItemString>,
11158 #[serde(default, skip_serializing_if = "Option::is_none")]
11159 pub external_collab_multi_factor_auth_settings:
11160 Option<EnterpriseConfigurationSecurityExternalCollabMultiFactorAuthSettings>,
11161 #[serde(default, skip_serializing_if = "Option::is_none")]
11162 pub keysafe: Option<EnterpriseConfigurationSecurityKeysafe>,
11163 #[serde(default, skip_serializing_if = "Option::is_none")]
11164 pub is_custom_session_duration_enabled: Option<EnterpriseConfigurationItemBoolean>,
11165 #[serde(default, skip_serializing_if = "Option::is_none")]
11166 pub custom_session_duration_value: Option<EnterpriseConfigurationItemString>,
11167 #[serde(default, skip_serializing_if = "Option::is_none")]
11168 pub custom_session_duration_groups:
11169 Option<EnterpriseConfigurationSecurityCustomSessionDurationGroups>,
11170 #[serde(default, skip_serializing_if = "Option::is_none")]
11171 pub multi_factor_auth_type: Option<EnterpriseConfigurationItemString>,
11172 #[serde(default, skip_serializing_if = "Option::is_none")]
11173 pub enforced_mfa_frequency: Option<EnterpriseConfigurationSecurityEnforcedMfaFrequency>,
11174}
11175
11176#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11177pub struct EnterpriseConfigurationShield {
11178 #[serde(default, skip_serializing_if = "Option::is_none")]
11179 pub shield_rules: Option<Vec<ShieldRuleItem>>,
11180}
11181
11182#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11183pub struct EnterpriseConfigurationUserSettings {
11184 #[serde(default, skip_serializing_if = "Option::is_none")]
11185 pub enterprise_feature_settings: Option<Vec<EnterpriseFeatureSettingsItem>>,
11186 #[serde(default, skip_serializing_if = "Option::is_none")]
11187 pub user_invites_expiration_time_frame: Option<EnterpriseConfigurationItemString>,
11188 #[serde(default, skip_serializing_if = "Option::is_none")]
11189 pub is_username_change_restricted: Option<EnterpriseConfigurationItemBoolean>,
11190 #[serde(default, skip_serializing_if = "Option::is_none")]
11191 pub is_box_sync_restricted_for_new_users: Option<EnterpriseConfigurationItemBoolean>,
11192 #[serde(default, skip_serializing_if = "Option::is_none")]
11193 pub is_view_all_users_enabled_for_new_users: Option<EnterpriseConfigurationItemBoolean>,
11194 #[serde(default, skip_serializing_if = "Option::is_none")]
11195 pub is_device_limit_exemption_enabled_for_new_users: Option<EnterpriseConfigurationItemBoolean>,
11196 #[serde(default, skip_serializing_if = "Option::is_none")]
11197 pub is_external_collaboration_restricted_for_new_users:
11198 Option<EnterpriseConfigurationItemBoolean>,
11199 #[serde(default, skip_serializing_if = "Option::is_none")]
11200 pub is_unlimited_storage_enabled_for_new_users: Option<EnterpriseConfigurationItemBoolean>,
11201 #[serde(default, skip_serializing_if = "Option::is_none")]
11202 pub new_user_default_storage_limit: Option<EnterpriseConfigurationItemInteger>,
11203 #[serde(default, skip_serializing_if = "Option::is_none")]
11204 pub new_user_default_timezone: Option<EnterpriseConfigurationItemString>,
11205 #[serde(default, skip_serializing_if = "Option::is_none")]
11206 pub new_user_default_language: Option<EnterpriseConfigurationItemString>,
11207 #[serde(default, skip_serializing_if = "Option::is_none")]
11208 pub is_enterprise_sso_required: Option<EnterpriseConfigurationItemBoolean>,
11209 #[serde(default, skip_serializing_if = "Option::is_none")]
11210 pub is_enterprise_sso_in_testing: Option<EnterpriseConfigurationItemBoolean>,
11211 #[serde(default, skip_serializing_if = "Option::is_none")]
11212 pub is_sso_auto_add_groups_enabled: Option<EnterpriseConfigurationItemBoolean>,
11213 #[serde(default, skip_serializing_if = "Option::is_none")]
11214 pub is_sso_auto_add_user_to_groups_enabled: Option<EnterpriseConfigurationItemBoolean>,
11215 #[serde(default, skip_serializing_if = "Option::is_none")]
11216 pub is_sso_auto_remove_user_from_groups_enabled: Option<EnterpriseConfigurationItemBoolean>,
11217 #[serde(default, skip_serializing_if = "Option::is_none")]
11218 pub user_tracking_codes: Option<EnterpriseConfigurationUserSettingsUserTrackingCodes>,
11219 #[serde(default, skip_serializing_if = "Option::is_none")]
11220 pub number_of_user_tracking_codes_remaining: Option<EnterpriseConfigurationItemInteger>,
11221 #[serde(default, skip_serializing_if = "Option::is_none")]
11222 pub is_instant_login_restricted: Option<EnterpriseConfigurationItemBoolean>,
11223}
11224
11225#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11226pub struct EnterpriseFeatureSetting {
11227 #[serde(
11228 default,
11229 skip_serializing_if = "Option::is_none",
11230 deserialize_with = "double_option"
11231 )]
11232 pub id: Option<Option<String>>,
11233 #[serde(default, skip_serializing_if = "Option::is_none")]
11234 pub feature: Option<EnterpriseFeatureSettingFeature>,
11235 #[serde(
11236 default,
11237 skip_serializing_if = "Option::is_none",
11238 deserialize_with = "double_option"
11239 )]
11240 pub state: Option<Option<String>>,
11241 #[serde(
11242 default,
11243 skip_serializing_if = "Option::is_none",
11244 deserialize_with = "double_option"
11245 )]
11246 pub can_configure: Option<Option<bool>>,
11247 #[serde(
11248 default,
11249 skip_serializing_if = "Option::is_none",
11250 deserialize_with = "double_option"
11251 )]
11252 pub is_configured: Option<Option<bool>>,
11253 #[serde(
11254 default,
11255 skip_serializing_if = "Option::is_none",
11256 deserialize_with = "double_option"
11257 )]
11258 pub allowlist: Option<Option<Vec<UserOrGroupReference>>>,
11259 #[serde(
11260 default,
11261 skip_serializing_if = "Option::is_none",
11262 deserialize_with = "double_option"
11263 )]
11264 pub denylist: Option<Option<Vec<UserOrGroupReference>>>,
11265}
11266
11267#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11268pub struct EnterpriseFeatureSettingsItem {
11269 #[serde(default, skip_serializing_if = "Option::is_none")]
11270 pub is_used: Option<bool>,
11271 #[serde(default, skip_serializing_if = "Option::is_none")]
11272 pub value: Option<EnterpriseFeatureSetting>,
11273}
11274
11275#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11276pub struct EnterpriseReference {
11277 #[serde(default, skip_serializing_if = "Option::is_none")]
11278 pub id: Option<String>,
11279 #[serde(default, skip_serializing_if = "Option::is_none")]
11280 pub r#type: Option<EnterpriseReferenceType>,
11281}
11282
11283#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11284pub struct ExternalCollabSecuritySettings {
11285 #[serde(default, skip_serializing_if = "Option::is_none")]
11286 pub denylist_domains: Option<Vec<String>>,
11287 #[serde(default, skip_serializing_if = "Option::is_none")]
11288 pub denylist_emails: Option<Vec<String>>,
11289 #[serde(default, skip_serializing_if = "Option::is_none")]
11290 pub allowlist_domains: Option<Vec<String>>,
11291 #[serde(default, skip_serializing_if = "Option::is_none")]
11292 pub allowlist_emails: Option<Vec<String>>,
11293 #[serde(
11294 default,
11295 skip_serializing_if = "Option::is_none",
11296 deserialize_with = "double_option"
11297 )]
11298 pub state: Option<Option<String>>,
11299 #[serde(
11300 default,
11301 skip_serializing_if = "Option::is_none",
11302 deserialize_with = "double_option"
11303 )]
11304 pub scheduled_status: Option<Option<String>>,
11305 #[serde(
11306 default,
11307 skip_serializing_if = "Option::is_none",
11308 deserialize_with = "double_option"
11309 )]
11310 pub scheduled_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
11311 #[serde(
11312 default,
11313 skip_serializing_if = "Option::is_none",
11314 deserialize_with = "double_option"
11315 )]
11316 pub factor_type_settings: Option<Option<String>>,
11317}
11318
11319#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11320pub struct ExternalUserDeletionResult {
11321 pub user_id: String,
11322 pub status: i64,
11323 #[serde(default, skip_serializing_if = "Option::is_none")]
11324 pub detail: Option<String>,
11325}
11326
11327#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11328pub struct ExternalUsersSubmitDeleteJobRequest {
11329 pub external_users: Vec<UserReference>,
11330}
11331
11332#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11333pub struct ExternalUsersSubmitDeleteJobResponse {
11334 pub entries: Vec<ExternalUserDeletionResult>,
11335}
11336
11337#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11338pub struct FileReference {
11339 pub r#type: FileReferenceType,
11340 pub id: String,
11341}
11342
11343#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11344pub struct Hub {
11345 pub id: String,
11346 pub r#type: HubType,
11347 #[serde(default, skip_serializing_if = "Option::is_none")]
11348 pub title: Option<String>,
11349 #[serde(default, skip_serializing_if = "Option::is_none")]
11350 pub description: Option<String>,
11351 #[serde(default, skip_serializing_if = "Option::is_none")]
11352 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
11353 #[serde(default, skip_serializing_if = "Option::is_none")]
11354 pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
11355 #[serde(default, skip_serializing_if = "Option::is_none")]
11356 pub created_by: Option<UserMini>,
11357 #[serde(default, skip_serializing_if = "Option::is_none")]
11358 pub updated_by: Option<UserMini>,
11359 #[serde(default, skip_serializing_if = "Option::is_none")]
11360 pub view_count: Option<i64>,
11361 #[serde(default, skip_serializing_if = "Option::is_none")]
11362 pub is_ai_enabled: Option<bool>,
11363 #[serde(default, skip_serializing_if = "Option::is_none")]
11364 pub is_collaboration_restricted_to_enterprise: Option<bool>,
11365 #[serde(default, skip_serializing_if = "Option::is_none")]
11366 pub can_non_owners_invite: Option<bool>,
11367 #[serde(default, skip_serializing_if = "Option::is_none")]
11368 pub can_shared_link_be_created: Option<bool>,
11369 #[serde(default, skip_serializing_if = "Option::is_none")]
11370 pub can_public_shared_link_be_created: Option<bool>,
11371 #[serde(default, skip_serializing_if = "Option::is_none")]
11372 pub copy_hub_access: Option<HubCopyHubAccess>,
11373}
11374
11375#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11376pub struct HubBase {
11377 pub id: String,
11378 pub r#type: HubType,
11379}
11380
11381#[derive(Clone, Debug, PartialEq)]
11382pub enum HubAccessGrantee {
11383 User(HubCollaborationUser),
11384 Group(GroupMini),
11385 Unknown(serde_json::Value),
11387}
11388
11389impl Default for HubAccessGrantee {
11390 fn default() -> Self {
11391 Self::Unknown(Default::default())
11392 }
11393}
11394
11395impl serde::Serialize for HubAccessGrantee {
11396 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
11397 match self {
11398 Self::User(inner) => inner.serialize(serializer),
11399 Self::Group(inner) => inner.serialize(serializer),
11400 Self::Unknown(inner) => inner.serialize(serializer),
11401 }
11402 }
11403}
11404
11405impl<'de> serde::Deserialize<'de> for HubAccessGrantee {
11406 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
11407 let value = serde_json::Value::deserialize(deserializer)?;
11408 let tag = value
11409 .get("type")
11410 .and_then(serde_json::Value::as_str)
11411 .map(str::to_owned);
11412 match tag.as_deref() {
11413 Some("user") => Ok(Self::User(
11414 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11415 )),
11416 Some("group") => Ok(Self::Group(
11417 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11418 )),
11419 _ => Ok(Self::Unknown(value)),
11420 }
11421 }
11422}
11423
11424#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11425pub struct HubCalloutBoxTextBlock {
11426 pub id: String,
11427 #[serde(
11428 default,
11429 skip_serializing_if = "Option::is_none",
11430 deserialize_with = "double_option"
11431 )]
11432 pub parent_id: Option<Option<String>>,
11433 pub r#type: HubCalloutBoxTextBlockType,
11434 pub fragment: String,
11435}
11436
11437#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11438pub struct HubCollaboration {
11439 pub id: String,
11440 pub r#type: HubCollaborationType,
11441 #[serde(default, skip_serializing_if = "Option::is_none")]
11442 pub hub: Option<HubBase>,
11443 #[serde(default, skip_serializing_if = "Option::is_none")]
11444 pub accessible_by: Option<HubAccessGrantee>,
11445 #[serde(default, skip_serializing_if = "Option::is_none")]
11446 pub role: Option<String>,
11447 #[serde(default, skip_serializing_if = "Option::is_none")]
11448 pub status: Option<HubCollaborationStatus>,
11449 #[serde(default, skip_serializing_if = "Option::is_none")]
11450 pub acceptance_requirements_status: Option<HubCollaborationAcceptanceRequirementsStatus>,
11451}
11452
11453#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11454pub struct HubCollaborationCreateRequest {
11455 pub hub: HubCollaborationCreateRequestHub,
11456 pub accessible_by: HubCollaborationCreateRequestAccessibleBy,
11457 pub role: String,
11458}
11459
11460#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11461pub struct HubCollaborations {
11462 #[serde(default, skip_serializing_if = "Option::is_none")]
11463 pub entries: Option<Vec<HubCollaboration>>,
11464 #[serde(default, skip_serializing_if = "Option::is_none")]
11465 pub limit: Option<i64>,
11466 #[serde(
11467 default,
11468 skip_serializing_if = "Option::is_none",
11469 deserialize_with = "double_option"
11470 )]
11471 pub next_marker: Option<Option<String>>,
11472}
11473
11474#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11475pub struct HubCollaborationUpdateRequest {
11476 #[serde(default, skip_serializing_if = "Option::is_none")]
11477 pub role: Option<String>,
11478}
11479
11480#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11481pub struct HubCollaborationUser {
11482 pub id: String,
11483 pub r#type: HubCollaborationUserType,
11484 #[serde(default, skip_serializing_if = "Option::is_none")]
11485 pub name: Option<String>,
11486 #[serde(default, skip_serializing_if = "Option::is_none")]
11487 pub login: Option<String>,
11488}
11489
11490#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11491pub struct HubCopyRequest {
11492 #[serde(default, skip_serializing_if = "Option::is_none")]
11493 pub title: Option<String>,
11494 #[serde(default, skip_serializing_if = "Option::is_none")]
11495 pub description: Option<String>,
11496 #[serde(default, skip_serializing_if = "Option::is_none")]
11497 pub include_items: Option<bool>,
11498}
11499
11500#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11501pub struct HubCreateRequest {
11502 pub title: String,
11503 #[serde(default, skip_serializing_if = "Option::is_none")]
11504 pub description: Option<String>,
11505}
11506
11507#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11508pub struct HubDividerBlock {
11509 pub id: String,
11510 #[serde(
11511 default,
11512 skip_serializing_if = "Option::is_none",
11513 deserialize_with = "double_option"
11514 )]
11515 pub parent_id: Option<Option<String>>,
11516 pub r#type: HubDividerBlockType,
11517}
11518
11519#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11520pub struct HubDocumentBlock {
11521 pub id: String,
11522 #[serde(
11523 default,
11524 skip_serializing_if = "Option::is_none",
11525 deserialize_with = "double_option"
11526 )]
11527 pub parent_id: Option<Option<String>>,
11528}
11529
11530#[derive(Clone, Debug, PartialEq)]
11531pub enum HubDocumentBlockEntry {
11532 Paragraph(HubParagraphTextBlock),
11533 SectionTitle(HubSectionTitleTextBlock),
11534 CalloutBox(HubCalloutBoxTextBlock),
11535 ItemList(HubItemListBlock),
11536 Divider(HubDividerBlock),
11537 Unknown(serde_json::Value),
11539}
11540
11541impl Default for HubDocumentBlockEntry {
11542 fn default() -> Self {
11543 Self::Unknown(Default::default())
11544 }
11545}
11546
11547impl serde::Serialize for HubDocumentBlockEntry {
11548 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
11549 match self {
11550 Self::Paragraph(inner) => inner.serialize(serializer),
11551 Self::SectionTitle(inner) => inner.serialize(serializer),
11552 Self::CalloutBox(inner) => inner.serialize(serializer),
11553 Self::ItemList(inner) => inner.serialize(serializer),
11554 Self::Divider(inner) => inner.serialize(serializer),
11555 Self::Unknown(inner) => inner.serialize(serializer),
11556 }
11557 }
11558}
11559
11560impl<'de> serde::Deserialize<'de> for HubDocumentBlockEntry {
11561 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
11562 let value = serde_json::Value::deserialize(deserializer)?;
11563 let tag = value
11564 .get("type")
11565 .and_then(serde_json::Value::as_str)
11566 .map(str::to_owned);
11567 match tag.as_deref() {
11568 Some("paragraph") => Ok(Self::Paragraph(
11569 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11570 )),
11571 Some("section_title") => Ok(Self::SectionTitle(
11572 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11573 )),
11574 Some("callout_box") => Ok(Self::CalloutBox(
11575 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11576 )),
11577 Some("item_list") => Ok(Self::ItemList(
11578 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11579 )),
11580 Some("divider") => Ok(Self::Divider(
11581 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11582 )),
11583 _ => Ok(Self::Unknown(value)),
11584 }
11585 }
11586}
11587
11588#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11589pub struct HubDocumentBlocks {
11590 pub entries: Vec<HubDocumentBlockEntry>,
11591 pub r#type: HubDocumentBlocksType,
11592 #[serde(default, skip_serializing_if = "Option::is_none")]
11593 pub limit: Option<i64>,
11594 #[serde(
11595 default,
11596 skip_serializing_if = "Option::is_none",
11597 deserialize_with = "double_option"
11598 )]
11599 pub next_marker: Option<Option<String>>,
11600}
11601
11602#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11603pub struct HubDocumentPage {
11604 pub id: String,
11605 pub r#type: String,
11606 #[serde(
11607 default,
11608 skip_serializing_if = "Option::is_none",
11609 deserialize_with = "double_option"
11610 )]
11611 pub parent_id: Option<Option<String>>,
11612 pub title_fragment: String,
11613}
11614
11615#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11616pub struct HubDocumentPages {
11617 pub entries: Vec<HubDocumentPage>,
11618 pub r#type: HubDocumentPagesType,
11619 #[serde(default, skip_serializing_if = "Option::is_none")]
11620 pub limit: Option<i64>,
11621 #[serde(
11622 default,
11623 skip_serializing_if = "Option::is_none",
11624 deserialize_with = "double_option"
11625 )]
11626 pub next_marker: Option<Option<String>>,
11627}
11628
11629#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11630pub struct HubItem {
11631 pub id: String,
11632 pub r#type: HubItemType,
11633 pub name: String,
11634}
11635
11636#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11637pub struct HubItemListBlock {
11638 pub id: String,
11639 #[serde(
11640 default,
11641 skip_serializing_if = "Option::is_none",
11642 deserialize_with = "double_option"
11643 )]
11644 pub parent_id: Option<Option<String>>,
11645 pub r#type: HubItemListBlockType,
11646}
11647
11648#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11649pub struct HubItemOperation {
11650 pub action: HubItemOperationAction,
11651 pub item: HubItemReference,
11652 #[serde(default, skip_serializing_if = "Option::is_none")]
11653 pub parent_id: Option<String>,
11654}
11655
11656#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11657pub struct HubItemOperationResult {
11658 #[serde(default, skip_serializing_if = "Option::is_none")]
11659 pub action: Option<String>,
11660 #[serde(default, skip_serializing_if = "Option::is_none")]
11661 pub item: Option<HubItemReference>,
11662 #[serde(default, skip_serializing_if = "Option::is_none")]
11663 pub parent_id: Option<String>,
11664 #[serde(default, skip_serializing_if = "Option::is_none")]
11665 pub status: Option<i64>,
11666 #[serde(default, skip_serializing_if = "Option::is_none")]
11667 pub error: Option<String>,
11668}
11669
11670#[derive(Clone, Debug, PartialEq)]
11671pub enum HubItemReference {
11672 File(FileReference),
11673 Folder(FolderReference),
11674 WebLink(WeblinkReference),
11675 Unknown(serde_json::Value),
11677}
11678
11679impl Default for HubItemReference {
11680 fn default() -> Self {
11681 Self::Unknown(Default::default())
11682 }
11683}
11684
11685impl serde::Serialize for HubItemReference {
11686 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
11687 match self {
11688 Self::File(inner) => inner.serialize(serializer),
11689 Self::Folder(inner) => inner.serialize(serializer),
11690 Self::WebLink(inner) => inner.serialize(serializer),
11691 Self::Unknown(inner) => inner.serialize(serializer),
11692 }
11693 }
11694}
11695
11696impl<'de> serde::Deserialize<'de> for HubItemReference {
11697 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
11698 let value = serde_json::Value::deserialize(deserializer)?;
11699 let tag = value
11700 .get("type")
11701 .and_then(serde_json::Value::as_str)
11702 .map(str::to_owned);
11703 match tag.as_deref() {
11704 Some("file") => Ok(Self::File(
11705 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11706 )),
11707 Some("folder") => Ok(Self::Folder(
11708 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11709 )),
11710 Some("web_link") => Ok(Self::WebLink(
11711 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11712 )),
11713 _ => Ok(Self::Unknown(value)),
11714 }
11715 }
11716}
11717
11718#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11719pub struct HubItems {
11720 #[serde(default, skip_serializing_if = "Option::is_none")]
11721 pub entries: Option<Vec<HubItem>>,
11722 #[serde(default, skip_serializing_if = "Option::is_none")]
11723 pub limit: Option<i64>,
11724 #[serde(
11725 default,
11726 skip_serializing_if = "Option::is_none",
11727 deserialize_with = "double_option"
11728 )]
11729 pub next_marker: Option<Option<String>>,
11730}
11731
11732#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11733pub struct HubItemsManageRequest {
11734 #[serde(default, skip_serializing_if = "Option::is_none")]
11735 pub operations: Option<Vec<HubItemOperation>>,
11736}
11737
11738#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11739pub struct HubItemsManageResponse {
11740 pub operations: Vec<HubItemOperationResult>,
11741}
11742
11743#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11744pub struct HubParagraphTextBlock {
11745 pub id: String,
11746 #[serde(
11747 default,
11748 skip_serializing_if = "Option::is_none",
11749 deserialize_with = "double_option"
11750 )]
11751 pub parent_id: Option<Option<String>>,
11752 pub r#type: HubParagraphTextBlockType,
11753 pub fragment: String,
11754}
11755
11756#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11757pub struct Hubs {
11758 #[serde(default, skip_serializing_if = "Option::is_none")]
11759 pub entries: Option<Vec<Hub>>,
11760 #[serde(default, skip_serializing_if = "Option::is_none")]
11761 pub limit: Option<i64>,
11762 #[serde(
11763 default,
11764 skip_serializing_if = "Option::is_none",
11765 deserialize_with = "double_option"
11766 )]
11767 pub next_marker: Option<Option<String>>,
11768}
11769
11770#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11771pub struct HubSectionTitleTextBlock {
11772 pub id: String,
11773 #[serde(
11774 default,
11775 skip_serializing_if = "Option::is_none",
11776 deserialize_with = "double_option"
11777 )]
11778 pub parent_id: Option<Option<String>>,
11779 pub r#type: HubSectionTitleTextBlockType,
11780 pub fragment: String,
11781}
11782
11783#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11784pub struct HubUpdateRequest {
11785 #[serde(default, skip_serializing_if = "Option::is_none")]
11786 pub title: Option<String>,
11787 #[serde(default, skip_serializing_if = "Option::is_none")]
11788 pub description: Option<String>,
11789 #[serde(default, skip_serializing_if = "Option::is_none")]
11790 pub is_ai_enabled: Option<bool>,
11791 #[serde(default, skip_serializing_if = "Option::is_none")]
11792 pub is_collaboration_restricted_to_enterprise: Option<bool>,
11793 #[serde(default, skip_serializing_if = "Option::is_none")]
11794 pub can_non_owners_invite: Option<bool>,
11795 #[serde(default, skip_serializing_if = "Option::is_none")]
11796 pub can_shared_link_be_created: Option<bool>,
11797 #[serde(default, skip_serializing_if = "Option::is_none")]
11798 pub can_public_shared_link_be_created: Option<bool>,
11799 #[serde(default, skip_serializing_if = "Option::is_none")]
11800 pub copy_hub_access: Option<HubCopyHubAccess>,
11801}
11802
11803#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11804pub struct KeysafeSettings {
11805 #[serde(default, skip_serializing_if = "Option::is_none")]
11806 pub keysafe_enabled: Option<bool>,
11807 #[serde(
11808 default,
11809 skip_serializing_if = "Option::is_none",
11810 deserialize_with = "double_option"
11811 )]
11812 pub cloud_provider: Option<Option<String>>,
11813 #[serde(
11814 default,
11815 skip_serializing_if = "Option::is_none",
11816 deserialize_with = "double_option"
11817 )]
11818 pub key_id: Option<Option<String>>,
11819 #[serde(
11820 default,
11821 skip_serializing_if = "Option::is_none",
11822 deserialize_with = "double_option"
11823 )]
11824 pub account_id: Option<Option<String>>,
11825 #[serde(
11826 default,
11827 skip_serializing_if = "Option::is_none",
11828 deserialize_with = "double_option"
11829 )]
11830 pub location_id: Option<Option<String>>,
11831 #[serde(
11832 default,
11833 skip_serializing_if = "Option::is_none",
11834 deserialize_with = "double_option"
11835 )]
11836 pub project_id: Option<Option<String>>,
11837 #[serde(
11838 default,
11839 skip_serializing_if = "Option::is_none",
11840 deserialize_with = "double_option"
11841 )]
11842 pub keyring_id: Option<Option<String>>,
11843}
11844
11845#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11846pub struct ListUser {
11847 #[serde(
11848 default,
11849 skip_serializing_if = "Option::is_none",
11850 deserialize_with = "double_option"
11851 )]
11852 pub id: Option<Option<i64>>,
11853 #[serde(
11854 default,
11855 skip_serializing_if = "Option::is_none",
11856 deserialize_with = "double_option"
11857 )]
11858 pub name: Option<Option<String>>,
11859 #[serde(
11860 default,
11861 skip_serializing_if = "Option::is_none",
11862 deserialize_with = "double_option"
11863 )]
11864 pub email: Option<Option<String>>,
11865}
11866
11867#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11868pub struct ShieldList {
11869 pub id: String,
11870 pub r#type: String,
11871 pub name: String,
11872 pub enterprise: EnterpriseReference,
11873 #[serde(default, skip_serializing_if = "Option::is_none")]
11874 pub description: Option<String>,
11875 pub created_at: chrono::DateTime<chrono::Utc>,
11876 pub updated_at: chrono::DateTime<chrono::Utc>,
11877 pub content: ShieldListContent,
11878}
11879
11880#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11881pub struct ShieldListMini {
11882 pub id: String,
11883 pub r#type: ShieldListMiniType,
11884 pub name: String,
11885 pub content: ShieldListMiniContent,
11886}
11887
11888#[derive(Clone, Debug, PartialEq)]
11889pub enum ShieldListContent {
11890 Country(ShieldListContentCountry),
11891 Domain(ShieldListContentDomain),
11892 Email(ShieldListContentEmail),
11893 Ip(ShieldListContentIp),
11894 Integration(ShieldListContentIntegration),
11895 Unknown(serde_json::Value),
11897}
11898
11899impl Default for ShieldListContent {
11900 fn default() -> Self {
11901 Self::Unknown(Default::default())
11902 }
11903}
11904
11905impl serde::Serialize for ShieldListContent {
11906 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
11907 match self {
11908 Self::Country(inner) => inner.serialize(serializer),
11909 Self::Domain(inner) => inner.serialize(serializer),
11910 Self::Email(inner) => inner.serialize(serializer),
11911 Self::Ip(inner) => inner.serialize(serializer),
11912 Self::Integration(inner) => inner.serialize(serializer),
11913 Self::Unknown(inner) => inner.serialize(serializer),
11914 }
11915 }
11916}
11917
11918impl<'de> serde::Deserialize<'de> for ShieldListContent {
11919 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
11920 let value = serde_json::Value::deserialize(deserializer)?;
11921 let tag = value
11922 .get("type")
11923 .and_then(serde_json::Value::as_str)
11924 .map(str::to_owned);
11925 match tag.as_deref() {
11926 Some("country") => Ok(Self::Country(
11927 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11928 )),
11929 Some("domain") => Ok(Self::Domain(
11930 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11931 )),
11932 Some("email") => Ok(Self::Email(
11933 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11934 )),
11935 Some("ip") => Ok(Self::Ip(
11936 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11937 )),
11938 Some("integration") => Ok(Self::Integration(
11939 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
11940 )),
11941 _ => Ok(Self::Unknown(value)),
11942 }
11943 }
11944}
11945
11946#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11947pub struct ShieldListContentCountry {
11948 pub r#type: ShieldListContentCountryType,
11949 pub country_codes: Vec<String>,
11950}
11951
11952#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11953pub struct ShieldListContentDomain {
11954 pub r#type: ShieldListContentDomainType,
11955 pub domains: Vec<String>,
11956}
11957
11958#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11959pub struct ShieldListContentEmail {
11960 pub r#type: ShieldListContentEmailType,
11961 pub email_addresses: Vec<String>,
11962}
11963
11964#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11965pub struct ShieldListContentIntegration {
11966 pub r#type: ShieldListContentIntegrationType,
11967 pub integrations: Vec<ShieldListContentIntegrationIntegrations>,
11968}
11969
11970#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
11971pub struct ShieldListContentIp {
11972 pub r#type: ShieldListContentIpType,
11973 pub ip_addresses: Vec<String>,
11974}
11975
11976#[derive(Clone, Debug, PartialEq)]
11977pub enum ShieldListContentRequest {
11978 Country(ShieldListContentCountry),
11979 Domain(ShieldListContentDomain),
11980 Email(ShieldListContentEmail),
11981 Ip(ShieldListContentIp),
11982 Unknown(serde_json::Value),
11984}
11985
11986impl Default for ShieldListContentRequest {
11987 fn default() -> Self {
11988 Self::Unknown(Default::default())
11989 }
11990}
11991
11992impl serde::Serialize for ShieldListContentRequest {
11993 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
11994 match self {
11995 Self::Country(inner) => inner.serialize(serializer),
11996 Self::Domain(inner) => inner.serialize(serializer),
11997 Self::Email(inner) => inner.serialize(serializer),
11998 Self::Ip(inner) => inner.serialize(serializer),
11999 Self::Unknown(inner) => inner.serialize(serializer),
12000 }
12001 }
12002}
12003
12004impl<'de> serde::Deserialize<'de> for ShieldListContentRequest {
12005 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
12006 let value = serde_json::Value::deserialize(deserializer)?;
12007 let tag = value
12008 .get("type")
12009 .and_then(serde_json::Value::as_str)
12010 .map(str::to_owned);
12011 match tag.as_deref() {
12012 Some("country") => Ok(Self::Country(
12013 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
12014 )),
12015 Some("domain") => Ok(Self::Domain(
12016 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
12017 )),
12018 Some("email") => Ok(Self::Email(
12019 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
12020 )),
12021 Some("ip") => Ok(Self::Ip(
12022 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
12023 )),
12024 _ => Ok(Self::Unknown(value)),
12025 }
12026 }
12027}
12028
12029#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12030pub struct ShieldLists {
12031 #[serde(default, skip_serializing_if = "Option::is_none")]
12032 pub entries: Option<Vec<ShieldListMini>>,
12033}
12034
12035#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12036pub struct ShieldListsCreate {
12037 pub name: String,
12038 #[serde(default, skip_serializing_if = "Option::is_none")]
12039 pub description: Option<String>,
12040 pub content: ShieldListContentRequest,
12041}
12042
12043#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12044pub struct ShieldListsUpdate {
12045 pub name: String,
12046 #[serde(default, skip_serializing_if = "Option::is_none")]
12047 pub description: Option<String>,
12048 pub content: ShieldListContentRequest,
12049}
12050
12051#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12052pub struct ShieldRuleItem {
12053 #[serde(default, skip_serializing_if = "Option::is_none")]
12054 pub id: Option<String>,
12055 #[serde(default, skip_serializing_if = "Option::is_none")]
12056 pub r#type: Option<ShieldRuleItemType>,
12057 #[serde(default, skip_serializing_if = "Option::is_none")]
12058 pub rule_category: Option<String>,
12059 #[serde(default, skip_serializing_if = "Option::is_none")]
12060 pub name: Option<String>,
12061 #[serde(default, skip_serializing_if = "Option::is_none")]
12062 pub description: Option<String>,
12063 #[serde(default, skip_serializing_if = "Option::is_none")]
12064 pub priority: Option<ShieldRuleItemPriority>,
12065 #[serde(default, skip_serializing_if = "Option::is_none")]
12066 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
12067 #[serde(default, skip_serializing_if = "Option::is_none")]
12068 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
12069}
12070
12071#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12072pub struct UserOrGroupReference {
12073 #[serde(default, skip_serializing_if = "Option::is_none")]
12074 pub r#type: Option<UserOrGroupReferenceType>,
12075 #[serde(default, skip_serializing_if = "Option::is_none")]
12076 pub id: Option<String>,
12077}
12078
12079#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12080pub struct UserReference {
12081 pub r#type: HubCollaborationUserType,
12082 pub id: String,
12083}
12084
12085#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12086pub struct UserTrackingCode {
12087 #[serde(
12088 default,
12089 skip_serializing_if = "Option::is_none",
12090 deserialize_with = "double_option"
12091 )]
12092 pub id: Option<Option<i64>>,
12093 #[serde(
12094 default,
12095 skip_serializing_if = "Option::is_none",
12096 deserialize_with = "double_option"
12097 )]
12098 pub name: Option<Option<String>>,
12099}
12100
12101#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12102pub struct WeblinkReference {
12103 pub r#type: WeblinkReferenceType,
12104 pub id: String,
12105}
12106
12107#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12108#[serde(transparent)]
12109pub struct ArchiveType(pub String);
12110
12111impl ArchiveType {
12112 pub const ARCHIVE: &'static str = "archive";
12113}
12114
12115#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12116pub struct ArchiveOwnedBy {
12117 pub id: String,
12118 pub r#type: String,
12119}
12120
12121#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12122#[serde(transparent)]
12123pub struct DocGenBatchBaseType(pub String);
12124
12125impl DocGenBatchBaseType {
12126 pub const DOCGEN_BATCH: &'static str = "docgen_batch";
12127}
12128
12129#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12130#[serde(transparent)]
12131pub struct DestinationFolderType(pub String);
12132
12133impl DestinationFolderType {
12134 pub const FOLDER: &'static str = "folder";
12135}
12136
12137#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12138pub struct DocGenBatchCreateRequestDestinationFolder {
12139 pub r#type: DestinationFolderType,
12140 pub id: String,
12141}
12142
12143#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12144#[serde(transparent)]
12145pub struct DocGenJobType(pub String);
12146
12147impl DocGenJobType {
12148 pub const DOCGEN_JOB: &'static str = "docgen_job";
12149}
12150
12151#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12152#[serde(transparent)]
12153pub struct DocGenJobOutputFile(pub serde_json::Value);
12154
12155#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12156#[serde(transparent)]
12157pub struct DocGenJobOutputFileVersion(pub serde_json::Value);
12158
12159#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12160#[serde(transparent)]
12161pub struct DocGenJobStatus(pub String);
12162
12163impl DocGenJobStatus {
12164 pub const SUBMITTED: &'static str = "submitted";
12165 pub const COMPLETED: &'static str = "completed";
12166 pub const FAILED: &'static str = "failed";
12167 pub const COMPLETED_WITH_ERROR: &'static str = "completed_with_error";
12168 pub const PENDING: &'static str = "pending";
12169}
12170
12171#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12172pub struct DocGenJobFailures {
12173 pub errors: Vec<String>,
12174 pub warnings: Vec<String>,
12175}
12176
12177#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12178#[serde(transparent)]
12179pub struct DocGenTagTagType(pub String);
12180
12181impl DocGenTagTagType {
12182 pub const TEXT: &'static str = "text";
12183 pub const ARITHMETIC: &'static str = "arithmetic";
12184 pub const CONDITIONAL: &'static str = "conditional";
12185 pub const FOR_LOOP: &'static str = "for-loop";
12186 pub const TABLE_LOOP: &'static str = "table-loop";
12187 pub const IMAGE: &'static str = "image";
12188}
12189
12190#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12191#[serde(transparent)]
12192pub struct EnterpriseConfigurationType(pub String);
12193
12194impl EnterpriseConfigurationType {
12195 pub const ENTERPRISE_CONFIGURATION: &'static str = "enterprise_configuration";
12196}
12197
12198#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12199#[serde(transparent)]
12200pub struct EnterpriseConfigurationSecurity2(pub serde_json::Value);
12201
12202#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12203#[serde(transparent)]
12204pub struct EnterpriseConfigurationContentAndSharing2(pub serde_json::Value);
12205
12206#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12207#[serde(transparent)]
12208pub struct EnterpriseConfigurationUserSettings2(pub serde_json::Value);
12209
12210#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12211#[serde(transparent)]
12212pub struct EnterpriseConfigurationShield2(pub serde_json::Value);
12213
12214#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12215pub struct EnterpriseConfigurationContentAndSharingSharedLinkDefaultPermissionsSelected {
12216 #[serde(default, skip_serializing_if = "Option::is_none")]
12217 pub is_used: Option<bool>,
12218 #[serde(default, skip_serializing_if = "Option::is_none")]
12219 pub value: Option<SharedLinkPermissions>,
12220}
12221
12222#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12223pub struct EnterpriseConfigurationContentAndSharingCollaborationPermissions {
12224 #[serde(default, skip_serializing_if = "Option::is_none")]
12225 pub is_used: Option<bool>,
12226 #[serde(default, skip_serializing_if = "Option::is_none")]
12227 pub value: Option<CollaborationPermissions>,
12228}
12229
12230#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12231pub struct EnterpriseConfigurationContentAndSharingCollaborationRestrictions {
12232 #[serde(default, skip_serializing_if = "Option::is_none")]
12233 pub is_used: Option<bool>,
12234 #[serde(default, skip_serializing_if = "Option::is_none")]
12235 pub value: Option<Vec<String>>,
12236}
12237
12238#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12239pub struct EnterpriseConfigurationContentAndSharingExternalCollaborationStatus {
12240 #[serde(default, skip_serializing_if = "Option::is_none")]
12241 pub is_used: Option<bool>,
12242 #[serde(
12243 default,
12244 skip_serializing_if = "Option::is_none",
12245 deserialize_with = "double_option"
12246 )]
12247 pub value: Option<Option<String>>,
12248}
12249
12250#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12251pub struct EnterpriseConfigurationContentAndSharingExternalCollaborationAllowlistUsers {
12252 #[serde(default, skip_serializing_if = "Option::is_none")]
12253 pub is_used: Option<bool>,
12254 #[serde(default, skip_serializing_if = "Option::is_none")]
12255 pub value: Option<Vec<ListUser>>,
12256}
12257
12258#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12259pub struct EnterpriseConfigurationSecurityLastPasswordResetAt {
12260 #[serde(default, skip_serializing_if = "Option::is_none")]
12261 pub is_used: Option<bool>,
12262 #[serde(
12263 default,
12264 skip_serializing_if = "Option::is_none",
12265 deserialize_with = "double_option"
12266 )]
12267 pub value: Option<Option<chrono::DateTime<chrono::Utc>>>,
12268}
12269
12270#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12271#[serde(transparent)]
12272pub struct ExternalCollabMultiFactorAuthSettingsValue(pub serde_json::Value);
12273
12274#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12275pub struct EnterpriseConfigurationSecurityExternalCollabMultiFactorAuthSettings {
12276 #[serde(default, skip_serializing_if = "Option::is_none")]
12277 pub is_used: Option<bool>,
12278 #[serde(default, skip_serializing_if = "Option::is_none")]
12279 pub value: Option<ExternalCollabMultiFactorAuthSettingsValue>,
12280}
12281
12282#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12283#[serde(transparent)]
12284pub struct KeysafeValue(pub serde_json::Value);
12285
12286#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12287pub struct EnterpriseConfigurationSecurityKeysafe {
12288 #[serde(default, skip_serializing_if = "Option::is_none")]
12289 pub is_used: Option<bool>,
12290 #[serde(default, skip_serializing_if = "Option::is_none")]
12291 pub value: Option<KeysafeValue>,
12292}
12293
12294#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12295pub struct EnterpriseConfigurationSecurityCustomSessionDurationGroups {
12296 #[serde(default, skip_serializing_if = "Option::is_none")]
12297 pub is_used: Option<bool>,
12298 #[serde(default, skip_serializing_if = "Option::is_none")]
12299 pub value: Option<Vec<CustomSessionDurationGroupItem>>,
12300}
12301
12302#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12303pub struct EnforcedMfaFrequencyValue {
12304 #[serde(
12305 default,
12306 skip_serializing_if = "Option::is_none",
12307 deserialize_with = "double_option"
12308 )]
12309 pub days: Option<Option<i64>>,
12310 #[serde(
12311 default,
12312 skip_serializing_if = "Option::is_none",
12313 deserialize_with = "double_option"
12314 )]
12315 pub hours: Option<Option<i64>>,
12316}
12317
12318#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12319pub struct EnterpriseConfigurationSecurityEnforcedMfaFrequency {
12320 #[serde(default, skip_serializing_if = "Option::is_none")]
12321 pub is_used: Option<bool>,
12322 #[serde(default, skip_serializing_if = "Option::is_none")]
12323 pub value: Option<EnforcedMfaFrequencyValue>,
12324}
12325
12326#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12327pub struct EnterpriseConfigurationUserSettingsUserTrackingCodes {
12328 #[serde(default, skip_serializing_if = "Option::is_none")]
12329 pub is_used: Option<bool>,
12330 #[serde(default, skip_serializing_if = "Option::is_none")]
12331 pub value: Option<Vec<UserTrackingCode>>,
12332}
12333
12334#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12335pub struct EnterpriseFeatureSettingFeature {
12336 #[serde(
12337 default,
12338 skip_serializing_if = "Option::is_none",
12339 deserialize_with = "double_option"
12340 )]
12341 pub id: Option<Option<String>>,
12342}
12343
12344#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12345#[serde(transparent)]
12346pub struct EnterpriseReferenceType(pub String);
12347
12348impl EnterpriseReferenceType {
12349 pub const ENTERPRISE: &'static str = "enterprise";
12350}
12351
12352#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12353#[serde(transparent)]
12354pub struct FileReferenceType(pub String);
12355
12356impl FileReferenceType {
12357 pub const FILE: &'static str = "file";
12358}
12359
12360#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12361#[serde(transparent)]
12362pub struct FileVersionBaseType(pub String);
12363
12364impl FileVersionBaseType {
12365 pub const FILE_VERSION: &'static str = "file_version";
12366}
12367
12368#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12369#[serde(transparent)]
12370pub struct GroupBaseType(pub String);
12371
12372impl GroupBaseType {
12373 pub const GROUP: &'static str = "group";
12374}
12375
12376#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12377#[serde(transparent)]
12378pub struct GroupMiniGroupType(pub String);
12379
12380impl GroupMiniGroupType {
12381 pub const MANAGED_GROUP: &'static str = "managed_group";
12382 pub const ALL_USERS_GROUP: &'static str = "all_users_group";
12383}
12384
12385#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12386#[serde(transparent)]
12387pub struct HubType(pub String);
12388
12389impl HubType {
12390 pub const HUBS: &'static str = "hubs";
12391}
12392
12393#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12394#[serde(transparent)]
12395pub struct HubCopyHubAccess(pub String);
12396
12397impl HubCopyHubAccess {
12398 pub const ALL: &'static str = "all";
12399 pub const COMPANY: &'static str = "company";
12400 pub const NONE: &'static str = "none";
12401}
12402
12403#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12404#[serde(transparent)]
12405pub struct HubCalloutBoxTextBlockType(pub String);
12406
12407impl HubCalloutBoxTextBlockType {
12408 pub const CALLOUT_BOX: &'static str = "callout_box";
12409}
12410
12411#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12412#[serde(transparent)]
12413pub struct HubCollaborationType(pub String);
12414
12415impl HubCollaborationType {
12416 pub const HUB_COLLABORATION: &'static str = "hub_collaboration";
12417}
12418
12419#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12420#[serde(transparent)]
12421pub struct HubCollaborationStatus(pub String);
12422
12423impl HubCollaborationStatus {
12424 pub const ACCEPTED: &'static str = "accepted";
12425 pub const PENDING: &'static str = "pending";
12426 pub const REJECTED: &'static str = "rejected";
12427}
12428
12429#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12430pub struct HubCollaborationAcceptanceRequirementsStatus {
12431 #[serde(default, skip_serializing_if = "Option::is_none")]
12432 pub terms_of_service_requirement: Option<AcceptanceRequirementsStatusTermsOfServiceRequirement>,
12433 #[serde(default, skip_serializing_if = "Option::is_none")]
12434 pub strong_password_requirement: Option<AcceptanceRequirementsStatusStrongPasswordRequirement>,
12435 #[serde(default, skip_serializing_if = "Option::is_none")]
12436 pub two_factor_authentication_requirement:
12437 Option<AcceptanceRequirementsStatusTwoFactorAuthenticationRequirement>,
12438}
12439
12440#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12441pub struct HubCollaborationCreateRequestHub {
12442 pub r#type: HubType,
12443 pub id: String,
12444}
12445
12446#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12447pub struct HubCollaborationCreateRequestAccessibleBy {
12448 pub r#type: String,
12449 #[serde(default, skip_serializing_if = "Option::is_none")]
12450 pub id: Option<String>,
12451 #[serde(default, skip_serializing_if = "Option::is_none")]
12452 pub login: Option<String>,
12453}
12454
12455#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12456#[serde(transparent)]
12457pub struct HubCollaborationUserType(pub String);
12458
12459impl HubCollaborationUserType {
12460 pub const USER: &'static str = "user";
12461}
12462
12463#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12464#[serde(transparent)]
12465pub struct HubDividerBlockType(pub String);
12466
12467impl HubDividerBlockType {
12468 pub const DIVIDER: &'static str = "divider";
12469}
12470
12471#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12472#[serde(transparent)]
12473pub struct HubDocumentBlocksType(pub String);
12474
12475impl HubDocumentBlocksType {
12476 pub const DOCUMENT_BLOCKS: &'static str = "document_blocks";
12477}
12478
12479#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12480#[serde(transparent)]
12481pub struct HubDocumentPagesType(pub String);
12482
12483impl HubDocumentPagesType {
12484 pub const DOCUMENT_PAGES: &'static str = "document_pages";
12485}
12486
12487#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12488#[serde(transparent)]
12489pub struct HubItemType(pub String);
12490
12491impl HubItemType {
12492 pub const FILE: &'static str = "file";
12493 pub const FOLDER: &'static str = "folder";
12494 pub const WEB_LINK: &'static str = "web_link";
12495}
12496
12497#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12498#[serde(transparent)]
12499pub struct HubItemListBlockType(pub String);
12500
12501impl HubItemListBlockType {
12502 pub const ITEM_LIST: &'static str = "item_list";
12503}
12504
12505#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12506#[serde(transparent)]
12507pub struct HubItemOperationAction(pub String);
12508
12509impl HubItemOperationAction {
12510 pub const ADD: &'static str = "add";
12511 pub const REMOVE: &'static str = "remove";
12512}
12513
12514#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12515#[serde(transparent)]
12516pub struct HubParagraphTextBlockType(pub String);
12517
12518impl HubParagraphTextBlockType {
12519 pub const PARAGRAPH: &'static str = "paragraph";
12520}
12521
12522#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12523#[serde(transparent)]
12524pub struct HubSectionTitleTextBlockType(pub String);
12525
12526impl HubSectionTitleTextBlockType {
12527 pub const SECTION_TITLE: &'static str = "section_title";
12528}
12529
12530#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12531#[serde(transparent)]
12532pub struct ShieldListMiniType(pub String);
12533
12534impl ShieldListMiniType {
12535 pub const SHIELD_LIST: &'static str = "shield_list";
12536}
12537
12538#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12539pub struct ShieldListMiniContent {
12540 #[serde(default, skip_serializing_if = "Option::is_none")]
12541 pub r#type: Option<String>,
12542}
12543
12544#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12545#[serde(transparent)]
12546pub struct ShieldListContentCountryType(pub String);
12547
12548impl ShieldListContentCountryType {
12549 pub const COUNTRY: &'static str = "country";
12550}
12551
12552#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12553#[serde(transparent)]
12554pub struct ShieldListContentDomainType(pub String);
12555
12556impl ShieldListContentDomainType {
12557 pub const DOMAIN: &'static str = "domain";
12558}
12559
12560#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12561#[serde(transparent)]
12562pub struct ShieldListContentEmailType(pub String);
12563
12564impl ShieldListContentEmailType {
12565 pub const EMAIL: &'static str = "email";
12566}
12567
12568#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12569#[serde(transparent)]
12570pub struct ShieldListContentIntegrationType(pub String);
12571
12572impl ShieldListContentIntegrationType {
12573 pub const INTEGRATION: &'static str = "integration";
12574}
12575
12576#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12577pub struct ShieldListContentIntegrationIntegrations {
12578 #[serde(default, skip_serializing_if = "Option::is_none")]
12579 pub id: Option<String>,
12580}
12581
12582#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12583#[serde(transparent)]
12584pub struct ShieldListContentIpType(pub String);
12585
12586impl ShieldListContentIpType {
12587 pub const IP: &'static str = "ip";
12588}
12589
12590#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12591#[serde(transparent)]
12592pub struct ShieldRuleItemType(pub String);
12593
12594impl ShieldRuleItemType {
12595 pub const SHIELD_RULE: &'static str = "shield_rule";
12596}
12597
12598#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12599#[serde(transparent)]
12600pub struct ShieldRuleItemPriority(pub String);
12601
12602impl ShieldRuleItemPriority {
12603 pub const INFORMATIONAL: &'static str = "informational";
12604 pub const LOW: &'static str = "low";
12605 pub const MEDIUM: &'static str = "medium";
12606 pub const HIGH: &'static str = "high";
12607 pub const CRITICAL: &'static str = "critical";
12608}
12609
12610#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12611#[serde(transparent)]
12612pub struct TermsOfServiceBaseType(pub String);
12613
12614impl TermsOfServiceBaseType {
12615 pub const TERMS_OF_SERVICE: &'static str = "terms_of_service";
12616}
12617
12618#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12619#[serde(transparent)]
12620pub struct UserOrGroupReferenceType(pub String);
12621
12622impl UserOrGroupReferenceType {
12623 pub const USER: &'static str = "user";
12624 pub const GROUP: &'static str = "group";
12625}
12626
12627#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12628#[serde(transparent)]
12629pub struct WeblinkReferenceType(pub String);
12630
12631impl WeblinkReferenceType {
12632 pub const WEB_LINK: &'static str = "web_link";
12633}
12634
12635#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12636pub struct ArchiveCreateRequest {
12637 pub name: String,
12638 #[serde(default, skip_serializing_if = "Option::is_none")]
12639 pub description: Option<String>,
12640 #[serde(default, skip_serializing_if = "Option::is_none")]
12641 pub storage_policy_id: Option<String>,
12642}
12643
12644#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12645pub struct ArchiveUpdateRequest {
12646 #[serde(default, skip_serializing_if = "Option::is_none")]
12647 pub name: Option<String>,
12648 #[serde(default, skip_serializing_if = "Option::is_none")]
12649 pub description: Option<String>,
12650}
12651
12652#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12653pub struct AutomateWorkflowAction {
12654 pub id: String,
12655 pub r#type: AutomateWorkflowActionType,
12656 pub action_type: AutomateWorkflowActionActionType,
12657 #[serde(default, skip_serializing_if = "Option::is_none")]
12658 pub description: Option<String>,
12659 #[serde(default, skip_serializing_if = "Option::is_none")]
12660 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
12661 #[serde(default, skip_serializing_if = "Option::is_none")]
12662 pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
12663 #[serde(default, skip_serializing_if = "Option::is_none")]
12664 pub created_by: Option<UserMini>,
12665 #[serde(default, skip_serializing_if = "Option::is_none")]
12666 pub updated_by: Option<UserMini>,
12667 pub workflow: AutomateWorkflowReference,
12668}
12669
12670#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12671pub struct AutomateWorkflowReference {
12672 pub id: String,
12673 pub r#type: AutomateWorkflowReferenceType,
12674 #[serde(default, skip_serializing_if = "Option::is_none")]
12675 pub name: Option<String>,
12676}
12677
12678#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12679pub struct AutomateWorkflows {
12680 #[serde(default, skip_serializing_if = "Option::is_none")]
12681 pub entries: Option<Vec<AutomateWorkflowAction>>,
12682 #[serde(default, skip_serializing_if = "Option::is_none")]
12683 pub limit: Option<i64>,
12684 #[serde(
12685 default,
12686 skip_serializing_if = "Option::is_none",
12687 deserialize_with = "double_option"
12688 )]
12689 pub next_marker: Option<Option<String>>,
12690}
12691
12692#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12693pub struct AutomateWorkflowStartRequest {
12694 pub workflow_action_id: String,
12695 pub file_ids: Vec<String>,
12696}
12697
12698#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12699pub struct NotesConvertRequestBody {
12700 pub content: String,
12701 pub content_format: NotesConvertRequestBodyContentFormat,
12702 pub parent: FolderReference,
12703 pub name: String,
12704}
12705
12706#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
12707pub struct NotesConvertResponse {
12708 pub r#type: NotesConvertResponseType,
12709 pub id: String,
12710}
12711
12712#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12713#[serde(transparent)]
12714pub struct AutomateWorkflowActionType(pub String);
12715
12716impl AutomateWorkflowActionType {
12717 pub const WORKFLOW_ACTION: &'static str = "workflow_action";
12718}
12719
12720#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12721#[serde(transparent)]
12722pub struct AutomateWorkflowActionActionType(pub String);
12723
12724impl AutomateWorkflowActionActionType {
12725 pub const RUN_WORKFLOW: &'static str = "run_workflow";
12726}
12727
12728#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12729#[serde(transparent)]
12730pub struct AutomateWorkflowReferenceType(pub String);
12731
12732impl AutomateWorkflowReferenceType {
12733 pub const WORKFLOW: &'static str = "workflow";
12734}
12735
12736#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12737#[serde(transparent)]
12738pub struct FolderReferenceType(pub String);
12739
12740impl FolderReferenceType {
12741 pub const FOLDER: &'static str = "folder";
12742}
12743
12744#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12745#[serde(transparent)]
12746pub struct NotesConvertRequestBodyContentFormat(pub String);
12747
12748impl NotesConvertRequestBodyContentFormat {
12749 pub const MARKDOWN: &'static str = "markdown";
12750}
12751
12752#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12753#[serde(transparent)]
12754pub struct NotesConvertResponseType(pub String);
12755
12756impl NotesConvertResponseType {
12757 pub const FILE: &'static str = "file";
12758}
12759
12760#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
12761#[serde(transparent)]
12762pub struct UserBaseType(pub String);
12763
12764impl UserBaseType {
12765 pub const USER: &'static str = "user";
12766}