1use crate::serde_helpers::double_option;
4
5mod ai;
6mod ai_studio;
7mod app_item_associations;
8mod archives;
9mod authorization;
10mod automate_workflows;
11mod avatars;
12mod chunked_uploads;
13mod classifications;
14mod collaboration_allowlist_entries;
15mod collaboration_allowlist_exempt_targets;
16mod collections;
17mod comments;
18mod device_pinners;
19mod docgen;
20mod docgen_template;
21mod email_aliases;
22mod enterprise_configurations;
23mod events;
24mod external_users;
25mod file_requests;
26mod file_version_legal_holds;
27mod file_version_retentions;
28mod file_versions;
29mod files;
30mod folder_locks;
31mod folders;
32mod groups;
33mod hub_collaborations;
34mod hub_document;
35mod hub_items;
36mod hubs;
37mod integration_mappings;
38mod invites;
39mod legal_hold_policies;
40mod legal_hold_policy_assignments;
41mod list_collaborations;
42mod memberships;
43mod metadata_cascade_policies;
44mod metadata_taxonomies;
45mod metadata_templates;
46mod notes;
47mod query;
48mod recent_items;
49mod retention_policies;
50mod retention_policy_assignments;
51mod search;
52mod session_termination;
53mod shared_links_folders;
54mod shield_information_barrier_reports;
55mod shield_information_barrier_segment_members;
56mod shield_information_barrier_segment_restrictions;
57mod shield_information_barrier_segments;
58mod shield_information_barriers;
59mod shield_lists;
60mod sign_requests;
61mod sign_templates;
62mod skills;
63mod storage_policies;
64mod storage_policy_assignments;
65mod task_assignments;
66mod tasks;
67mod terms_of_service_user_statuses;
68mod terms_of_services;
69mod transfer;
70mod trashed_files;
71mod trashed_folders;
72mod trashed_items;
73mod trashed_web_links;
74mod uploads;
75mod user_collaborations;
76mod users;
77mod web_links;
78mod webhooks;
79mod workflows;
80mod zip_downloads;
81
82pub use ai::*;
83pub use ai_studio::*;
84pub use app_item_associations::*;
85pub use archives::*;
86pub use authorization::*;
87pub use automate_workflows::*;
88pub use avatars::*;
89pub use chunked_uploads::*;
90pub use classifications::*;
91pub use collaboration_allowlist_entries::*;
92pub use collaboration_allowlist_exempt_targets::*;
93pub use collections::*;
94pub use comments::*;
95pub use device_pinners::*;
96pub use docgen::*;
97pub use docgen_template::*;
98pub use email_aliases::*;
99pub use enterprise_configurations::*;
100pub use events::*;
101pub use external_users::*;
102pub use file_requests::*;
103pub use file_version_legal_holds::*;
104pub use file_version_retentions::*;
105pub use file_versions::*;
106pub use files::*;
107pub use folder_locks::*;
108pub use folders::*;
109pub use groups::*;
110pub use hub_collaborations::*;
111pub use hub_document::*;
112pub use hub_items::*;
113pub use hubs::*;
114pub use integration_mappings::*;
115pub use invites::*;
116pub use legal_hold_policies::*;
117pub use legal_hold_policy_assignments::*;
118pub use list_collaborations::*;
119pub use memberships::*;
120pub use metadata_cascade_policies::*;
121pub use metadata_taxonomies::*;
122pub use metadata_templates::*;
123pub use notes::*;
124pub use query::*;
125pub use recent_items::*;
126pub use retention_policies::*;
127pub use retention_policy_assignments::*;
128pub use search::*;
129pub use session_termination::*;
130pub use shared_links_folders::*;
131pub use shield_information_barrier_reports::*;
132pub use shield_information_barrier_segment_members::*;
133pub use shield_information_barrier_segment_restrictions::*;
134pub use shield_information_barrier_segments::*;
135pub use shield_information_barriers::*;
136pub use shield_lists::*;
137pub use sign_requests::*;
138pub use sign_templates::*;
139pub use skills::*;
140pub use storage_policies::*;
141pub use storage_policy_assignments::*;
142pub use task_assignments::*;
143pub use tasks::*;
144pub use terms_of_service_user_statuses::*;
145pub use terms_of_services::*;
146pub use transfer::*;
147pub use trashed_files::*;
148pub use trashed_folders::*;
149pub use trashed_items::*;
150pub use trashed_web_links::*;
151pub use uploads::*;
152pub use user_collaborations::*;
153pub use users::*;
154pub use web_links::*;
155pub use webhooks::*;
156pub use workflows::*;
157pub use zip_downloads::*;
158
159#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
160pub struct AiAgentBasicTextToolBase {
161 #[serde(default, skip_serializing_if = "Option::is_none")]
162 pub model: Option<String>,
163 #[serde(default, skip_serializing_if = "Option::is_none")]
164 pub num_tokens_for_completion: Option<i64>,
165 #[serde(default, skip_serializing_if = "Option::is_none")]
166 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
167}
168
169#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
170pub struct AiAgentBasicTextToolTextGen {
171 #[serde(default, skip_serializing_if = "Option::is_none")]
172 pub model: Option<String>,
173 #[serde(default, skip_serializing_if = "Option::is_none")]
174 pub num_tokens_for_completion: Option<i64>,
175 #[serde(default, skip_serializing_if = "Option::is_none")]
176 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
177 #[serde(default, skip_serializing_if = "Option::is_none")]
178 pub system_message: Option<String>,
179 #[serde(default, skip_serializing_if = "Option::is_none")]
180 pub prompt_template: Option<String>,
181}
182
183#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
184pub struct AiAgentLongTextToolTextGen {
185 #[serde(default, skip_serializing_if = "Option::is_none")]
186 pub model: Option<String>,
187 #[serde(default, skip_serializing_if = "Option::is_none")]
188 pub num_tokens_for_completion: Option<i64>,
189 #[serde(default, skip_serializing_if = "Option::is_none")]
190 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
191 #[serde(default, skip_serializing_if = "Option::is_none")]
192 pub system_message: Option<String>,
193 #[serde(default, skip_serializing_if = "Option::is_none")]
194 pub prompt_template: Option<String>,
195 #[serde(default, skip_serializing_if = "Option::is_none")]
196 pub embeddings: Option<AiAgentBasicGenToolEmbeddings>,
197}
198
199#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
200pub struct AiAgentSpreadsheetTool {
201 #[serde(default, skip_serializing_if = "Option::is_none")]
202 pub model: Option<String>,
203 #[serde(default, skip_serializing_if = "Option::is_none")]
204 pub num_tokens_for_completion: Option<i64>,
205 #[serde(default, skip_serializing_if = "Option::is_none")]
206 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
207}
208
209#[derive(Clone, Debug, PartialEq)]
210pub enum AiLlmEndpointParams {
211 OpenaiParams(AiLlmEndpointParamsOpenAi),
212 GoogleParams(AiLlmEndpointParamsGoogle),
213 AwsParams(AiLlmEndpointParamsAWS),
214 IbmParams(AiLlmEndpointParamsIBM),
215 Unknown(serde_json::Value),
217}
218
219impl Default for AiLlmEndpointParams {
220 fn default() -> Self {
221 Self::Unknown(Default::default())
222 }
223}
224
225impl serde::Serialize for AiLlmEndpointParams {
226 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
227 match self {
228 Self::OpenaiParams(inner) => inner.serialize(serializer),
229 Self::GoogleParams(inner) => inner.serialize(serializer),
230 Self::AwsParams(inner) => inner.serialize(serializer),
231 Self::IbmParams(inner) => inner.serialize(serializer),
232 Self::Unknown(inner) => inner.serialize(serializer),
233 }
234 }
235}
236
237impl<'de> serde::Deserialize<'de> for AiLlmEndpointParams {
238 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
239 let value = serde_json::Value::deserialize(deserializer)?;
240 let tag = value
241 .get("type")
242 .and_then(serde_json::Value::as_str)
243 .map(str::to_owned);
244 match tag.as_deref() {
245 Some("openai_params") => Ok(Self::OpenaiParams(
246 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
247 )),
248 Some("google_params") => Ok(Self::GoogleParams(
249 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
250 )),
251 Some("aws_params") => Ok(Self::AwsParams(
252 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
253 )),
254 Some("ibm_params") => Ok(Self::IbmParams(
255 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
256 )),
257 _ => Ok(Self::Unknown(value)),
258 }
259 }
260}
261
262#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
263pub struct AiLlmEndpointParamsAWS {
264 pub r#type: AiLlmEndpointParamsAWSType,
265 #[serde(
266 default,
267 skip_serializing_if = "Option::is_none",
268 deserialize_with = "double_option"
269 )]
270 pub temperature: Option<Option<f64>>,
271 #[serde(
272 default,
273 skip_serializing_if = "Option::is_none",
274 deserialize_with = "double_option"
275 )]
276 pub top_p: Option<Option<f64>>,
277}
278
279#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
280pub struct AiLlmEndpointParamsGoogle {
281 pub r#type: AiLlmEndpointParamsGoogleType,
282 #[serde(
283 default,
284 skip_serializing_if = "Option::is_none",
285 deserialize_with = "double_option"
286 )]
287 pub temperature: Option<Option<f64>>,
288 #[serde(
289 default,
290 skip_serializing_if = "Option::is_none",
291 deserialize_with = "double_option"
292 )]
293 pub top_p: Option<Option<f64>>,
294 #[serde(
295 default,
296 skip_serializing_if = "Option::is_none",
297 deserialize_with = "double_option"
298 )]
299 pub top_k: Option<Option<f64>>,
300}
301
302#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
303pub struct AiLlmEndpointParamsIBM {
304 pub r#type: AiLlmEndpointParamsIBMType,
305 #[serde(
306 default,
307 skip_serializing_if = "Option::is_none",
308 deserialize_with = "double_option"
309 )]
310 pub temperature: Option<Option<f64>>,
311 #[serde(
312 default,
313 skip_serializing_if = "Option::is_none",
314 deserialize_with = "double_option"
315 )]
316 pub top_p: Option<Option<f64>>,
317 #[serde(
318 default,
319 skip_serializing_if = "Option::is_none",
320 deserialize_with = "double_option"
321 )]
322 pub top_k: Option<Option<f64>>,
323}
324
325#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
326pub struct AiLlmEndpointParamsOpenAi {
327 pub r#type: AiLlmEndpointParamsOpenAiType,
328 #[serde(
329 default,
330 skip_serializing_if = "Option::is_none",
331 deserialize_with = "double_option"
332 )]
333 pub temperature: Option<Option<f64>>,
334 #[serde(
335 default,
336 skip_serializing_if = "Option::is_none",
337 deserialize_with = "double_option"
338 )]
339 pub top_p: Option<Option<f64>>,
340 #[serde(
341 default,
342 skip_serializing_if = "Option::is_none",
343 deserialize_with = "double_option"
344 )]
345 pub frequency_penalty: Option<Option<f64>>,
346 #[serde(
347 default,
348 skip_serializing_if = "Option::is_none",
349 deserialize_with = "double_option"
350 )]
351 pub presence_penalty: Option<Option<f64>>,
352 #[serde(
353 default,
354 skip_serializing_if = "Option::is_none",
355 deserialize_with = "double_option"
356 )]
357 pub stop: Option<Option<String>>,
358}
359
360#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
361pub struct AiSingleAgentResponse {
362 pub id: String,
363 #[serde(default, skip_serializing_if = "Option::is_none")]
364 pub r#type: Option<AiSingleAgentResponseType>,
365 pub origin: String,
366 pub name: String,
367 pub access_state: String,
368 #[serde(default, skip_serializing_if = "Option::is_none")]
369 pub created_by: Option<UserBase>,
370 #[serde(default, skip_serializing_if = "Option::is_none")]
371 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
372 #[serde(default, skip_serializing_if = "Option::is_none")]
373 pub modified_by: Option<UserBase>,
374 #[serde(default, skip_serializing_if = "Option::is_none")]
375 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
376 #[serde(default, skip_serializing_if = "Option::is_none")]
377 pub icon_reference: Option<String>,
378 #[serde(default, skip_serializing_if = "Option::is_none")]
379 pub allowed_entities: Option<Vec<AiAgentAllowedEntity>>,
380}
381
382#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
383pub struct AppItem {
384 pub id: String,
385 pub r#type: AppItemType,
386 pub application_type: String,
387}
388
389#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
390pub struct Classification {
391 #[serde(
392 rename = "Box__Security__Classification__Key",
393 default,
394 skip_serializing_if = "Option::is_none"
395 )]
396 pub box_security_classification_key: Option<String>,
397 #[serde(rename = "$parent", default, skip_serializing_if = "Option::is_none")]
398 pub parent: Option<String>,
399 #[serde(rename = "$template", default, skip_serializing_if = "Option::is_none")]
400 pub template: Option<ClassificationTemplate2>,
401 #[serde(rename = "$scope", default, skip_serializing_if = "Option::is_none")]
402 pub scope: Option<String>,
403 #[serde(rename = "$version", default, skip_serializing_if = "Option::is_none")]
404 pub version: Option<i64>,
405 #[serde(rename = "$type", default, skip_serializing_if = "Option::is_none")]
406 pub r#type: Option<String>,
407 #[serde(
408 rename = "$typeVersion",
409 default,
410 skip_serializing_if = "Option::is_none"
411 )]
412 pub type_version: Option<f64>,
413 #[serde(rename = "$canEdit", default, skip_serializing_if = "Option::is_none")]
414 pub can_edit: Option<bool>,
415}
416
417#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
418pub struct ClientError {
419 #[serde(default, skip_serializing_if = "Option::is_none")]
420 pub r#type: Option<ClientErrorType>,
421 #[serde(default, skip_serializing_if = "Option::is_none")]
422 pub status: Option<i64>,
423 #[serde(default, skip_serializing_if = "Option::is_none")]
424 pub code: Option<ClientErrorCode>,
425 #[serde(default, skip_serializing_if = "Option::is_none")]
426 pub message: Option<String>,
427 #[serde(
428 default,
429 skip_serializing_if = "Option::is_none",
430 deserialize_with = "double_option"
431 )]
432 pub context_info: Option<Option<std::collections::HashMap<String, serde_json::Value>>>,
433 #[serde(default, skip_serializing_if = "Option::is_none")]
434 pub help_url: Option<String>,
435 #[serde(default, skip_serializing_if = "Option::is_none")]
436 pub request_id: Option<String>,
437}
438
439#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
440pub struct Collaboration {
441 pub id: String,
442 pub r#type: CollaborationType,
443 #[serde(
444 default,
445 skip_serializing_if = "Option::is_none",
446 deserialize_with = "double_option"
447 )]
448 pub item: Option<Option<CollaborationItem>>,
449 #[serde(
450 default,
451 skip_serializing_if = "Option::is_none",
452 deserialize_with = "double_option"
453 )]
454 pub app_item: Option<Option<AppItem>>,
455 #[serde(default, skip_serializing_if = "Option::is_none")]
456 pub accessible_by: Option<CollaborationAccessGrantee>,
457 #[serde(
458 default,
459 skip_serializing_if = "Option::is_none",
460 deserialize_with = "double_option"
461 )]
462 pub invite_email: Option<Option<String>>,
463 #[serde(default, skip_serializing_if = "Option::is_none")]
464 pub role: Option<CollaborationRole>,
465 #[serde(
466 default,
467 skip_serializing_if = "Option::is_none",
468 deserialize_with = "double_option"
469 )]
470 pub expires_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
471 #[serde(default, skip_serializing_if = "Option::is_none")]
472 pub is_access_only: Option<bool>,
473 #[serde(default, skip_serializing_if = "Option::is_none")]
474 pub status: Option<CollaborationStatus>,
475 #[serde(default, skip_serializing_if = "Option::is_none")]
476 pub acknowledged_at: Option<chrono::DateTime<chrono::Utc>>,
477 #[serde(default, skip_serializing_if = "Option::is_none")]
478 pub created_by: Option<UserCollaborations>,
479 #[serde(default, skip_serializing_if = "Option::is_none")]
480 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
481 #[serde(default, skip_serializing_if = "Option::is_none")]
482 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
483 #[serde(default, skip_serializing_if = "Option::is_none")]
484 pub acceptance_requirements_status: Option<CollaborationAcceptanceRequirementsStatus>,
485}
486
487#[derive(Clone, Debug, PartialEq)]
488pub enum CollaborationAccessGrantee {
489 User(UserCollaborations),
490 Group(GroupMini),
491 Unknown(serde_json::Value),
493}
494
495impl Default for CollaborationAccessGrantee {
496 fn default() -> Self {
497 Self::Unknown(Default::default())
498 }
499}
500
501impl serde::Serialize for CollaborationAccessGrantee {
502 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
503 match self {
504 Self::User(inner) => inner.serialize(serializer),
505 Self::Group(inner) => inner.serialize(serializer),
506 Self::Unknown(inner) => inner.serialize(serializer),
507 }
508 }
509}
510
511impl<'de> serde::Deserialize<'de> for CollaborationAccessGrantee {
512 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
513 let value = serde_json::Value::deserialize(deserializer)?;
514 let tag = value
515 .get("type")
516 .and_then(serde_json::Value::as_str)
517 .map(str::to_owned);
518 match tag.as_deref() {
519 Some("user") => Ok(Self::User(
520 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
521 )),
522 Some("group") => Ok(Self::Group(
523 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
524 )),
525 _ => Ok(Self::Unknown(value)),
526 }
527 }
528}
529
530#[derive(Clone, Debug, PartialEq)]
531pub enum CollaborationItem {
532 File(File),
533 Folder(Folder),
534 WebLink(WebLink),
535 Unknown(serde_json::Value),
537}
538
539impl Default for CollaborationItem {
540 fn default() -> Self {
541 Self::Unknown(Default::default())
542 }
543}
544
545impl serde::Serialize for CollaborationItem {
546 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
547 match self {
548 Self::File(inner) => inner.serialize(serializer),
549 Self::Folder(inner) => inner.serialize(serializer),
550 Self::WebLink(inner) => inner.serialize(serializer),
551 Self::Unknown(inner) => inner.serialize(serializer),
552 }
553 }
554}
555
556impl<'de> serde::Deserialize<'de> for CollaborationItem {
557 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
558 let value = serde_json::Value::deserialize(deserializer)?;
559 let tag = value
560 .get("type")
561 .and_then(serde_json::Value::as_str)
562 .map(str::to_owned);
563 match tag.as_deref() {
564 Some("file") => Ok(Self::File(
565 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
566 )),
567 Some("folder") => Ok(Self::Folder(
568 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
569 )),
570 Some("web_link") => Ok(Self::WebLink(
571 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
572 )),
573 _ => Ok(Self::Unknown(value)),
574 }
575 }
576}
577
578#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
579pub struct Collection {
580 #[serde(default, skip_serializing_if = "Option::is_none")]
581 pub id: Option<String>,
582 #[serde(default, skip_serializing_if = "Option::is_none")]
583 pub r#type: Option<CollectionType>,
584 #[serde(default, skip_serializing_if = "Option::is_none")]
585 pub name: Option<CollectionName>,
586 #[serde(default, skip_serializing_if = "Option::is_none")]
587 pub collection_type: Option<CollectionCollectionType>,
588}
589
590#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
591pub struct Comment {
592 #[serde(default, skip_serializing_if = "Option::is_none")]
593 pub id: Option<String>,
594 #[serde(default, skip_serializing_if = "Option::is_none")]
595 pub r#type: Option<CommentType>,
596 #[serde(default, skip_serializing_if = "Option::is_none")]
597 pub is_reply_comment: Option<bool>,
598 #[serde(default, skip_serializing_if = "Option::is_none")]
599 pub message: Option<String>,
600 #[serde(default, skip_serializing_if = "Option::is_none")]
601 pub created_by: Option<UserMini>,
602 #[serde(default, skip_serializing_if = "Option::is_none")]
603 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
604 #[serde(default, skip_serializing_if = "Option::is_none")]
605 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
606 #[serde(default, skip_serializing_if = "Option::is_none")]
607 pub item: Option<CommentItem>,
608}
609
610#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
611pub struct CommentBase {
612 #[serde(default, skip_serializing_if = "Option::is_none")]
613 pub id: Option<String>,
614 #[serde(default, skip_serializing_if = "Option::is_none")]
615 pub r#type: Option<CommentType>,
616}
617
618#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
619pub struct ConflictError {
620 #[serde(default, skip_serializing_if = "Option::is_none")]
621 pub r#type: Option<ClientErrorType>,
622 #[serde(default, skip_serializing_if = "Option::is_none")]
623 pub status: Option<i64>,
624 #[serde(default, skip_serializing_if = "Option::is_none")]
625 pub code: Option<ClientErrorCode>,
626 #[serde(default, skip_serializing_if = "Option::is_none")]
627 pub message: Option<String>,
628 #[serde(default, skip_serializing_if = "Option::is_none")]
629 pub context_info: Option<ConflictErrorContextInfo>,
630 #[serde(default, skip_serializing_if = "Option::is_none")]
631 pub help_url: Option<String>,
632 #[serde(default, skip_serializing_if = "Option::is_none")]
633 pub request_id: Option<String>,
634}
635
636#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
637pub struct File {
638 pub id: String,
639 #[serde(
640 default,
641 skip_serializing_if = "Option::is_none",
642 deserialize_with = "double_option"
643 )]
644 pub etag: Option<Option<String>>,
645 pub r#type: AiCitationType,
646 #[serde(default, skip_serializing_if = "Option::is_none")]
647 pub sequence_id: Option<String>,
648 #[serde(default, skip_serializing_if = "Option::is_none")]
649 pub name: Option<String>,
650 #[serde(default, skip_serializing_if = "Option::is_none")]
651 pub sha1: Option<String>,
652 #[serde(default, skip_serializing_if = "Option::is_none")]
653 pub file_version: Option<FileVersionMini>,
654 #[serde(default, skip_serializing_if = "Option::is_none")]
655 pub description: Option<String>,
656 #[serde(default, skip_serializing_if = "Option::is_none")]
657 pub size: Option<i64>,
658 #[serde(default, skip_serializing_if = "Option::is_none")]
659 pub path_collection: Option<FilePathCollection>,
660 #[serde(default, skip_serializing_if = "Option::is_none")]
661 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
662 #[serde(default, skip_serializing_if = "Option::is_none")]
663 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
664 #[serde(
665 default,
666 skip_serializing_if = "Option::is_none",
667 deserialize_with = "double_option"
668 )]
669 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
670 #[serde(
671 default,
672 skip_serializing_if = "Option::is_none",
673 deserialize_with = "double_option"
674 )]
675 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
676 #[serde(
677 default,
678 skip_serializing_if = "Option::is_none",
679 deserialize_with = "double_option"
680 )]
681 pub content_created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
682 #[serde(
683 default,
684 skip_serializing_if = "Option::is_none",
685 deserialize_with = "double_option"
686 )]
687 pub content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
688 #[serde(default, skip_serializing_if = "Option::is_none")]
689 pub created_by: Option<UserMini>,
690 #[serde(default, skip_serializing_if = "Option::is_none")]
691 pub modified_by: Option<UserMini>,
692 #[serde(default, skip_serializing_if = "Option::is_none")]
693 pub owned_by: Option<UserMini>,
694 #[serde(
695 default,
696 skip_serializing_if = "Option::is_none",
697 deserialize_with = "double_option"
698 )]
699 pub shared_link: Option<Option<FileSharedLink>>,
700 #[serde(
701 default,
702 skip_serializing_if = "Option::is_none",
703 deserialize_with = "double_option"
704 )]
705 pub parent: Option<Option<FolderMini>>,
706 #[serde(default, skip_serializing_if = "Option::is_none")]
707 pub item_status: Option<FileItemStatus>,
708}
709
710#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
711pub struct FileBase {
712 pub id: String,
713 #[serde(
714 default,
715 skip_serializing_if = "Option::is_none",
716 deserialize_with = "double_option"
717 )]
718 pub etag: Option<Option<String>>,
719 pub r#type: AiCitationType,
720}
721
722#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
723pub struct FileFull {
724 pub id: String,
725 #[serde(
726 default,
727 skip_serializing_if = "Option::is_none",
728 deserialize_with = "double_option"
729 )]
730 pub etag: Option<Option<String>>,
731 pub r#type: AiCitationType,
732 #[serde(default, skip_serializing_if = "Option::is_none")]
733 pub sequence_id: Option<String>,
734 #[serde(default, skip_serializing_if = "Option::is_none")]
735 pub name: Option<String>,
736 #[serde(default, skip_serializing_if = "Option::is_none")]
737 pub sha1: Option<String>,
738 #[serde(default, skip_serializing_if = "Option::is_none")]
739 pub file_version: Option<FileVersionMini>,
740 #[serde(default, skip_serializing_if = "Option::is_none")]
741 pub description: Option<String>,
742 #[serde(default, skip_serializing_if = "Option::is_none")]
743 pub size: Option<i64>,
744 #[serde(default, skip_serializing_if = "Option::is_none")]
745 pub path_collection: Option<FilePathCollection>,
746 #[serde(default, skip_serializing_if = "Option::is_none")]
747 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
748 #[serde(default, skip_serializing_if = "Option::is_none")]
749 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
750 #[serde(
751 default,
752 skip_serializing_if = "Option::is_none",
753 deserialize_with = "double_option"
754 )]
755 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
756 #[serde(
757 default,
758 skip_serializing_if = "Option::is_none",
759 deserialize_with = "double_option"
760 )]
761 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
762 #[serde(
763 default,
764 skip_serializing_if = "Option::is_none",
765 deserialize_with = "double_option"
766 )]
767 pub content_created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
768 #[serde(
769 default,
770 skip_serializing_if = "Option::is_none",
771 deserialize_with = "double_option"
772 )]
773 pub content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
774 #[serde(default, skip_serializing_if = "Option::is_none")]
775 pub created_by: Option<UserMini>,
776 #[serde(default, skip_serializing_if = "Option::is_none")]
777 pub modified_by: Option<UserMini>,
778 #[serde(default, skip_serializing_if = "Option::is_none")]
779 pub owned_by: Option<UserMini>,
780 #[serde(
781 default,
782 skip_serializing_if = "Option::is_none",
783 deserialize_with = "double_option"
784 )]
785 pub shared_link: Option<Option<FileSharedLink>>,
786 #[serde(
787 default,
788 skip_serializing_if = "Option::is_none",
789 deserialize_with = "double_option"
790 )]
791 pub parent: Option<Option<FolderMini>>,
792 #[serde(default, skip_serializing_if = "Option::is_none")]
793 pub item_status: Option<FileItemStatus>,
794 #[serde(default, skip_serializing_if = "Option::is_none")]
795 pub version_number: Option<String>,
796 #[serde(default, skip_serializing_if = "Option::is_none")]
797 pub comment_count: Option<i64>,
798 #[serde(default, skip_serializing_if = "Option::is_none")]
799 pub permissions: Option<FileFullPermissions>,
800 #[serde(default, skip_serializing_if = "Option::is_none")]
801 pub tags: Option<Vec<String>>,
802 #[serde(
803 default,
804 skip_serializing_if = "Option::is_none",
805 deserialize_with = "double_option"
806 )]
807 pub lock: Option<Option<FileFullLock>>,
808 #[serde(default, skip_serializing_if = "Option::is_none")]
809 pub extension: Option<String>,
810 #[serde(default, skip_serializing_if = "Option::is_none")]
811 pub is_package: Option<bool>,
812 #[serde(default, skip_serializing_if = "Option::is_none")]
813 pub expiring_embed_link: Option<FileFullExpiringEmbedLink>,
814 #[serde(default, skip_serializing_if = "Option::is_none")]
815 pub watermark_info: Option<FileFullWatermarkInfo>,
816 #[serde(default, skip_serializing_if = "Option::is_none")]
817 pub is_accessible_via_shared_link: Option<bool>,
818 #[serde(default, skip_serializing_if = "Option::is_none")]
819 pub allowed_invitee_roles: Option<Vec<FileFullAllowedInviteeRoles>>,
820 #[serde(default, skip_serializing_if = "Option::is_none")]
821 pub is_externally_owned: Option<bool>,
822 #[serde(default, skip_serializing_if = "Option::is_none")]
823 pub has_collaborations: Option<bool>,
824 #[serde(default, skip_serializing_if = "Option::is_none")]
825 pub metadata:
826 Option<std::collections::HashMap<String, std::collections::HashMap<String, MetadataFull>>>,
827 #[serde(
828 default,
829 skip_serializing_if = "Option::is_none",
830 deserialize_with = "double_option"
831 )]
832 pub expires_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
833 #[serde(default, skip_serializing_if = "Option::is_none")]
834 pub representations: Option<FileFullRepresentations>,
835 #[serde(
836 default,
837 skip_serializing_if = "Option::is_none",
838 deserialize_with = "double_option"
839 )]
840 pub classification: Option<Option<FileFullClassification>>,
841 #[serde(default, skip_serializing_if = "Option::is_none")]
842 pub uploader_display_name: Option<String>,
843 #[serde(
844 default,
845 skip_serializing_if = "Option::is_none",
846 deserialize_with = "double_option"
847 )]
848 pub disposition_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
849 #[serde(
850 default,
851 skip_serializing_if = "Option::is_none",
852 deserialize_with = "double_option"
853 )]
854 pub shared_link_permission_options: Option<Option<Vec<FileFullSharedLinkPermissionOptions>>>,
855 #[serde(default, skip_serializing_if = "Option::is_none")]
856 pub is_associated_with_app_item: Option<bool>,
857 #[serde(default, skip_serializing_if = "Option::is_none")]
858 pub collections: Option<Vec<Collection>>,
859 #[serde(default, skip_serializing_if = "Option::is_none")]
860 pub is_download_available: Option<bool>,
861 #[serde(default, skip_serializing_if = "Option::is_none")]
862 pub download_url: Option<String>,
863 #[serde(default, skip_serializing_if = "Option::is_none")]
864 pub authenticated_download_url: Option<String>,
865 #[serde(default, skip_serializing_if = "Option::is_none")]
866 pub allowed_shared_link_access_levels: Option<Vec<SharedLinkAccess>>,
867}
868
869#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
870pub struct FileMini {
871 pub id: String,
872 #[serde(
873 default,
874 skip_serializing_if = "Option::is_none",
875 deserialize_with = "double_option"
876 )]
877 pub etag: Option<Option<String>>,
878 pub r#type: AiCitationType,
879 #[serde(default, skip_serializing_if = "Option::is_none")]
880 pub sequence_id: Option<String>,
881 #[serde(default, skip_serializing_if = "Option::is_none")]
882 pub name: Option<String>,
883 #[serde(default, skip_serializing_if = "Option::is_none")]
884 pub sha1: Option<String>,
885 #[serde(default, skip_serializing_if = "Option::is_none")]
886 pub file_version: Option<FileVersionMini>,
887}
888
889#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
890pub struct FileConflict {
891 pub id: String,
892 #[serde(
893 default,
894 skip_serializing_if = "Option::is_none",
895 deserialize_with = "double_option"
896 )]
897 pub etag: Option<Option<String>>,
898 pub r#type: AiCitationType,
899 #[serde(default, skip_serializing_if = "Option::is_none")]
900 pub sequence_id: Option<String>,
901 #[serde(default, skip_serializing_if = "Option::is_none")]
902 pub name: Option<String>,
903 #[serde(default, skip_serializing_if = "Option::is_none")]
904 pub sha1: Option<String>,
905 #[serde(default, skip_serializing_if = "Option::is_none")]
906 pub file_version: Option<FileVersionMini>,
907}
908
909#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
910pub struct Files {
911 #[serde(default, skip_serializing_if = "Option::is_none")]
912 pub total_count: Option<i64>,
913 #[serde(default, skip_serializing_if = "Option::is_none")]
914 pub entries: Option<Vec<FileFull>>,
915}
916
917#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
918pub struct FileVersionBase {
919 pub id: String,
920 pub r#type: FileVersionType,
921}
922
923#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
924pub struct FileVersionMini {
925 pub id: String,
926 pub r#type: FileVersionType,
927 #[serde(default, skip_serializing_if = "Option::is_none")]
928 pub sha1: Option<String>,
929}
930
931#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
932pub struct Folder {
933 pub id: String,
934 #[serde(
935 default,
936 skip_serializing_if = "Option::is_none",
937 deserialize_with = "double_option"
938 )]
939 pub etag: Option<Option<String>>,
940 pub r#type: FolderType,
941 #[serde(default, skip_serializing_if = "Option::is_none")]
942 pub sequence_id: Option<String>,
943 #[serde(default, skip_serializing_if = "Option::is_none")]
944 pub name: Option<String>,
945 #[serde(
946 default,
947 skip_serializing_if = "Option::is_none",
948 deserialize_with = "double_option"
949 )]
950 pub created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
951 #[serde(
952 default,
953 skip_serializing_if = "Option::is_none",
954 deserialize_with = "double_option"
955 )]
956 pub modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
957 #[serde(default, skip_serializing_if = "Option::is_none")]
958 pub description: Option<String>,
959 #[serde(default, skip_serializing_if = "Option::is_none")]
960 pub size: Option<i64>,
961 #[serde(default, skip_serializing_if = "Option::is_none")]
962 pub path_collection: Option<FilePathCollection>,
963 #[serde(default, skip_serializing_if = "Option::is_none")]
964 pub created_by: Option<UserMini>,
965 #[serde(default, skip_serializing_if = "Option::is_none")]
966 pub modified_by: Option<UserMini>,
967 #[serde(
968 default,
969 skip_serializing_if = "Option::is_none",
970 deserialize_with = "double_option"
971 )]
972 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
973 #[serde(
974 default,
975 skip_serializing_if = "Option::is_none",
976 deserialize_with = "double_option"
977 )]
978 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
979 #[serde(
980 default,
981 skip_serializing_if = "Option::is_none",
982 deserialize_with = "double_option"
983 )]
984 pub content_created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
985 #[serde(
986 default,
987 skip_serializing_if = "Option::is_none",
988 deserialize_with = "double_option"
989 )]
990 pub content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
991 #[serde(default, skip_serializing_if = "Option::is_none")]
992 pub owned_by: Option<UserMini>,
993 #[serde(
994 default,
995 skip_serializing_if = "Option::is_none",
996 deserialize_with = "double_option"
997 )]
998 pub shared_link: Option<Option<FileSharedLink>>,
999 #[serde(
1000 default,
1001 skip_serializing_if = "Option::is_none",
1002 deserialize_with = "double_option"
1003 )]
1004 pub folder_upload_email: Option<Option<FolderFolderUploadEmail>>,
1005 #[serde(
1006 default,
1007 skip_serializing_if = "Option::is_none",
1008 deserialize_with = "double_option"
1009 )]
1010 pub parent: Option<Option<FolderMini>>,
1011 #[serde(default, skip_serializing_if = "Option::is_none")]
1012 pub item_status: Option<FileItemStatus>,
1013 #[serde(default, skip_serializing_if = "Option::is_none")]
1014 pub item_collection: Option<Items>,
1015}
1016
1017#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1018pub struct FolderFull {
1019 pub id: String,
1020 #[serde(
1021 default,
1022 skip_serializing_if = "Option::is_none",
1023 deserialize_with = "double_option"
1024 )]
1025 pub etag: Option<Option<String>>,
1026 pub r#type: FolderType,
1027 #[serde(default, skip_serializing_if = "Option::is_none")]
1028 pub sequence_id: Option<String>,
1029 #[serde(default, skip_serializing_if = "Option::is_none")]
1030 pub name: Option<String>,
1031 #[serde(
1032 default,
1033 skip_serializing_if = "Option::is_none",
1034 deserialize_with = "double_option"
1035 )]
1036 pub created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1037 #[serde(
1038 default,
1039 skip_serializing_if = "Option::is_none",
1040 deserialize_with = "double_option"
1041 )]
1042 pub modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1043 #[serde(default, skip_serializing_if = "Option::is_none")]
1044 pub description: Option<String>,
1045 #[serde(default, skip_serializing_if = "Option::is_none")]
1046 pub size: Option<i64>,
1047 #[serde(default, skip_serializing_if = "Option::is_none")]
1048 pub path_collection: Option<FilePathCollection>,
1049 #[serde(default, skip_serializing_if = "Option::is_none")]
1050 pub created_by: Option<UserMini>,
1051 #[serde(default, skip_serializing_if = "Option::is_none")]
1052 pub modified_by: Option<UserMini>,
1053 #[serde(
1054 default,
1055 skip_serializing_if = "Option::is_none",
1056 deserialize_with = "double_option"
1057 )]
1058 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1059 #[serde(
1060 default,
1061 skip_serializing_if = "Option::is_none",
1062 deserialize_with = "double_option"
1063 )]
1064 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1065 #[serde(
1066 default,
1067 skip_serializing_if = "Option::is_none",
1068 deserialize_with = "double_option"
1069 )]
1070 pub content_created_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1071 #[serde(
1072 default,
1073 skip_serializing_if = "Option::is_none",
1074 deserialize_with = "double_option"
1075 )]
1076 pub content_modified_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1077 #[serde(default, skip_serializing_if = "Option::is_none")]
1078 pub owned_by: Option<UserMini>,
1079 #[serde(
1080 default,
1081 skip_serializing_if = "Option::is_none",
1082 deserialize_with = "double_option"
1083 )]
1084 pub shared_link: Option<Option<FileSharedLink>>,
1085 #[serde(
1086 default,
1087 skip_serializing_if = "Option::is_none",
1088 deserialize_with = "double_option"
1089 )]
1090 pub folder_upload_email: Option<Option<FolderFolderUploadEmail>>,
1091 #[serde(
1092 default,
1093 skip_serializing_if = "Option::is_none",
1094 deserialize_with = "double_option"
1095 )]
1096 pub parent: Option<Option<FolderMini>>,
1097 #[serde(default, skip_serializing_if = "Option::is_none")]
1098 pub item_status: Option<FileItemStatus>,
1099 #[serde(default, skip_serializing_if = "Option::is_none")]
1100 pub item_collection: Option<Items>,
1101 #[serde(default, skip_serializing_if = "Option::is_none")]
1102 pub sync_state: Option<FolderFullSyncState>,
1103 #[serde(default, skip_serializing_if = "Option::is_none")]
1104 pub has_collaborations: Option<bool>,
1105 #[serde(default, skip_serializing_if = "Option::is_none")]
1106 pub permissions: Option<FolderFullPermissions>,
1107 #[serde(default, skip_serializing_if = "Option::is_none")]
1108 pub tags: Option<Vec<String>>,
1109 #[serde(default, skip_serializing_if = "Option::is_none")]
1110 pub can_non_owners_invite: Option<bool>,
1111 #[serde(default, skip_serializing_if = "Option::is_none")]
1112 pub is_externally_owned: Option<bool>,
1113 #[serde(default, skip_serializing_if = "Option::is_none")]
1114 pub metadata:
1115 Option<std::collections::HashMap<String, std::collections::HashMap<String, MetadataFull>>>,
1116 #[serde(default, skip_serializing_if = "Option::is_none")]
1117 pub is_collaboration_restricted_to_enterprise: Option<bool>,
1118 #[serde(default, skip_serializing_if = "Option::is_none")]
1119 pub allowed_shared_link_access_levels: Option<Vec<SharedLinkAccess>>,
1120 #[serde(default, skip_serializing_if = "Option::is_none")]
1121 pub allowed_invitee_roles: Option<Vec<FileFullAllowedInviteeRoles>>,
1122 #[serde(default, skip_serializing_if = "Option::is_none")]
1123 pub watermark_info: Option<FileFullWatermarkInfo>,
1124 #[serde(default, skip_serializing_if = "Option::is_none")]
1125 pub is_accessible_via_shared_link: Option<bool>,
1126 #[serde(default, skip_serializing_if = "Option::is_none")]
1127 pub can_non_owners_view_collaborators: Option<bool>,
1128 #[serde(
1129 default,
1130 skip_serializing_if = "Option::is_none",
1131 deserialize_with = "double_option"
1132 )]
1133 pub classification: Option<Option<FileFullClassification>>,
1134 #[serde(default, skip_serializing_if = "Option::is_none")]
1135 pub is_associated_with_app_item: Option<bool>,
1136 #[serde(default, skip_serializing_if = "Option::is_none")]
1137 pub collections: Option<Vec<Collection>>,
1138}
1139
1140#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1141pub struct FolderMini {
1142 pub id: String,
1143 #[serde(
1144 default,
1145 skip_serializing_if = "Option::is_none",
1146 deserialize_with = "double_option"
1147 )]
1148 pub etag: Option<Option<String>>,
1149 pub r#type: FolderType,
1150 #[serde(default, skip_serializing_if = "Option::is_none")]
1151 pub sequence_id: Option<String>,
1152 #[serde(default, skip_serializing_if = "Option::is_none")]
1153 pub name: Option<String>,
1154}
1155
1156#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1157pub struct FolderReference {
1158 pub r#type: FolderType,
1159 pub id: String,
1160}
1161
1162#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1163pub struct Group {
1164 pub id: String,
1165 pub r#type: GroupType,
1166 #[serde(default, skip_serializing_if = "Option::is_none")]
1167 pub name: Option<String>,
1168 #[serde(default, skip_serializing_if = "Option::is_none")]
1169 pub group_type: Option<GroupGroupType>,
1170 #[serde(default, skip_serializing_if = "Option::is_none")]
1171 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1172 #[serde(default, skip_serializing_if = "Option::is_none")]
1173 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
1174}
1175
1176#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1177pub struct GroupMini {
1178 pub id: String,
1179 pub r#type: GroupType,
1180 #[serde(default, skip_serializing_if = "Option::is_none")]
1181 pub name: Option<String>,
1182 #[serde(default, skip_serializing_if = "Option::is_none")]
1183 pub group_type: Option<GroupGroupType>,
1184}
1185
1186#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1187pub struct IntegrationMappingBase {
1188 pub id: String,
1189 pub r#type: IntegrationMappingType,
1190}
1191
1192#[derive(Clone, Debug, PartialEq)]
1193pub enum Item {
1194 File(FileFull),
1195 Folder(FolderMini),
1196 WebLink(WebLink),
1197 Unknown(serde_json::Value),
1199}
1200
1201impl Default for Item {
1202 fn default() -> Self {
1203 Self::Unknown(Default::default())
1204 }
1205}
1206
1207impl serde::Serialize for Item {
1208 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1209 match self {
1210 Self::File(inner) => inner.serialize(serializer),
1211 Self::Folder(inner) => inner.serialize(serializer),
1212 Self::WebLink(inner) => inner.serialize(serializer),
1213 Self::Unknown(inner) => inner.serialize(serializer),
1214 }
1215 }
1216}
1217
1218impl<'de> serde::Deserialize<'de> for Item {
1219 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1220 let value = serde_json::Value::deserialize(deserializer)?;
1221 let tag = value
1222 .get("type")
1223 .and_then(serde_json::Value::as_str)
1224 .map(str::to_owned);
1225 match tag.as_deref() {
1226 Some("file") => Ok(Self::File(
1227 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1228 )),
1229 Some("folder") => Ok(Self::Folder(
1230 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1231 )),
1232 Some("web_link") => Ok(Self::WebLink(
1233 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1234 )),
1235 _ => Ok(Self::Unknown(value)),
1236 }
1237 }
1238}
1239
1240#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1241pub struct Items {
1242 #[serde(default, skip_serializing_if = "Option::is_none")]
1243 pub limit: Option<i64>,
1244 #[serde(
1245 default,
1246 skip_serializing_if = "Option::is_none",
1247 deserialize_with = "double_option"
1248 )]
1249 pub next_marker: Option<Option<String>>,
1250 #[serde(
1251 default,
1252 skip_serializing_if = "Option::is_none",
1253 deserialize_with = "double_option"
1254 )]
1255 pub prev_marker: Option<Option<String>>,
1256 #[serde(default, skip_serializing_if = "Option::is_none")]
1257 pub total_count: Option<i64>,
1258 #[serde(default, skip_serializing_if = "Option::is_none")]
1259 pub offset: Option<i64>,
1260 #[serde(default, skip_serializing_if = "Option::is_none")]
1261 pub order: Option<Vec<CollectionsOrder>>,
1262 #[serde(default, skip_serializing_if = "Option::is_none")]
1263 pub entries: Option<Vec<Item>>,
1264}
1265
1266#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1267pub struct LegalHoldPolicyMini {
1268 pub id: String,
1269 pub r#type: LegalHoldPolicyType,
1270}
1271
1272#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1273pub struct LegalHoldPolicyAssignedItem {
1274 pub r#type: LegalHoldPolicyAssignedItemType,
1275 pub id: String,
1276}
1277
1278#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1279pub struct LegalHoldPolicyAssignment {
1280 #[serde(default, skip_serializing_if = "Option::is_none")]
1281 pub id: Option<String>,
1282 #[serde(default, skip_serializing_if = "Option::is_none")]
1283 pub r#type: Option<LegalHoldPolicyAssignmentType>,
1284 #[serde(default, skip_serializing_if = "Option::is_none")]
1285 pub legal_hold_policy: Option<LegalHoldPolicyMini>,
1286 #[serde(default, skip_serializing_if = "Option::is_none")]
1287 pub assigned_to: Option<LegalHoldPolicyAssignedItem>,
1288 #[serde(default, skip_serializing_if = "Option::is_none")]
1289 pub assigned_by: Option<UserMini>,
1290 #[serde(default, skip_serializing_if = "Option::is_none")]
1291 pub assigned_at: Option<chrono::DateTime<chrono::Utc>>,
1292 #[serde(default, skip_serializing_if = "Option::is_none")]
1293 pub deleted_at: Option<chrono::DateTime<chrono::Utc>>,
1294}
1295
1296#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1297pub struct LegalHoldPolicyAssignmentBase {
1298 #[serde(default, skip_serializing_if = "Option::is_none")]
1299 pub id: Option<String>,
1300 #[serde(default, skip_serializing_if = "Option::is_none")]
1301 pub r#type: Option<LegalHoldPolicyAssignmentType>,
1302}
1303
1304pub type Metadata = MetadataBase;
1305
1306#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1307pub struct MetadataBase {
1308 #[serde(rename = "$parent", default, skip_serializing_if = "Option::is_none")]
1309 pub parent: Option<String>,
1310 #[serde(rename = "$template", default, skip_serializing_if = "Option::is_none")]
1311 pub template: Option<String>,
1312 #[serde(rename = "$scope", default, skip_serializing_if = "Option::is_none")]
1313 pub scope: Option<String>,
1314 #[serde(rename = "$version", default, skip_serializing_if = "Option::is_none")]
1315 pub version: Option<i64>,
1316}
1317
1318#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1319pub struct MetadataFull {
1320 #[serde(rename = "$parent", default, skip_serializing_if = "Option::is_none")]
1321 pub parent: Option<String>,
1322 #[serde(rename = "$template", default, skip_serializing_if = "Option::is_none")]
1323 pub template: Option<String>,
1324 #[serde(rename = "$scope", default, skip_serializing_if = "Option::is_none")]
1325 pub scope: Option<String>,
1326 #[serde(rename = "$version", default, skip_serializing_if = "Option::is_none")]
1327 pub version: Option<i64>,
1328 #[serde(rename = "$canEdit", default, skip_serializing_if = "Option::is_none")]
1329 pub can_edit: Option<bool>,
1330 #[serde(rename = "$id", default, skip_serializing_if = "Option::is_none")]
1331 pub id: Option<String>,
1332 #[serde(rename = "$type", default, skip_serializing_if = "Option::is_none")]
1333 pub r#type: Option<String>,
1334 #[serde(
1335 rename = "$typeVersion",
1336 default,
1337 skip_serializing_if = "Option::is_none"
1338 )]
1339 pub type_version: Option<i64>,
1340}
1341
1342#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1343pub struct MetadataError {
1344 #[serde(default, skip_serializing_if = "Option::is_none")]
1345 pub code: Option<String>,
1346 #[serde(default, skip_serializing_if = "Option::is_none")]
1347 pub message: Option<String>,
1348 #[serde(default, skip_serializing_if = "Option::is_none")]
1349 pub request_id: Option<String>,
1350}
1351
1352#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1353#[serde(transparent)]
1354pub struct MetadataInstanceValue(pub serde_json::Value);
1355
1356#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1357pub struct Metadatas {
1358 #[serde(default, skip_serializing_if = "Option::is_none")]
1359 pub entries: Option<Vec<Metadata>>,
1360 #[serde(default, skip_serializing_if = "Option::is_none")]
1361 pub limit: Option<i64>,
1362}
1363
1364#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1365pub struct OAuth2Error {
1366 #[serde(default, skip_serializing_if = "Option::is_none")]
1367 pub error: Option<String>,
1368 #[serde(default, skip_serializing_if = "Option::is_none")]
1369 pub error_description: Option<String>,
1370}
1371
1372#[derive(Clone, Debug, PartialEq)]
1373pub enum Resource {
1374 Folder(FolderMini),
1375 File(FileMini),
1376 Unknown(serde_json::Value),
1378}
1379
1380impl Default for Resource {
1381 fn default() -> Self {
1382 Self::Unknown(Default::default())
1383 }
1384}
1385
1386impl serde::Serialize for Resource {
1387 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1388 match self {
1389 Self::Folder(inner) => inner.serialize(serializer),
1390 Self::File(inner) => inner.serialize(serializer),
1391 Self::Unknown(inner) => inner.serialize(serializer),
1392 }
1393 }
1394}
1395
1396impl<'de> serde::Deserialize<'de> for Resource {
1397 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1398 let value = serde_json::Value::deserialize(deserializer)?;
1399 let tag = value
1400 .get("type")
1401 .and_then(serde_json::Value::as_str)
1402 .map(str::to_owned);
1403 match tag.as_deref() {
1404 Some("folder") => Ok(Self::Folder(
1405 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1406 )),
1407 Some("file") => Ok(Self::File(
1408 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
1409 )),
1410 _ => Ok(Self::Unknown(value)),
1411 }
1412 }
1413}
1414
1415#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1416pub struct ResourceScope {
1417 #[serde(default, skip_serializing_if = "Option::is_none")]
1418 pub scope: Option<ResourceScopeScope>,
1419 #[serde(default, skip_serializing_if = "Option::is_none")]
1420 pub object: Option<Resource>,
1421}
1422
1423#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1424pub struct RetentionPolicyBase {
1425 pub id: String,
1426 pub r#type: RetentionPolicyType,
1427}
1428
1429#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1430pub struct RetentionPolicyMini {
1431 pub id: String,
1432 pub r#type: RetentionPolicyType,
1433 #[serde(default, skip_serializing_if = "Option::is_none")]
1434 pub policy_name: Option<String>,
1435 #[serde(default, skip_serializing_if = "Option::is_none")]
1436 pub retention_length: Option<String>,
1437 #[serde(default, skip_serializing_if = "Option::is_none")]
1438 pub disposition_action: Option<RetentionPolicyDispositionAction>,
1439 #[serde(default, skip_serializing_if = "Option::is_none")]
1440 pub max_extension_length: Option<RetentionPolicyMaxExtensionLengthResponse>,
1441}
1442
1443#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1444#[serde(transparent)]
1445pub struct RetentionPolicyMaxExtensionLengthResponse(pub serde_json::Value);
1446
1447#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1448pub struct ShieldInformationBarrierBase {
1449 #[serde(default, skip_serializing_if = "Option::is_none")]
1450 pub id: Option<String>,
1451 #[serde(default, skip_serializing_if = "Option::is_none")]
1452 pub r#type: Option<ShieldInformationBarrierType>,
1453}
1454
1455#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1456pub struct ShieldInformationBarrierReportBase {
1457 #[serde(default, skip_serializing_if = "Option::is_none")]
1458 pub id: Option<String>,
1459 #[serde(default, skip_serializing_if = "Option::is_none")]
1460 pub r#type: Option<ShieldInformationBarrierReportType>,
1461}
1462
1463#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1464pub struct ShieldInformationBarrierSegmentMemberBase {
1465 #[serde(default, skip_serializing_if = "Option::is_none")]
1466 pub id: Option<String>,
1467 #[serde(default, skip_serializing_if = "Option::is_none")]
1468 pub r#type: Option<ShieldInformationBarrierSegmentMemberType>,
1469}
1470
1471#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1472pub struct ShieldInformationBarrierSegmentMemberMini {
1473 #[serde(default, skip_serializing_if = "Option::is_none")]
1474 pub id: Option<String>,
1475 #[serde(default, skip_serializing_if = "Option::is_none")]
1476 pub r#type: Option<ShieldInformationBarrierSegmentMemberType>,
1477 #[serde(default, skip_serializing_if = "Option::is_none")]
1478 pub user: Option<UserBase>,
1479}
1480
1481#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1482pub struct ShieldInformationBarrierSegmentRestrictionBase {
1483 #[serde(default, skip_serializing_if = "Option::is_none")]
1484 pub r#type: Option<ShieldInformationBarrierSegmentRestrictionType>,
1485 #[serde(default, skip_serializing_if = "Option::is_none")]
1486 pub id: Option<String>,
1487}
1488
1489#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1490pub struct ShieldInformationBarrierSegmentRestrictionMini {
1491 #[serde(default, skip_serializing_if = "Option::is_none")]
1492 pub r#type: Option<ShieldInformationBarrierSegmentRestrictionType>,
1493 #[serde(default, skip_serializing_if = "Option::is_none")]
1494 pub id: Option<String>,
1495 pub shield_information_barrier_segment:
1496 ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment,
1497 pub restricted_segment: ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment,
1498}
1499
1500#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1501pub struct SignRequestBase {
1502 #[serde(default, skip_serializing_if = "Option::is_none")]
1503 pub is_document_preparation_needed: Option<bool>,
1504 #[serde(
1505 default,
1506 skip_serializing_if = "Option::is_none",
1507 deserialize_with = "double_option"
1508 )]
1509 pub redirect_url: Option<Option<String>>,
1510 #[serde(
1511 default,
1512 skip_serializing_if = "Option::is_none",
1513 deserialize_with = "double_option"
1514 )]
1515 pub declined_redirect_url: Option<Option<String>>,
1516 #[serde(default, skip_serializing_if = "Option::is_none")]
1517 pub are_text_signatures_enabled: Option<bool>,
1518 #[serde(
1519 default,
1520 skip_serializing_if = "Option::is_none",
1521 deserialize_with = "double_option"
1522 )]
1523 pub email_subject: Option<Option<String>>,
1524 #[serde(
1525 default,
1526 skip_serializing_if = "Option::is_none",
1527 deserialize_with = "double_option"
1528 )]
1529 pub email_message: Option<Option<String>>,
1530 #[serde(default, skip_serializing_if = "Option::is_none")]
1531 pub are_reminders_enabled: Option<bool>,
1532 #[serde(default, skip_serializing_if = "Option::is_none")]
1533 pub name: Option<String>,
1534 #[serde(default, skip_serializing_if = "Option::is_none")]
1535 pub prefill_tags: Option<Vec<SignRequestPrefillTag>>,
1536 #[serde(
1537 default,
1538 skip_serializing_if = "Option::is_none",
1539 deserialize_with = "double_option"
1540 )]
1541 pub days_valid: Option<Option<i64>>,
1542 #[serde(
1543 default,
1544 skip_serializing_if = "Option::is_none",
1545 deserialize_with = "double_option"
1546 )]
1547 pub external_id: Option<Option<String>>,
1548 #[serde(
1549 default,
1550 skip_serializing_if = "Option::is_none",
1551 deserialize_with = "double_option"
1552 )]
1553 pub template_id: Option<Option<String>>,
1554 #[serde(
1555 default,
1556 skip_serializing_if = "Option::is_none",
1557 deserialize_with = "double_option"
1558 )]
1559 pub external_system_name: Option<Option<String>>,
1560 #[serde(
1561 default,
1562 skip_serializing_if = "Option::is_none",
1563 deserialize_with = "double_option"
1564 )]
1565 pub request_flow: Option<Option<String>>,
1566}
1567
1568#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1569pub struct SignRequestSignerInputCustomValidation {
1570 pub validation_type: SignRequestSignerInputCustomValidationValidationType,
1571 pub custom_regex: Option<String>,
1572 pub custom_error_message: Option<String>,
1573}
1574
1575#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1576pub struct SignRequestSignerInputDateAsiaValidation {
1577 #[serde(default, skip_serializing_if = "Option::is_none")]
1578 pub validation_type: Option<SignRequestSignerInputDateAsiaValidationValidationType>,
1579}
1580
1581#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1582pub struct SignRequestSignerInputDateEUValidation {
1583 #[serde(default, skip_serializing_if = "Option::is_none")]
1584 pub validation_type: Option<SignRequestSignerInputDateEUValidationValidationType>,
1585}
1586
1587#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1588pub struct SignRequestSignerInputDateISOValidation {
1589 #[serde(default, skip_serializing_if = "Option::is_none")]
1590 pub validation_type: Option<SignRequestSignerInputDateISOValidationValidationType>,
1591}
1592
1593#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1594pub struct SignRequestSignerInputDateUSValidation {
1595 #[serde(default, skip_serializing_if = "Option::is_none")]
1596 pub validation_type: Option<SignRequestSignerInputDateUSValidationValidationType>,
1597}
1598
1599#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1600pub struct SignRequestSignerInputEmailValidation {
1601 pub validation_type: SignRequestSignerInputEmailValidationValidationType,
1602}
1603
1604#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1605pub struct SignRequestSignerInputNumberWithCommaValidation {
1606 #[serde(default, skip_serializing_if = "Option::is_none")]
1607 pub validation_type: Option<SignRequestSignerInputNumberWithCommaValidationValidationType>,
1608}
1609
1610#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1611pub struct SignRequestSignerInputNumberWithPeriodValidation {
1612 #[serde(default, skip_serializing_if = "Option::is_none")]
1613 pub validation_type: Option<SignRequestSignerInputNumberWithPeriodValidationValidationType>,
1614}
1615
1616#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1617pub struct SignRequestSignerInputSSNValidation {
1618 pub validation_type: SignRequestSignerInputSSNValidationValidationType,
1619}
1620
1621#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1622#[serde(transparent)]
1623pub struct SignRequestSignerInputValidation(pub serde_json::Value);
1624
1625#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1626pub struct SignRequestSignerInputZIP4Validation {
1627 pub validation_type: SignRequestSignerInputZIP4ValidationValidationType,
1628}
1629
1630#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1631pub struct SignRequestSignerInputZIPValidation {
1632 pub validation_type: SignRequestSignerInputZIPValidationValidationType,
1633}
1634
1635#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1636pub struct TaskAssignment {
1637 #[serde(default, skip_serializing_if = "Option::is_none")]
1638 pub id: Option<String>,
1639 #[serde(default, skip_serializing_if = "Option::is_none")]
1640 pub r#type: Option<TaskAssignmentType>,
1641 #[serde(default, skip_serializing_if = "Option::is_none")]
1642 pub item: Option<FileMini>,
1643 #[serde(default, skip_serializing_if = "Option::is_none")]
1644 pub assigned_to: Option<UserMini>,
1645 #[serde(default, skip_serializing_if = "Option::is_none")]
1646 pub message: Option<String>,
1647 #[serde(default, skip_serializing_if = "Option::is_none")]
1648 pub completed_at: Option<chrono::DateTime<chrono::Utc>>,
1649 #[serde(default, skip_serializing_if = "Option::is_none")]
1650 pub assigned_at: Option<chrono::DateTime<chrono::Utc>>,
1651 #[serde(default, skip_serializing_if = "Option::is_none")]
1652 pub reminded_at: Option<chrono::DateTime<chrono::Utc>>,
1653 #[serde(default, skip_serializing_if = "Option::is_none")]
1654 pub resolution_state: Option<TaskAssignmentResolutionState>,
1655 #[serde(default, skip_serializing_if = "Option::is_none")]
1656 pub assigned_by: Option<UserMini>,
1657}
1658
1659#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1660pub struct TaskAssignments {
1661 #[serde(default, skip_serializing_if = "Option::is_none")]
1662 pub total_count: Option<i64>,
1663 #[serde(default, skip_serializing_if = "Option::is_none")]
1664 pub entries: Option<Vec<TaskAssignment>>,
1665}
1666
1667#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1668pub struct TermsOfServiceBase {
1669 pub id: String,
1670 pub r#type: TermsOfServiceType,
1671}
1672
1673#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1674pub struct UploadPartMini {
1675 #[serde(default, skip_serializing_if = "Option::is_none")]
1676 pub part_id: Option<String>,
1677 #[serde(default, skip_serializing_if = "Option::is_none")]
1678 pub offset: Option<i64>,
1679 #[serde(default, skip_serializing_if = "Option::is_none")]
1680 pub size: Option<i64>,
1681}
1682
1683#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1684pub struct UserBase {
1685 pub id: String,
1686 pub r#type: VariableValueType,
1687}
1688
1689#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1690pub struct UserCollaborations {
1691 pub id: String,
1692 pub r#type: VariableValueType,
1693 #[serde(default, skip_serializing_if = "Option::is_none")]
1694 pub name: Option<String>,
1695 #[serde(default, skip_serializing_if = "Option::is_none")]
1696 pub login: Option<String>,
1697 #[serde(default, skip_serializing_if = "Option::is_none")]
1698 pub is_active: Option<bool>,
1699}
1700
1701#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1702pub struct UserMini {
1703 pub id: String,
1704 pub r#type: VariableValueType,
1705 #[serde(default, skip_serializing_if = "Option::is_none")]
1706 pub name: Option<String>,
1707 #[serde(default, skip_serializing_if = "Option::is_none")]
1708 pub login: Option<String>,
1709}
1710
1711#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1712pub struct Watermark {
1713 #[serde(default, skip_serializing_if = "Option::is_none")]
1714 pub watermark: Option<WatermarkWatermark>,
1715}
1716
1717#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1718pub struct WebLink {
1719 pub id: String,
1720 pub r#type: TrashWebLinkType,
1721 #[serde(default, skip_serializing_if = "Option::is_none")]
1722 pub etag: Option<String>,
1723 #[serde(default, skip_serializing_if = "Option::is_none")]
1724 pub url: Option<String>,
1725 #[serde(default, skip_serializing_if = "Option::is_none")]
1726 pub sequence_id: Option<String>,
1727 #[serde(default, skip_serializing_if = "Option::is_none")]
1728 pub name: Option<String>,
1729 #[serde(default, skip_serializing_if = "Option::is_none")]
1730 pub parent: Option<FolderMini>,
1731 #[serde(default, skip_serializing_if = "Option::is_none")]
1732 pub description: Option<String>,
1733 #[serde(default, skip_serializing_if = "Option::is_none")]
1734 pub path_collection: Option<FilePathCollection>,
1735 #[serde(default, skip_serializing_if = "Option::is_none")]
1736 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1737 #[serde(default, skip_serializing_if = "Option::is_none")]
1738 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
1739 #[serde(
1740 default,
1741 skip_serializing_if = "Option::is_none",
1742 deserialize_with = "double_option"
1743 )]
1744 pub trashed_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1745 #[serde(
1746 default,
1747 skip_serializing_if = "Option::is_none",
1748 deserialize_with = "double_option"
1749 )]
1750 pub purged_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
1751 #[serde(default, skip_serializing_if = "Option::is_none")]
1752 pub created_by: Option<UserMini>,
1753 #[serde(default, skip_serializing_if = "Option::is_none")]
1754 pub modified_by: Option<UserMini>,
1755 #[serde(default, skip_serializing_if = "Option::is_none")]
1756 pub owned_by: Option<UserMini>,
1757 #[serde(
1758 default,
1759 skip_serializing_if = "Option::is_none",
1760 deserialize_with = "double_option"
1761 )]
1762 pub shared_link: Option<Option<FileSharedLink>>,
1763 #[serde(default, skip_serializing_if = "Option::is_none")]
1764 pub item_status: Option<FileItemStatus>,
1765 #[serde(default, skip_serializing_if = "Option::is_none")]
1766 pub collections: Option<Vec<Collection>>,
1767 #[serde(default, skip_serializing_if = "Option::is_none")]
1768 pub allowed_shared_link_access_levels: Option<Vec<SharedLinkAccess>>,
1769}
1770
1771#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1772pub struct WebLinkMini {
1773 pub id: String,
1774 pub r#type: TrashWebLinkType,
1775 #[serde(default, skip_serializing_if = "Option::is_none")]
1776 pub etag: Option<String>,
1777 #[serde(default, skip_serializing_if = "Option::is_none")]
1778 pub url: Option<String>,
1779 #[serde(default, skip_serializing_if = "Option::is_none")]
1780 pub sequence_id: Option<String>,
1781 #[serde(default, skip_serializing_if = "Option::is_none")]
1782 pub name: Option<String>,
1783}
1784
1785#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1786pub struct WorkflowMini {
1787 #[serde(default, skip_serializing_if = "Option::is_none")]
1788 pub id: Option<String>,
1789 #[serde(default, skip_serializing_if = "Option::is_none")]
1790 pub r#type: Option<WorkflowType>,
1791 #[serde(default, skip_serializing_if = "Option::is_none")]
1792 pub name: Option<String>,
1793 #[serde(default, skip_serializing_if = "Option::is_none")]
1794 pub description: Option<String>,
1795 #[serde(default, skip_serializing_if = "Option::is_none")]
1796 pub is_enabled: Option<bool>,
1797}
1798
1799#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
1800#[serde(transparent)]
1801pub struct AccessTokenTokenType(pub String);
1802
1803impl AccessTokenTokenType {
1804 pub const BEARER: &'static str = "bearer";
1805}
1806
1807#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
1808#[serde(transparent)]
1809pub struct AiAgentAskType(pub String);
1810
1811impl AiAgentAskType {
1812 pub const AI_AGENT_ASK: &'static str = "ai_agent_ask";
1813}
1814
1815#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1816pub struct EmbeddingsStrategy {
1817 #[serde(default, skip_serializing_if = "Option::is_none")]
1818 pub id: Option<String>,
1819 #[serde(default, skip_serializing_if = "Option::is_none")]
1820 pub num_tokens_per_chunk: Option<i64>,
1821}
1822
1823#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1824pub struct AiAgentBasicGenToolEmbeddings {
1825 #[serde(default, skip_serializing_if = "Option::is_none")]
1826 pub model: Option<String>,
1827 #[serde(default, skip_serializing_if = "Option::is_none")]
1828 pub strategy: Option<EmbeddingsStrategy>,
1829}
1830
1831#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
1832#[serde(transparent)]
1833pub struct AiAgentExtractType(pub String);
1834
1835impl AiAgentExtractType {
1836 pub const AI_AGENT_EXTRACT: &'static str = "ai_agent_extract";
1837}
1838
1839#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
1840#[serde(transparent)]
1841pub struct AiAgentTextGenType(pub String);
1842
1843impl AiAgentTextGenType {
1844 pub const AI_AGENT_TEXT_GEN: &'static str = "ai_agent_text_gen";
1845}
1846
1847#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
1848#[serde(transparent)]
1849pub struct AiCitationType(pub String);
1850
1851impl AiCitationType {
1852 pub const FILE: &'static str = "file";
1853}
1854
1855#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
1856#[serde(transparent)]
1857pub struct MetadataTemplateType(pub String);
1858
1859impl MetadataTemplateType {
1860 pub const METADATA_TEMPLATE: &'static str = "metadata_template";
1861}
1862
1863#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1864pub struct FieldsOptions {
1865 pub key: String,
1866}
1867
1868#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
1869#[serde(transparent)]
1870pub struct AiLlmEndpointParamsAWSType(pub String);
1871
1872impl AiLlmEndpointParamsAWSType {
1873 pub const AWS_PARAMS: &'static str = "aws_params";
1874}
1875
1876#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
1877#[serde(transparent)]
1878pub struct AiLlmEndpointParamsGoogleType(pub String);
1879
1880impl AiLlmEndpointParamsGoogleType {
1881 pub const GOOGLE_PARAMS: &'static str = "google_params";
1882}
1883
1884#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
1885#[serde(transparent)]
1886pub struct AiLlmEndpointParamsIBMType(pub String);
1887
1888impl AiLlmEndpointParamsIBMType {
1889 pub const IBM_PARAMS: &'static str = "ibm_params";
1890}
1891
1892#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
1893#[serde(transparent)]
1894pub struct AiLlmEndpointParamsOpenAiType(pub String);
1895
1896impl AiLlmEndpointParamsOpenAiType {
1897 pub const OPENAI_PARAMS: &'static str = "openai_params";
1898}
1899
1900#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
1901#[serde(transparent)]
1902pub struct AppItemType(pub String);
1903
1904impl AppItemType {
1905 pub const APP_ITEM: &'static str = "app_item";
1906}
1907
1908#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
1909#[serde(transparent)]
1910pub struct ClassificationTemplate2(pub String);
1911
1912impl ClassificationTemplate2 {
1913 pub const SECURITYCLASSIFICATION_6VMVOCHWUWO: &'static str =
1914 "securityClassification-6VMVochwUWo";
1915}
1916
1917#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
1918#[serde(transparent)]
1919pub struct ClientErrorType(pub String);
1920
1921impl ClientErrorType {
1922 pub const ERROR: &'static str = "error";
1923}
1924
1925#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
1926#[serde(transparent)]
1927pub struct ClientErrorCode(pub String);
1928
1929impl ClientErrorCode {
1930 pub const CREATED: &'static str = "created";
1931 pub const ACCEPTED: &'static str = "accepted";
1932 pub const NO_CONTENT: &'static str = "no_content";
1933 pub const REDIRECT: &'static str = "redirect";
1934 pub const NOT_MODIFIED: &'static str = "not_modified";
1935 pub const BAD_REQUEST: &'static str = "bad_request";
1936 pub const UNAUTHORIZED: &'static str = "unauthorized";
1937 pub const FORBIDDEN: &'static str = "forbidden";
1938 pub const NOT_FOUND: &'static str = "not_found";
1939 pub const METHOD_NOT_ALLOWED: &'static str = "method_not_allowed";
1940 pub const CONFLICT: &'static str = "conflict";
1941 pub const PRECONDITION_FAILED: &'static str = "precondition_failed";
1942 pub const TOO_MANY_REQUESTS: &'static str = "too_many_requests";
1943 pub const INTERNAL_SERVER_ERROR: &'static str = "internal_server_error";
1944 pub const UNAVAILABLE: &'static str = "unavailable";
1945 pub const ITEM_NAME_INVALID: &'static str = "item_name_invalid";
1946 pub const INSUFFICIENT_SCOPE: &'static str = "insufficient_scope";
1947}
1948
1949#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
1950#[serde(transparent)]
1951pub struct CollaborationType(pub String);
1952
1953impl CollaborationType {
1954 pub const COLLABORATION: &'static str = "collaboration";
1955}
1956
1957#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
1958#[serde(transparent)]
1959pub struct CollaborationRole(pub String);
1960
1961impl CollaborationRole {
1962 pub const EDITOR: &'static str = "editor";
1963 pub const VIEWER: &'static str = "viewer";
1964 pub const PREVIEWER: &'static str = "previewer";
1965 pub const UPLOADER: &'static str = "uploader";
1966 pub const PREVIEWER_UPLOADER: &'static str = "previewer uploader";
1967 pub const VIEWER_UPLOADER: &'static str = "viewer uploader";
1968 pub const CO_OWNER: &'static str = "co-owner";
1969 pub const OWNER: &'static str = "owner";
1970}
1971
1972#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
1973#[serde(transparent)]
1974pub struct CollaborationStatus(pub String);
1975
1976impl CollaborationStatus {
1977 pub const ACCEPTED: &'static str = "accepted";
1978 pub const PENDING: &'static str = "pending";
1979 pub const REJECTED: &'static str = "rejected";
1980}
1981
1982#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1983pub struct AcceptanceRequirementsStatusTermsOfServiceRequirement {
1984 #[serde(
1985 default,
1986 skip_serializing_if = "Option::is_none",
1987 deserialize_with = "double_option"
1988 )]
1989 pub is_accepted: Option<Option<bool>>,
1990 #[serde(default, skip_serializing_if = "Option::is_none")]
1991 pub terms_of_service: Option<TermsOfServiceBase>,
1992}
1993
1994#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
1995pub struct AcceptanceRequirementsStatusStrongPasswordRequirement {
1996 #[serde(default, skip_serializing_if = "Option::is_none")]
1997 pub enterprise_has_strong_password_required_for_external_users: Option<bool>,
1998 #[serde(
1999 default,
2000 skip_serializing_if = "Option::is_none",
2001 deserialize_with = "double_option"
2002 )]
2003 pub user_has_strong_password: Option<Option<bool>>,
2004}
2005
2006#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2007pub struct AcceptanceRequirementsStatusTwoFactorAuthenticationRequirement {
2008 #[serde(default, skip_serializing_if = "Option::is_none")]
2009 pub enterprise_has_two_factor_auth_enabled: Option<bool>,
2010 #[serde(
2011 default,
2012 skip_serializing_if = "Option::is_none",
2013 deserialize_with = "double_option"
2014 )]
2015 pub user_has_two_factor_authentication_enabled: Option<Option<bool>>,
2016}
2017
2018#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2019pub struct CollaborationAcceptanceRequirementsStatus {
2020 #[serde(default, skip_serializing_if = "Option::is_none")]
2021 pub terms_of_service_requirement: Option<AcceptanceRequirementsStatusTermsOfServiceRequirement>,
2022 #[serde(default, skip_serializing_if = "Option::is_none")]
2023 pub strong_password_requirement: Option<AcceptanceRequirementsStatusStrongPasswordRequirement>,
2024 #[serde(default, skip_serializing_if = "Option::is_none")]
2025 pub two_factor_authentication_requirement:
2026 Option<AcceptanceRequirementsStatusTwoFactorAuthenticationRequirement>,
2027}
2028
2029#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2030#[serde(transparent)]
2031pub struct EnterpriseType(pub String);
2032
2033impl EnterpriseType {
2034 pub const ENTERPRISE: &'static str = "enterprise";
2035}
2036
2037#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2038pub struct CollaborationAllowlistEntryEnterprise {
2039 #[serde(default, skip_serializing_if = "Option::is_none")]
2040 pub id: Option<String>,
2041 #[serde(default, skip_serializing_if = "Option::is_none")]
2042 pub r#type: Option<EnterpriseType>,
2043 #[serde(default, skip_serializing_if = "Option::is_none")]
2044 pub name: Option<String>,
2045}
2046
2047#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2048#[serde(transparent)]
2049pub struct VariableValueType(pub String);
2050
2051impl VariableValueType {
2052 pub const USER: &'static str = "user";
2053}
2054
2055#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2056pub struct CollaboratorVariableVariableValue {
2057 pub r#type: VariableValueType,
2058 pub id: String,
2059}
2060
2061#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2062#[serde(transparent)]
2063pub struct CollectionType(pub String);
2064
2065impl CollectionType {
2066 pub const COLLECTION: &'static str = "collection";
2067}
2068
2069#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2070#[serde(transparent)]
2071pub struct CollectionName(pub String);
2072
2073impl CollectionName {
2074 pub const FAVORITES: &'static str = "Favorites";
2075}
2076
2077#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2078#[serde(transparent)]
2079pub struct CollectionCollectionType(pub String);
2080
2081impl CollectionCollectionType {
2082 pub const FAVORITES: &'static str = "favorites";
2083}
2084
2085#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2086#[serde(transparent)]
2087pub struct OrderDirection(pub String);
2088
2089impl OrderDirection {
2090 pub const ASC: &'static str = "ASC";
2091 pub const DESC: &'static str = "DESC";
2092}
2093
2094#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2095pub struct CollectionsOrder {
2096 #[serde(default, skip_serializing_if = "Option::is_none")]
2097 pub by: Option<String>,
2098 #[serde(default, skip_serializing_if = "Option::is_none")]
2099 pub direction: Option<OrderDirection>,
2100}
2101
2102#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2103pub struct CommentItem {
2104 #[serde(default, skip_serializing_if = "Option::is_none")]
2105 pub id: Option<String>,
2106 #[serde(default, skip_serializing_if = "Option::is_none")]
2107 pub r#type: Option<String>,
2108}
2109
2110#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2111pub struct ConflictErrorContextInfo {
2112 #[serde(default, skip_serializing_if = "Option::is_none")]
2113 pub conflicts: Option<Vec<FileConflict>>,
2114}
2115
2116#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2117#[serde(transparent)]
2118pub struct EventSourceItemType(pub String);
2119
2120impl EventSourceItemType {
2121 pub const FILE: &'static str = "file";
2122 pub const FOLDER: &'static str = "folder";
2123}
2124
2125#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2126pub struct FilePathCollection {
2127 pub total_count: i64,
2128 pub entries: Vec<FolderMini>,
2129}
2130
2131#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2132#[serde(transparent)]
2133pub struct SharedLinkAccess(pub String);
2134
2135impl SharedLinkAccess {
2136 pub const OPEN: &'static str = "open";
2137 pub const COMPANY: &'static str = "company";
2138 pub const COLLABORATORS: &'static str = "collaborators";
2139}
2140
2141#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2142#[serde(transparent)]
2143pub struct SharedLinkEffectivePermission(pub String);
2144
2145impl SharedLinkEffectivePermission {
2146 pub const CAN_EDIT: &'static str = "can_edit";
2147 pub const CAN_DOWNLOAD: &'static str = "can_download";
2148 pub const CAN_PREVIEW: &'static str = "can_preview";
2149 pub const NO_ACCESS: &'static str = "no_access";
2150}
2151
2152#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2153pub struct SharedLinkPermissions {
2154 #[serde(default, skip_serializing_if = "Option::is_none")]
2155 pub can_download: Option<bool>,
2156 #[serde(default, skip_serializing_if = "Option::is_none")]
2157 pub can_preview: Option<bool>,
2158 #[serde(default, skip_serializing_if = "Option::is_none")]
2159 pub can_edit: Option<bool>,
2160 #[serde(
2161 default,
2162 skip_serializing_if = "Option::is_none",
2163 deserialize_with = "double_option"
2164 )]
2165 pub shared_links_option: Option<Option<String>>,
2166 #[serde(
2167 default,
2168 skip_serializing_if = "Option::is_none",
2169 deserialize_with = "double_option"
2170 )]
2171 pub default_shared_link_type: Option<Option<String>>,
2172 #[serde(
2173 default,
2174 skip_serializing_if = "Option::is_none",
2175 deserialize_with = "double_option"
2176 )]
2177 pub notes_shared_link_option: Option<Option<String>>,
2178 #[serde(
2179 default,
2180 skip_serializing_if = "Option::is_none",
2181 deserialize_with = "double_option"
2182 )]
2183 pub default_notes_shared_link_type: Option<Option<String>>,
2184}
2185
2186#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2187pub struct FileSharedLink {
2188 pub url: String,
2189 #[serde(
2190 default,
2191 skip_serializing_if = "Option::is_none",
2192 deserialize_with = "double_option"
2193 )]
2194 pub download_url: Option<Option<String>>,
2195 #[serde(
2196 default,
2197 skip_serializing_if = "Option::is_none",
2198 deserialize_with = "double_option"
2199 )]
2200 pub vanity_url: Option<Option<String>>,
2201 #[serde(
2202 default,
2203 skip_serializing_if = "Option::is_none",
2204 deserialize_with = "double_option"
2205 )]
2206 pub vanity_name: Option<Option<String>>,
2207 #[serde(default, skip_serializing_if = "Option::is_none")]
2208 pub access: Option<SharedLinkAccess>,
2209 pub effective_access: SharedLinkAccess,
2210 pub effective_permission: SharedLinkEffectivePermission,
2211 #[serde(
2212 default,
2213 skip_serializing_if = "Option::is_none",
2214 deserialize_with = "double_option"
2215 )]
2216 pub unshared_at: Option<Option<chrono::DateTime<chrono::Utc>>>,
2217 pub is_password_enabled: bool,
2218 #[serde(default, skip_serializing_if = "Option::is_none")]
2219 pub permissions: Option<SharedLinkPermissions>,
2220 pub download_count: i64,
2221 pub preview_count: i64,
2222}
2223
2224#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2225#[serde(transparent)]
2226pub struct FileItemStatus(pub String);
2227
2228impl FileItemStatus {
2229 pub const ACTIVE: &'static str = "active";
2230 pub const TRASHED: &'static str = "trashed";
2231 pub const DELETED: &'static str = "deleted";
2232}
2233
2234#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2235pub struct FileFullPermissions {
2236 pub can_delete: bool,
2237 pub can_download: bool,
2238 pub can_invite_collaborator: bool,
2239 pub can_rename: bool,
2240 pub can_set_share_access: bool,
2241 pub can_share: bool,
2242 pub can_annotate: bool,
2243 pub can_comment: bool,
2244 pub can_preview: bool,
2245 pub can_upload: bool,
2246 pub can_view_annotations_all: bool,
2247 pub can_view_annotations_self: bool,
2248 #[serde(default, skip_serializing_if = "Option::is_none")]
2249 pub can_apply_watermark: Option<bool>,
2250}
2251
2252#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2253#[serde(transparent)]
2254pub struct LockType(pub String);
2255
2256impl LockType {
2257 pub const LOCK: &'static str = "lock";
2258}
2259
2260#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2261#[serde(transparent)]
2262pub struct LockAppType(pub String);
2263
2264impl LockAppType {
2265 pub const GSUITE: &'static str = "gsuite";
2266 pub const OFFICE_WOPI: &'static str = "office_wopi";
2267 pub const OFFICE_WOPIPLUS: &'static str = "office_wopiplus";
2268 pub const OTHER: &'static str = "other";
2269}
2270
2271#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2272pub struct FileFullLock {
2273 #[serde(default, skip_serializing_if = "Option::is_none")]
2274 pub id: Option<String>,
2275 #[serde(default, skip_serializing_if = "Option::is_none")]
2276 pub r#type: Option<LockType>,
2277 #[serde(default, skip_serializing_if = "Option::is_none")]
2278 pub created_by: Option<UserMini>,
2279 #[serde(default, skip_serializing_if = "Option::is_none")]
2280 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2281 #[serde(default, skip_serializing_if = "Option::is_none")]
2282 pub expired_at: Option<chrono::DateTime<chrono::Utc>>,
2283 #[serde(default, skip_serializing_if = "Option::is_none")]
2284 pub is_download_prevented: Option<bool>,
2285 #[serde(
2286 default,
2287 skip_serializing_if = "Option::is_none",
2288 deserialize_with = "double_option"
2289 )]
2290 pub app_type: Option<Option<LockAppType>>,
2291}
2292
2293#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2294pub struct FileFullExpiringEmbedLink {
2295 #[serde(default, skip_serializing_if = "Option::is_none")]
2296 pub access_token: Option<String>,
2297 #[serde(default, skip_serializing_if = "Option::is_none")]
2298 pub expires_in: Option<i64>,
2299 #[serde(default, skip_serializing_if = "Option::is_none")]
2300 pub token_type: Option<AccessTokenTokenType>,
2301 #[serde(default, skip_serializing_if = "Option::is_none")]
2302 pub restricted_to: Option<Vec<ResourceScope>>,
2303 #[serde(default, skip_serializing_if = "Option::is_none")]
2304 pub url: Option<String>,
2305}
2306
2307#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2308pub struct FileFullWatermarkInfo {
2309 #[serde(default, skip_serializing_if = "Option::is_none")]
2310 pub is_watermarked: Option<bool>,
2311 #[serde(default, skip_serializing_if = "Option::is_none")]
2312 pub is_watermark_inherited: Option<bool>,
2313 #[serde(default, skip_serializing_if = "Option::is_none")]
2314 pub is_watermarked_by_access_policy: Option<bool>,
2315}
2316
2317#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2318#[serde(transparent)]
2319pub struct FileFullAllowedInviteeRoles(pub String);
2320
2321impl FileFullAllowedInviteeRoles {
2322 pub const EDITOR: &'static str = "editor";
2323 pub const VIEWER: &'static str = "viewer";
2324 pub const PREVIEWER: &'static str = "previewer";
2325 pub const UPLOADER: &'static str = "uploader";
2326 pub const PREVIEWER_UPLOADER: &'static str = "previewer uploader";
2327 pub const VIEWER_UPLOADER: &'static str = "viewer uploader";
2328 pub const CO_OWNER: &'static str = "co-owner";
2329}
2330
2331#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2332pub struct EntriesContent {
2333 #[serde(default, skip_serializing_if = "Option::is_none")]
2334 pub url_template: Option<String>,
2335}
2336
2337#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2338pub struct EntriesInfo {
2339 #[serde(default, skip_serializing_if = "Option::is_none")]
2340 pub url: Option<String>,
2341}
2342
2343#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2344pub struct EntriesProperties {
2345 #[serde(default, skip_serializing_if = "Option::is_none")]
2346 pub dimensions: Option<String>,
2347 #[serde(default, skip_serializing_if = "Option::is_none")]
2348 pub paged: Option<String>,
2349 #[serde(default, skip_serializing_if = "Option::is_none")]
2350 pub thumb: Option<String>,
2351}
2352
2353#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2354#[serde(transparent)]
2355pub struct StatusState(pub String);
2356
2357impl StatusState {
2358 pub const SUCCESS: &'static str = "success";
2359 pub const VIEWABLE: &'static str = "viewable";
2360 pub const PENDING: &'static str = "pending";
2361 pub const NONE: &'static str = "none";
2362}
2363
2364#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2365pub struct EntriesStatus {
2366 #[serde(default, skip_serializing_if = "Option::is_none")]
2367 pub state: Option<StatusState>,
2368}
2369
2370#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2371pub struct RepresentationsEntries {
2372 #[serde(default, skip_serializing_if = "Option::is_none")]
2373 pub content: Option<EntriesContent>,
2374 #[serde(default, skip_serializing_if = "Option::is_none")]
2375 pub info: Option<EntriesInfo>,
2376 #[serde(default, skip_serializing_if = "Option::is_none")]
2377 pub properties: Option<EntriesProperties>,
2378 #[serde(default, skip_serializing_if = "Option::is_none")]
2379 pub representation: Option<String>,
2380 #[serde(default, skip_serializing_if = "Option::is_none")]
2381 pub status: Option<EntriesStatus>,
2382}
2383
2384#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2385pub struct FileFullRepresentations {
2386 #[serde(default, skip_serializing_if = "Option::is_none")]
2387 pub entries: Option<Vec<RepresentationsEntries>>,
2388}
2389
2390#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2391pub struct FileFullClassification {
2392 #[serde(default, skip_serializing_if = "Option::is_none")]
2393 pub name: Option<String>,
2394 #[serde(default, skip_serializing_if = "Option::is_none")]
2395 pub definition: Option<String>,
2396 #[serde(default, skip_serializing_if = "Option::is_none")]
2397 pub color: Option<String>,
2398}
2399
2400#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2401#[serde(transparent)]
2402pub struct FileFullSharedLinkPermissionOptions(pub String);
2403
2404impl FileFullSharedLinkPermissionOptions {
2405 pub const CAN_PREVIEW: &'static str = "can_preview";
2406 pub const CAN_DOWNLOAD: &'static str = "can_download";
2407 pub const CAN_EDIT: &'static str = "can_edit";
2408}
2409
2410#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2411#[serde(transparent)]
2412pub struct FolderType(pub String);
2413
2414impl FolderType {
2415 pub const FOLDER: &'static str = "folder";
2416}
2417
2418#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2419#[serde(transparent)]
2420pub struct FileVersionType(pub String);
2421
2422impl FileVersionType {
2423 pub const FILE_VERSION: &'static str = "file_version";
2424}
2425
2426#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2427#[serde(transparent)]
2428pub struct FolderUploadEmailAccess(pub String);
2429
2430impl FolderUploadEmailAccess {
2431 pub const OPEN: &'static str = "open";
2432 pub const COLLABORATORS: &'static str = "collaborators";
2433}
2434
2435#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2436pub struct FolderFolderUploadEmail {
2437 #[serde(default, skip_serializing_if = "Option::is_none")]
2438 pub access: Option<FolderUploadEmailAccess>,
2439 #[serde(default, skip_serializing_if = "Option::is_none")]
2440 pub email: Option<String>,
2441}
2442
2443#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2444#[serde(transparent)]
2445pub struct FolderFullSyncState(pub String);
2446
2447impl FolderFullSyncState {
2448 pub const SYNCED: &'static str = "synced";
2449 pub const NOT_SYNCED: &'static str = "not_synced";
2450 pub const PARTIALLY_SYNCED: &'static str = "partially_synced";
2451}
2452
2453#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2454pub struct FolderFullPermissions {
2455 pub can_delete: bool,
2456 pub can_download: bool,
2457 pub can_invite_collaborator: bool,
2458 pub can_rename: bool,
2459 pub can_set_share_access: bool,
2460 pub can_share: bool,
2461 pub can_upload: bool,
2462 #[serde(default, skip_serializing_if = "Option::is_none")]
2463 pub can_apply_watermark: Option<bool>,
2464}
2465
2466#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2467#[serde(transparent)]
2468pub struct GroupType(pub String);
2469
2470impl GroupType {
2471 pub const GROUP: &'static str = "group";
2472}
2473
2474#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2475#[serde(transparent)]
2476pub struct GroupGroupType(pub String);
2477
2478impl GroupGroupType {
2479 pub const MANAGED_GROUP: &'static str = "managed_group";
2480 pub const ALL_USERS_GROUP: &'static str = "all_users_group";
2481}
2482
2483#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2484#[serde(transparent)]
2485pub struct LegalHoldPolicyType(pub String);
2486
2487impl LegalHoldPolicyType {
2488 pub const LEGAL_HOLD_POLICY: &'static str = "legal_hold_policy";
2489}
2490
2491#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2492#[serde(transparent)]
2493pub struct LegalHoldPolicyAssignedItemType(pub String);
2494
2495impl LegalHoldPolicyAssignedItemType {
2496 pub const FILE: &'static str = "file";
2497 pub const FILE_VERSION: &'static str = "file_version";
2498 pub const FOLDER: &'static str = "folder";
2499 pub const USER: &'static str = "user";
2500 pub const OWNERSHIP: &'static str = "ownership";
2501 pub const INTERACTIONS: &'static str = "interactions";
2502}
2503
2504#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2505#[serde(transparent)]
2506pub struct LegalHoldPolicyAssignmentType(pub String);
2507
2508impl LegalHoldPolicyAssignmentType {
2509 pub const LEGAL_HOLD_POLICY_ASSIGNMENT: &'static str = "legal_hold_policy_assignment";
2510}
2511
2512#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2513pub struct MetadataCascadePolicyParent {
2514 #[serde(default, skip_serializing_if = "Option::is_none")]
2515 pub r#type: Option<FolderType>,
2516 #[serde(default, skip_serializing_if = "Option::is_none")]
2517 pub id: Option<String>,
2518}
2519
2520#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2521#[serde(transparent)]
2522pub struct ResourceScopeScope(pub String);
2523
2524impl ResourceScopeScope {
2525 pub const ANNOTATION_EDIT: &'static str = "annotation_edit";
2526 pub const ANNOTATION_VIEW_ALL: &'static str = "annotation_view_all";
2527 pub const ANNOTATION_VIEW_SELF: &'static str = "annotation_view_self";
2528 pub const BASE_EXPLORER: &'static str = "base_explorer";
2529 pub const BASE_PICKER: &'static str = "base_picker";
2530 pub const BASE_PREVIEW: &'static str = "base_preview";
2531 pub const BASE_UPLOAD: &'static str = "base_upload";
2532 pub const ITEM_DELETE: &'static str = "item_delete";
2533 pub const ITEM_DOWNLOAD: &'static str = "item_download";
2534 pub const ITEM_PREVIEW: &'static str = "item_preview";
2535 pub const ITEM_RENAME: &'static str = "item_rename";
2536 pub const ITEM_SHARE: &'static str = "item_share";
2537 pub const ITEM_UPLOAD: &'static str = "item_upload";
2538 pub const ITEM_READ: &'static str = "item_read";
2539}
2540
2541#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2542#[serde(transparent)]
2543pub struct RetentionPolicyType(pub String);
2544
2545impl RetentionPolicyType {
2546 pub const RETENTION_POLICY: &'static str = "retention_policy";
2547}
2548
2549#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2550#[serde(transparent)]
2551pub struct RetentionPolicyDispositionAction(pub String);
2552
2553impl RetentionPolicyDispositionAction {
2554 pub const PERMANENTLY_DELETE: &'static str = "permanently_delete";
2555 pub const REMOVE_RETENTION: &'static str = "remove_retention";
2556}
2557
2558#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2559#[serde(transparent)]
2560pub struct RetentionPolicyMaxExtensionLengthRequestVariant0(pub String);
2561
2562impl RetentionPolicyMaxExtensionLengthRequestVariant0 {
2563 pub const NONE: &'static str = "none";
2564}
2565
2566#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2567#[serde(transparent)]
2568pub struct ShieldInformationBarrierType(pub String);
2569
2570impl ShieldInformationBarrierType {
2571 pub const SHIELD_INFORMATION_BARRIER: &'static str = "shield_information_barrier";
2572}
2573
2574#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2575#[serde(transparent)]
2576pub struct ShieldInformationBarrierSegmentType(pub String);
2577
2578impl ShieldInformationBarrierSegmentType {
2579 pub const SHIELD_INFORMATION_BARRIER_SEGMENT: &'static str =
2580 "shield_information_barrier_segment";
2581}
2582
2583#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2584pub struct ShieldInformationBarrierSegmentMemberShieldInformationBarrierSegment {
2585 #[serde(default, skip_serializing_if = "Option::is_none")]
2586 pub id: Option<String>,
2587 #[serde(default, skip_serializing_if = "Option::is_none")]
2588 pub r#type: Option<ShieldInformationBarrierSegmentType>,
2589}
2590
2591#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2592#[serde(transparent)]
2593pub struct SignRequestCreateSignerRole(pub String);
2594
2595impl SignRequestCreateSignerRole {
2596 pub const SIGNER: &'static str = "signer";
2597 pub const APPROVER: &'static str = "approver";
2598 pub const FINAL_COPY_READER: &'static str = "final_copy_reader";
2599}
2600
2601#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2602#[serde(transparent)]
2603pub struct SignRequestSignerInputContentType(pub String);
2604
2605impl SignRequestSignerInputContentType {
2606 pub const SIGNATURE: &'static str = "signature";
2607 pub const INITIAL: &'static str = "initial";
2608 pub const STAMP: &'static str = "stamp";
2609 pub const DATE: &'static str = "date";
2610 pub const CHECKBOX: &'static str = "checkbox";
2611 pub const TEXT: &'static str = "text";
2612 pub const FULL_NAME: &'static str = "full_name";
2613 pub const FIRST_NAME: &'static str = "first_name";
2614 pub const LAST_NAME: &'static str = "last_name";
2615 pub const COMPANY: &'static str = "company";
2616 pub const TITLE: &'static str = "title";
2617 pub const EMAIL: &'static str = "email";
2618 pub const ATTACHMENT: &'static str = "attachment";
2619 pub const RADIO: &'static str = "radio";
2620 pub const DROPDOWN: &'static str = "dropdown";
2621}
2622
2623#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2624#[serde(transparent)]
2625pub struct SignRequestSignerInputCustomValidationValidationType(pub String);
2626
2627impl SignRequestSignerInputCustomValidationValidationType {
2628 pub const CUSTOM: &'static str = "custom";
2629}
2630
2631#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2632#[serde(transparent)]
2633pub struct SignRequestSignerInputDateAsiaValidationValidationType(pub String);
2634
2635impl SignRequestSignerInputDateAsiaValidationValidationType {
2636 pub const DATE_ASIA: &'static str = "date_asia";
2637}
2638
2639#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2640#[serde(transparent)]
2641pub struct SignRequestSignerInputDateEUValidationValidationType(pub String);
2642
2643impl SignRequestSignerInputDateEUValidationValidationType {
2644 pub const DATE_EU: &'static str = "date_eu";
2645}
2646
2647#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2648#[serde(transparent)]
2649pub struct SignRequestSignerInputDateISOValidationValidationType(pub String);
2650
2651impl SignRequestSignerInputDateISOValidationValidationType {
2652 pub const DATE_ISO: &'static str = "date_iso";
2653}
2654
2655#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2656#[serde(transparent)]
2657pub struct SignRequestSignerInputDateUSValidationValidationType(pub String);
2658
2659impl SignRequestSignerInputDateUSValidationValidationType {
2660 pub const DATE_US: &'static str = "date_us";
2661}
2662
2663#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2664#[serde(transparent)]
2665pub struct SignRequestSignerInputEmailValidationValidationType(pub String);
2666
2667impl SignRequestSignerInputEmailValidationValidationType {
2668 pub const EMAIL: &'static str = "email";
2669}
2670
2671#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2672#[serde(transparent)]
2673pub struct SignRequestSignerInputNumberWithCommaValidationValidationType(pub String);
2674
2675impl SignRequestSignerInputNumberWithCommaValidationValidationType {
2676 pub const NUMBER_WITH_COMMA: &'static str = "number_with_comma";
2677}
2678
2679#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2680#[serde(transparent)]
2681pub struct SignRequestSignerInputNumberWithPeriodValidationValidationType(pub String);
2682
2683impl SignRequestSignerInputNumberWithPeriodValidationValidationType {
2684 pub const NUMBER_WITH_PERIOD: &'static str = "number_with_period";
2685}
2686
2687#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2688#[serde(transparent)]
2689pub struct SignRequestSignerInputSSNValidationValidationType(pub String);
2690
2691impl SignRequestSignerInputSSNValidationValidationType {
2692 pub const SSN: &'static str = "ssn";
2693}
2694
2695#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2696#[serde(transparent)]
2697pub struct SignRequestSignerInputZIP4ValidationValidationType(pub String);
2698
2699impl SignRequestSignerInputZIP4ValidationValidationType {
2700 pub const ZIP_4: &'static str = "zip_4";
2701}
2702
2703#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2704#[serde(transparent)]
2705pub struct SignRequestSignerInputZIPValidationValidationType(pub String);
2706
2707impl SignRequestSignerInputZIPValidationValidationType {
2708 pub const ZIP: &'static str = "zip";
2709}
2710
2711#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2712#[serde(transparent)]
2713pub struct StoragePolicyType(pub String);
2714
2715impl StoragePolicyType {
2716 pub const STORAGE_POLICY: &'static str = "storage_policy";
2717}
2718
2719#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2720#[serde(transparent)]
2721pub struct TaskType(pub String);
2722
2723impl TaskType {
2724 pub const TASK: &'static str = "task";
2725}
2726
2727#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2728#[serde(transparent)]
2729pub struct TaskAssignmentType(pub String);
2730
2731impl TaskAssignmentType {
2732 pub const TASK_ASSIGNMENT: &'static str = "task_assignment";
2733}
2734
2735#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2736#[serde(transparent)]
2737pub struct TaskAssignmentResolutionState(pub String);
2738
2739impl TaskAssignmentResolutionState {
2740 pub const COMPLETED: &'static str = "completed";
2741 pub const INCOMPLETE: &'static str = "incomplete";
2742 pub const APPROVED: &'static str = "approved";
2743 pub const REJECTED: &'static str = "rejected";
2744}
2745
2746#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2747#[serde(transparent)]
2748pub struct TermsOfServiceType(pub String);
2749
2750impl TermsOfServiceType {
2751 pub const TERMS_OF_SERVICE: &'static str = "terms_of_service";
2752}
2753
2754#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2755pub struct PathCollectionEntries {
2756 #[serde(default, skip_serializing_if = "Option::is_none")]
2757 pub r#type: Option<FolderType>,
2758 #[serde(default, skip_serializing_if = "Option::is_none")]
2759 pub id: Option<String>,
2760 #[serde(
2761 default,
2762 skip_serializing_if = "Option::is_none",
2763 deserialize_with = "double_option"
2764 )]
2765 pub sequence_id: Option<Option<String>>,
2766 #[serde(
2767 default,
2768 skip_serializing_if = "Option::is_none",
2769 deserialize_with = "double_option"
2770 )]
2771 pub etag: Option<Option<String>>,
2772 #[serde(default, skip_serializing_if = "Option::is_none")]
2773 pub name: Option<String>,
2774}
2775
2776#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2777pub struct TrashFilePathCollection {
2778 pub total_count: i64,
2779 pub entries: Vec<PathCollectionEntries>,
2780}
2781
2782#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2783#[serde(transparent)]
2784pub struct TrashWebLinkType(pub String);
2785
2786impl TrashWebLinkType {
2787 pub const WEB_LINK: &'static str = "web_link";
2788}
2789
2790#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2791#[serde(transparent)]
2792pub struct UserStatus(pub String);
2793
2794impl UserStatus {
2795 pub const ACTIVE: &'static str = "active";
2796 pub const INACTIVE: &'static str = "inactive";
2797 pub const CANNOT_DELETE_EDIT: &'static str = "cannot_delete_edit";
2798 pub const CANNOT_DELETE_EDIT_UPLOAD: &'static str = "cannot_delete_edit_upload";
2799}
2800
2801#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2802pub struct UserNotificationEmail {
2803 #[serde(default, skip_serializing_if = "Option::is_none")]
2804 pub email: Option<String>,
2805 #[serde(default, skip_serializing_if = "Option::is_none")]
2806 pub is_confirmed: Option<bool>,
2807}
2808
2809#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2810pub struct WatermarkWatermark {
2811 #[serde(default, skip_serializing_if = "Option::is_none")]
2812 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
2813 #[serde(default, skip_serializing_if = "Option::is_none")]
2814 pub modified_at: Option<chrono::DateTime<chrono::Utc>>,
2815}
2816
2817#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2818pub struct PutIdParent {
2819 #[serde(default, skip_serializing_if = "Option::is_none")]
2820 pub id: Option<String>,
2821 #[serde(default, skip_serializing_if = "Option::is_none")]
2822 pub user_id: Option<String>,
2823}
2824
2825#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2826pub struct UpdateFileRequestSharedLinkPermissions {
2827 #[serde(default, skip_serializing_if = "Option::is_none")]
2828 pub can_download: Option<bool>,
2829}
2830
2831#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2832pub struct PutIdSharedLink {
2833 #[serde(default, skip_serializing_if = "Option::is_none")]
2834 pub access: Option<SharedLinkAccess>,
2835 #[serde(
2836 default,
2837 skip_serializing_if = "Option::is_none",
2838 deserialize_with = "double_option"
2839 )]
2840 pub password: Option<Option<String>>,
2841 #[serde(default, skip_serializing_if = "Option::is_none")]
2842 pub vanity_name: Option<String>,
2843 #[serde(default, skip_serializing_if = "Option::is_none")]
2844 pub unshared_at: Option<chrono::DateTime<chrono::Utc>>,
2845 #[serde(default, skip_serializing_if = "Option::is_none")]
2846 pub permissions: Option<UpdateFileRequestSharedLinkPermissions>,
2847}
2848
2849#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2850pub struct PostFileIdParent {
2851 #[serde(default, skip_serializing_if = "Option::is_none")]
2852 pub id: Option<String>,
2853}
2854
2855#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2856pub struct CreateFileRequest {
2857 #[serde(default, skip_serializing_if = "Option::is_none")]
2858 pub name: Option<String>,
2859 #[serde(default, skip_serializing_if = "Option::is_none")]
2860 pub parent: Option<PostFileIdParent>,
2861}
2862
2863#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2864pub struct AttributesParent {
2865 pub id: String,
2866}
2867
2868#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2869#[serde(transparent)]
2870pub struct PutOp(pub String);
2871
2872impl PutOp {
2873 pub const REPLACE: &'static str = "replace";
2874}
2875
2876#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2877#[serde(transparent)]
2878pub struct PutPath(pub String);
2879
2880impl PutPath {
2881 pub const BOX_SECURITY_CLASSIFICATION_KEY: &'static str = "/Box__Security__Classification__Key";
2882}
2883
2884#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2885pub struct UpdateFileClassificationRequest {
2886 pub op: PutOp,
2887 pub path: PutPath,
2888 pub value: String,
2889}
2890
2891#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2892pub struct CreateFileClassificationRequest {
2893 #[serde(
2894 rename = "Box__Security__Classification__Key",
2895 default,
2896 skip_serializing_if = "Option::is_none"
2897 )]
2898 pub box_security_classification_key: Option<String>,
2899}
2900
2901#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2902#[serde(transparent)]
2903pub struct GetFileIdMetadataIdScope(pub String);
2904
2905impl GetFileIdMetadataIdScope {
2906 pub const GLOBAL: &'static str = "global";
2907 pub const ENTERPRISE: &'static str = "enterprise";
2908}
2909
2910#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2911#[serde(transparent)]
2912pub struct PutFileIdMetadataIdOp(pub String);
2913
2914impl PutFileIdMetadataIdOp {
2915 pub const ADD: &'static str = "add";
2916 pub const REPLACE: &'static str = "replace";
2917 pub const REMOVE: &'static str = "remove";
2918 pub const TEST: &'static str = "test";
2919 pub const MOVE: &'static str = "move";
2920 pub const COPY: &'static str = "copy";
2921}
2922
2923#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2924pub struct UpdateFileMetadataRequest {
2925 #[serde(default, skip_serializing_if = "Option::is_none")]
2926 pub op: Option<PutFileIdMetadataIdOp>,
2927 #[serde(default, skip_serializing_if = "Option::is_none")]
2928 pub path: Option<String>,
2929 #[serde(default, skip_serializing_if = "Option::is_none")]
2930 pub value: Option<MetadataInstanceValue>,
2931 #[serde(default, skip_serializing_if = "Option::is_none")]
2932 pub from: Option<String>,
2933}
2934
2935#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2936#[serde(transparent)]
2937pub struct WatermarkImprint(pub String);
2938
2939impl WatermarkImprint {
2940 pub const DEFAULT: &'static str = "default";
2941}
2942
2943#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2944pub struct PutFileIdWatermarkWatermark {
2945 pub imprint: WatermarkImprint,
2946}
2947
2948#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2949pub struct UpdateFileWatermarkRequest {
2950 pub watermark: PutFileIdWatermarkWatermark,
2951}
2952
2953#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
2954#[serde(transparent)]
2955pub struct GetDirection(pub String);
2956
2957impl GetDirection {
2958 pub const DESC: &'static str = "DESC";
2959 pub const ASC: &'static str = "ASC";
2960}
2961
2962#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2963pub struct UpdateFileAddSharedLinkRequestSharedLinkPermissions {
2964 #[serde(default, skip_serializing_if = "Option::is_none")]
2965 pub can_download: Option<bool>,
2966 #[serde(default, skip_serializing_if = "Option::is_none")]
2967 pub can_preview: Option<bool>,
2968 #[serde(default, skip_serializing_if = "Option::is_none")]
2969 pub can_edit: Option<bool>,
2970}
2971
2972#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2973pub struct PutFileIdAddSharedLinkSharedLink {
2974 #[serde(default, skip_serializing_if = "Option::is_none")]
2975 pub access: Option<SharedLinkAccess>,
2976 #[serde(
2977 default,
2978 skip_serializing_if = "Option::is_none",
2979 deserialize_with = "double_option"
2980 )]
2981 pub password: Option<Option<String>>,
2982 #[serde(default, skip_serializing_if = "Option::is_none")]
2983 pub vanity_name: Option<String>,
2984 #[serde(default, skip_serializing_if = "Option::is_none")]
2985 pub unshared_at: Option<chrono::DateTime<chrono::Utc>>,
2986 #[serde(default, skip_serializing_if = "Option::is_none")]
2987 pub permissions: Option<UpdateFileAddSharedLinkRequestSharedLinkPermissions>,
2988}
2989
2990#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2991pub struct UpdateFileAddSharedLinkRequest {
2992 #[serde(default, skip_serializing_if = "Option::is_none")]
2993 pub shared_link: Option<PutFileIdAddSharedLinkSharedLink>,
2994}
2995
2996#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
2997pub struct UpdateFileRemoveSharedLinkRequest {
2998 #[serde(
2999 default,
3000 skip_serializing_if = "Option::is_none",
3001 deserialize_with = "double_option"
3002 )]
3003 pub shared_link: Option<Option<std::collections::HashMap<String, serde_json::Value>>>,
3004}
3005
3006#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3007pub struct PutSkillInvocationIdFile {
3008 #[serde(default, skip_serializing_if = "Option::is_none")]
3009 pub r#type: Option<AiCitationType>,
3010 #[serde(default, skip_serializing_if = "Option::is_none")]
3011 pub id: Option<String>,
3012}
3013
3014#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3015pub struct DocGenBatchBase {
3016 pub id: String,
3017 pub r#type: DocGenBatchBaseType,
3018}
3019
3020#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3021pub struct DocGenJob {
3022 pub id: String,
3023 pub r#type: DocGenJobType,
3024 pub batch: DocGenBatchBase,
3025 pub template_file: FileReference,
3026 pub template_file_version: FileVersionBase,
3027 #[serde(
3028 default,
3029 skip_serializing_if = "Option::is_none",
3030 deserialize_with = "double_option"
3031 )]
3032 pub output_file: Option<Option<FileReference>>,
3033 #[serde(
3034 default,
3035 skip_serializing_if = "Option::is_none",
3036 deserialize_with = "double_option"
3037 )]
3038 pub output_file_version: Option<Option<FileVersionBase>>,
3039 pub status: DocGenJobStatus,
3040 pub output_type: String,
3041 #[serde(
3042 default,
3043 skip_serializing_if = "Option::is_none",
3044 deserialize_with = "double_option"
3045 )]
3046 pub failures: Option<Option<DocGenJobFailures>>,
3047}
3048
3049#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3050pub struct DocGenJobBase {
3051 pub id: String,
3052 pub r#type: DocGenJobType,
3053}
3054
3055#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3056pub struct DocGenJobs {
3057 #[serde(default, skip_serializing_if = "Option::is_none")]
3058 pub limit: Option<i64>,
3059 #[serde(
3060 default,
3061 skip_serializing_if = "Option::is_none",
3062 deserialize_with = "double_option"
3063 )]
3064 pub next_marker: Option<Option<String>>,
3065 #[serde(
3066 default,
3067 skip_serializing_if = "Option::is_none",
3068 deserialize_with = "double_option"
3069 )]
3070 pub prev_marker: Option<Option<String>>,
3071 #[serde(default, skip_serializing_if = "Option::is_none")]
3072 pub entries: Option<Vec<DocGenJob>>,
3073}
3074
3075#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3076pub struct DocGenTagsProcessingMessage {
3077 pub message: String,
3078}
3079
3080#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3081pub struct EnterpriseConfigurationItem {
3082 #[serde(default, skip_serializing_if = "Option::is_none")]
3083 pub is_used: Option<bool>,
3084}
3085
3086#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3087pub struct EnterpriseReference {
3088 #[serde(default, skip_serializing_if = "Option::is_none")]
3089 pub id: Option<String>,
3090 #[serde(default, skip_serializing_if = "Option::is_none")]
3091 pub r#type: Option<EnterpriseReferenceType>,
3092}
3093
3094#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3095pub struct FileReference {
3096 pub r#type: FileReferenceType,
3097 pub id: String,
3098}
3099
3100#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3101pub struct HubDocumentBlock {
3102 pub id: String,
3103 #[serde(
3104 default,
3105 skip_serializing_if = "Option::is_none",
3106 deserialize_with = "double_option"
3107 )]
3108 pub parent_id: Option<Option<String>>,
3109}
3110
3111#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
3112#[serde(transparent)]
3113pub struct DocGenBatchBaseType(pub String);
3114
3115impl DocGenBatchBaseType {
3116 pub const DOCGEN_BATCH: &'static str = "docgen_batch";
3117}
3118
3119#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
3120#[serde(transparent)]
3121pub struct DocGenJobType(pub String);
3122
3123impl DocGenJobType {
3124 pub const DOCGEN_JOB: &'static str = "docgen_job";
3125}
3126
3127#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
3128#[serde(transparent)]
3129pub struct DocGenJobStatus(pub String);
3130
3131impl DocGenJobStatus {
3132 pub const SUBMITTED: &'static str = "submitted";
3133 pub const COMPLETED: &'static str = "completed";
3134 pub const FAILED: &'static str = "failed";
3135 pub const COMPLETED_WITH_ERROR: &'static str = "completed_with_error";
3136 pub const PENDING: &'static str = "pending";
3137}
3138
3139#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
3140pub struct DocGenJobFailures {
3141 pub errors: Vec<String>,
3142 pub warnings: Vec<String>,
3143}
3144
3145#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
3146#[serde(transparent)]
3147pub struct EnterpriseReferenceType(pub String);
3148
3149impl EnterpriseReferenceType {
3150 pub const ENTERPRISE: &'static str = "enterprise";
3151}
3152
3153#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
3154#[serde(transparent)]
3155pub struct FileReferenceType(pub String);
3156
3157impl FileReferenceType {
3158 pub const FILE: &'static str = "file";
3159}
3160
3161#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
3162#[serde(transparent)]
3163pub struct FileVersionBaseType(pub String);
3164
3165impl FileVersionBaseType {
3166 pub const FILE_VERSION: &'static str = "file_version";
3167}
3168
3169#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
3170#[serde(transparent)]
3171pub struct GroupBaseType(pub String);
3172
3173impl GroupBaseType {
3174 pub const GROUP: &'static str = "group";
3175}
3176
3177#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
3178#[serde(transparent)]
3179pub struct GroupMiniGroupType(pub String);
3180
3181impl GroupMiniGroupType {
3182 pub const MANAGED_GROUP: &'static str = "managed_group";
3183 pub const ALL_USERS_GROUP: &'static str = "all_users_group";
3184}
3185
3186#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
3187#[serde(transparent)]
3188pub struct HubType(pub String);
3189
3190impl HubType {
3191 pub const HUBS: &'static str = "hubs";
3192}
3193
3194#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
3195#[serde(transparent)]
3196pub struct HubCollaborationUserType(pub String);
3197
3198impl HubCollaborationUserType {
3199 pub const USER: &'static str = "user";
3200}
3201
3202#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
3203#[serde(transparent)]
3204pub struct TermsOfServiceBaseType(pub String);
3205
3206impl TermsOfServiceBaseType {
3207 pub const TERMS_OF_SERVICE: &'static str = "terms_of_service";
3208}
3209
3210#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
3211#[serde(transparent)]
3212pub struct FolderReferenceType(pub String);
3213
3214impl FolderReferenceType {
3215 pub const FOLDER: &'static str = "folder";
3216}
3217
3218#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
3219#[serde(transparent)]
3220pub struct UserBaseType(pub String);
3221
3222impl UserBaseType {
3223 pub const USER: &'static str = "user";
3224}