1use schemars::JsonSchema;
3use serde::{Deserialize, Serialize};
4
5#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
7pub struct Alias {
8 #[serde(
12 default,
13 skip_serializing_if = "String::is_empty",
14 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15 )]
16 pub alias: String,
17 #[serde(
21 default,
22 skip_serializing_if = "String::is_empty",
23 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24 )]
25 pub etag: String,
26 #[serde(
30 default,
31 skip_serializing_if = "String::is_empty",
32 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33 )]
34 pub id: String,
35 #[serde(
39 default,
40 skip_serializing_if = "String::is_empty",
41 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
42 )]
43 pub kind: String,
44 #[serde(
48 default,
49 skip_serializing_if = "String::is_empty",
50 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
51 rename = "primaryEmail"
52 )]
53 pub primary_email: String,
54}
55
56#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
58pub struct Aliases {
59 #[serde(
63 default,
64 skip_serializing_if = "Vec::is_empty",
65 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
66 )]
67 pub aliases: Vec<String>,
68 #[serde(
72 default,
73 skip_serializing_if = "String::is_empty",
74 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
75 )]
76 pub etag: String,
77 #[serde(
81 default,
82 skip_serializing_if = "String::is_empty",
83 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
84 )]
85 pub kind: String,
86}
87
88#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
90pub struct Asp {
91 #[serde(
95 default,
96 skip_serializing_if = "crate::utils::zero_i64",
97 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
98 rename = "codeId"
99 )]
100 pub code_id: i64,
101 #[serde(
105 default,
106 skip_serializing_if = "crate::utils::zero_i64",
107 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
108 rename = "creationTime"
109 )]
110 pub creation_time: i64,
111 #[serde(
115 default,
116 skip_serializing_if = "String::is_empty",
117 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
118 )]
119 pub etag: String,
120 #[serde(
124 default,
125 skip_serializing_if = "String::is_empty",
126 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
127 )]
128 pub kind: String,
129 #[serde(
133 default,
134 skip_serializing_if = "crate::utils::zero_i64",
135 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
136 rename = "lastTimeUsed"
137 )]
138 pub last_time_used: i64,
139 #[serde(
143 default,
144 skip_serializing_if = "String::is_empty",
145 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
146 )]
147 pub name: String,
148 #[serde(
152 default,
153 skip_serializing_if = "String::is_empty",
154 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
155 rename = "userKey"
156 )]
157 pub user_key: String,
158}
159
160#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
161pub struct Asps {
162 #[serde(
163 default,
164 skip_serializing_if = "String::is_empty",
165 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
166 )]
167 pub etag: String,
168 #[serde(
172 default,
173 skip_serializing_if = "Vec::is_empty",
174 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
175 )]
176 pub items: Vec<Asp>,
177 #[serde(
178 default,
179 skip_serializing_if = "String::is_empty",
180 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
181 )]
182 pub kind: String,
183}
184
185#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
189pub enum Severity {
190 #[serde(rename = "SEVERITY_ERROR")]
191 SeverityError,
192 #[serde(rename = "SEVERITY_INFO")]
193 SeverityInfo,
194 #[serde(rename = "SEVERITY_UNSPECIFIED")]
195 SeverityUnspecified,
196 #[serde(rename = "SEVERITY_WARNING")]
197 SeverityWarning,
198 #[serde(rename = "")]
199 #[default]
200 Noop,
201 #[serde(other)]
202 FallthroughString,
203}
204
205impl std::fmt::Display for Severity {
206 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
207 match self {
208 Severity::SeverityError => "SEVERITY_ERROR",
209 Severity::SeverityInfo => "SEVERITY_INFO",
210 Severity::SeverityUnspecified => "SEVERITY_UNSPECIFIED",
211 Severity::SeverityWarning => "SEVERITY_WARNING",
212 Severity::Noop => "",
213 Severity::FallthroughString => "*",
214 }
215 .fmt(f)
216 }
217}
218
219impl Severity {
220 pub fn is_noop(&self) -> bool {
221 matches!(self, Severity::Noop)
222 }
223}
224
225#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
227pub struct AuxiliaryMessage {
228 #[serde(
232 default,
233 skip_serializing_if = "String::is_empty",
234 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
235 rename = "auxiliaryMessage"
236 )]
237 pub auxiliary_message: String,
238 #[serde(
242 default,
243 skip_serializing_if = "String::is_empty",
244 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
245 rename = "fieldMask"
246 )]
247 pub field_mask: String,
248 #[serde(default, skip_serializing_if = "Option::is_none")]
252 pub severity: Option<Severity>,
253}
254
255#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
257pub struct BatchCreatePrintersRequest {
258 #[serde(
262 default,
263 skip_serializing_if = "Vec::is_empty",
264 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
265 )]
266 pub requests: Vec<CreatePrinterRequest>,
267}
268
269#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
271pub struct BatchCreatePrintersResponse {
272 #[serde(
276 default,
277 skip_serializing_if = "Vec::is_empty",
278 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
279 )]
280 pub failures: Vec<FailureInfo>,
281 #[serde(
285 default,
286 skip_serializing_if = "Vec::is_empty",
287 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
288 )]
289 pub printers: Vec<Printer>,
290}
291
292#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
294pub struct BatchDeletePrintersRequest {
295 #[serde(
299 default,
300 skip_serializing_if = "Vec::is_empty",
301 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
302 rename = "printerIds"
303 )]
304 pub printer_ids: Vec<String>,
305}
306
307#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
309pub struct BatchDeletePrintersResponse {
310 #[serde(
314 default,
315 skip_serializing_if = "Vec::is_empty",
316 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
317 rename = "failedPrinters"
318 )]
319 pub failed_printers: Vec<FailureInfo>,
320 #[serde(
324 default,
325 skip_serializing_if = "Vec::is_empty",
326 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
327 rename = "printerIds"
328 )]
329 pub printer_ids: Vec<String>,
330}
331
332#[derive(Serialize, Default, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
334pub struct Building {
335 #[serde(default, skip_serializing_if = "Option::is_none")]
339 pub address: Option<BuildingAddress>,
340 #[serde(
344 default,
345 skip_serializing_if = "String::is_empty",
346 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
347 rename = "buildingId"
348 )]
349 pub building_id: String,
350 #[serde(
354 default,
355 skip_serializing_if = "String::is_empty",
356 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
357 rename = "buildingName"
358 )]
359 pub building_name: String,
360 #[serde(default, skip_serializing_if = "Option::is_none")]
364 pub coordinates: Option<BuildingCoordinates>,
365 #[serde(
369 default,
370 skip_serializing_if = "String::is_empty",
371 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
372 )]
373 pub description: String,
374 #[serde(
378 default,
379 skip_serializing_if = "String::is_empty",
380 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
381 )]
382 pub etags: String,
383 #[serde(
387 default,
388 skip_serializing_if = "Vec::is_empty",
389 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
390 rename = "floorNames"
391 )]
392 pub floor_names: Vec<String>,
393 #[serde(
397 default,
398 skip_serializing_if = "String::is_empty",
399 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
400 )]
401 pub kind: String,
402}
403
404#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
406pub struct BuildingAddress {
407 #[serde(
411 default,
412 skip_serializing_if = "Vec::is_empty",
413 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
414 rename = "addressLines"
415 )]
416 pub address_lines: Vec<String>,
417 #[serde(
421 default,
422 skip_serializing_if = "String::is_empty",
423 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
424 rename = "administrativeArea"
425 )]
426 pub administrative_area: String,
427 #[serde(
431 default,
432 skip_serializing_if = "String::is_empty",
433 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
434 rename = "languageCode"
435 )]
436 pub language_code: String,
437 #[serde(
441 default,
442 skip_serializing_if = "String::is_empty",
443 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
444 )]
445 pub locality: String,
446 #[serde(
450 default,
451 skip_serializing_if = "String::is_empty",
452 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
453 rename = "postalCode"
454 )]
455 pub postal_code: String,
456 #[serde(
460 default,
461 skip_serializing_if = "String::is_empty",
462 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
463 rename = "regionCode"
464 )]
465 pub region_code: String,
466 #[serde(
470 default,
471 skip_serializing_if = "String::is_empty",
472 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
473 )]
474 pub sublocality: String,
475}
476
477#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
479pub struct BuildingCoordinates {
480 #[serde(
484 default,
485 skip_serializing_if = "crate::utils::zero_f64",
486 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
487 )]
488 pub latitude: f64,
489 #[serde(
493 default,
494 skip_serializing_if = "crate::utils::zero_f64",
495 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
496 )]
497 pub longitude: f64,
498}
499
500#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
502pub struct Buildings {
503 #[serde(
507 default,
508 skip_serializing_if = "Vec::is_empty",
509 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
510 )]
511 pub buildings: Vec<Building>,
512 #[serde(
516 default,
517 skip_serializing_if = "String::is_empty",
518 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
519 )]
520 pub etag: String,
521 #[serde(
525 default,
526 skip_serializing_if = "String::is_empty",
527 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
528 )]
529 pub kind: String,
530 #[serde(
534 default,
535 skip_serializing_if = "String::is_empty",
536 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
537 rename = "nextPageToken"
538 )]
539 pub next_page_token: String,
540}
541
542#[derive(Serialize, Default, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
544pub struct CalendarResource {
545 #[serde(
549 default,
550 skip_serializing_if = "String::is_empty",
551 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
552 rename = "buildingId"
553 )]
554 pub building_id: String,
555 #[serde(
559 default,
560 skip_serializing_if = "crate::utils::zero_i64",
561 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
562 )]
563 pub capacity: i64,
564 #[serde(
568 default,
569 skip_serializing_if = "String::is_empty",
570 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
571 )]
572 pub etags: String,
573 #[serde(
577 default,
578 skip_serializing_if = "Option::is_none",
579 rename = "featureInstances"
580 )]
581 pub feature_instances: Option<serde_json::Value>,
582 #[serde(
586 default,
587 skip_serializing_if = "String::is_empty",
588 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
589 rename = "floorName"
590 )]
591 pub floor_name: String,
592 #[serde(
596 default,
597 skip_serializing_if = "String::is_empty",
598 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
599 rename = "floorSection"
600 )]
601 pub floor_section: String,
602 #[serde(
606 default,
607 skip_serializing_if = "String::is_empty",
608 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
609 rename = "generatedResourceName"
610 )]
611 pub generated_resource_name: String,
612 #[serde(
616 default,
617 skip_serializing_if = "String::is_empty",
618 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
619 )]
620 pub kind: String,
621 #[serde(
625 default,
626 skip_serializing_if = "String::is_empty",
627 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
628 rename = "resourceCategory"
629 )]
630 pub resource_category: String,
631 #[serde(
635 default,
636 skip_serializing_if = "String::is_empty",
637 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
638 rename = "resourceDescription"
639 )]
640 pub resource_description: String,
641 #[serde(
645 default,
646 skip_serializing_if = "String::is_empty",
647 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
648 rename = "resourceEmail"
649 )]
650 pub resource_email: String,
651 #[serde(
655 default,
656 skip_serializing_if = "String::is_empty",
657 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
658 rename = "resourceId"
659 )]
660 pub resource_id: String,
661 #[serde(
665 default,
666 skip_serializing_if = "String::is_empty",
667 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
668 rename = "resourceName"
669 )]
670 pub resource_name: String,
671 #[serde(
675 default,
676 skip_serializing_if = "String::is_empty",
677 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
678 rename = "resourceType"
679 )]
680 pub resource_type: String,
681 #[serde(
685 default,
686 skip_serializing_if = "String::is_empty",
687 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
688 rename = "userVisibleDescription"
689 )]
690 pub user_visible_description: String,
691}
692
693#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
695pub struct CalendarResources {
696 #[serde(
700 default,
701 skip_serializing_if = "String::is_empty",
702 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
703 )]
704 pub etag: String,
705 #[serde(
709 default,
710 skip_serializing_if = "Vec::is_empty",
711 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
712 )]
713 pub items: Vec<CalendarResource>,
714 #[serde(
718 default,
719 skip_serializing_if = "String::is_empty",
720 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
721 )]
722 pub kind: String,
723 #[serde(
727 default,
728 skip_serializing_if = "String::is_empty",
729 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
730 rename = "nextPageToken"
731 )]
732 pub next_page_token: String,
733}
734
735#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
737pub struct Channel {
738 #[serde(
742 default,
743 skip_serializing_if = "String::is_empty",
744 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
745 )]
746 pub address: String,
747 #[serde(
751 default,
752 skip_serializing_if = "crate::utils::zero_i64",
753 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
754 )]
755 pub expiration: i64,
756 #[serde(
760 default,
761 skip_serializing_if = "String::is_empty",
762 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
763 )]
764 pub id: String,
765 #[serde(
769 default,
770 skip_serializing_if = "String::is_empty",
771 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
772 )]
773 pub kind: String,
774 #[serde(
778 default,
779 skip_serializing_if = "String::is_empty",
780 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
781 )]
782 pub params: String,
783 #[serde(
787 default,
788 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
789 )]
790 pub payload: bool,
791 #[serde(
795 default,
796 skip_serializing_if = "String::is_empty",
797 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
798 rename = "resourceId"
799 )]
800 pub resource_id: String,
801 #[serde(
805 default,
806 skip_serializing_if = "String::is_empty",
807 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
808 rename = "resourceUri"
809 )]
810 pub resource_uri: String,
811 #[serde(
815 default,
816 skip_serializing_if = "String::is_empty",
817 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
818 )]
819 pub token: String,
820 #[serde(
824 default,
825 skip_serializing_if = "String::is_empty",
826 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
827 rename = "type"
828 )]
829 pub type_: String,
830}
831
832#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
833pub struct ActiveTimeRanges {
834 #[serde(
838 default,
839 skip_serializing_if = "crate::utils::zero_i64",
840 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
841 rename = "activeTime"
842 )]
843 pub active_time: i64,
844 #[serde(
848 default,
849 skip_serializing_if = "Option::is_none",
850 deserialize_with = "crate::utils::date_format::deserialize"
851 )]
852 pub date: Option<chrono::NaiveDate>,
853}
854
855#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
856pub struct CpuTemperatureInfo {
857 #[serde(
858 default,
859 skip_serializing_if = "String::is_empty",
860 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
861 )]
862 pub label: String,
863 #[serde(
867 default,
868 skip_serializing_if = "crate::utils::zero_i64",
869 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
870 )]
871 pub temperature: i64,
872}
873
874#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
875pub struct CpuStatusReports {
876 #[serde(
880 default,
881 skip_serializing_if = "Vec::is_empty",
882 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
883 rename = "cpuTemperatureInfo"
884 )]
885 pub cpu_temperature_info: Vec<CpuTemperatureInfo>,
886 #[serde(
887 default,
888 skip_serializing_if = "Vec::is_empty",
889 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
890 rename = "cpuUtilizationPercentageInfo"
891 )]
892 pub cpu_utilization_percentage_info: Vec<i64>,
893 #[serde(
897 default,
898 skip_serializing_if = "Option::is_none",
899 deserialize_with = "crate::utils::date_time_format::deserialize",
900 rename = "reportTime"
901 )]
902 pub report_time: Option<chrono::DateTime<chrono::Utc>>,
903}
904
905#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
906pub struct DeviceFiles {
907 #[serde(
911 default,
912 skip_serializing_if = "Option::is_none",
913 deserialize_with = "crate::utils::date_time_format::deserialize",
914 rename = "createTime"
915 )]
916 pub create_time: Option<chrono::DateTime<chrono::Utc>>,
917 #[serde(
918 default,
919 skip_serializing_if = "String::is_empty",
920 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
921 rename = "downloadUrl"
922 )]
923 pub download_url: String,
924 #[serde(
925 default,
926 skip_serializing_if = "String::is_empty",
927 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
928 )]
929 pub name: String,
930 #[serde(
931 default,
932 skip_serializing_if = "String::is_empty",
933 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
934 rename = "type"
935 )]
936 pub type_: String,
937}
938
939#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
940pub struct VolumeInfo {
941 #[serde(
945 default,
946 skip_serializing_if = "crate::utils::zero_i64",
947 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
948 rename = "storageFree"
949 )]
950 pub storage_free: i64,
951 #[serde(
955 default,
956 skip_serializing_if = "crate::utils::zero_i64",
957 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
958 rename = "storageTotal"
959 )]
960 pub storage_total: i64,
961 #[serde(
962 default,
963 skip_serializing_if = "String::is_empty",
964 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
965 rename = "volumeId"
966 )]
967 pub volume_id: String,
968}
969
970#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
971pub struct DiskVolumeReports {
972 #[serde(
976 default,
977 skip_serializing_if = "Vec::is_empty",
978 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
979 rename = "volumeInfo"
980 )]
981 pub volume_info: Vec<VolumeInfo>,
982}
983
984#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
986pub struct LastKnownNetwork {
987 #[serde(
991 default,
992 skip_serializing_if = "String::is_empty",
993 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
994 rename = "ipAddress"
995 )]
996 pub ip_address: String,
997 #[serde(
1001 default,
1002 skip_serializing_if = "String::is_empty",
1003 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1004 rename = "wanIpAddress"
1005 )]
1006 pub wan_ip_address: String,
1007}
1008
1009#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1011pub struct RecentUsers {
1012 #[serde(
1016 default,
1017 skip_serializing_if = "String::is_empty",
1018 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1019 )]
1020 pub email: String,
1021 #[serde(
1025 default,
1026 skip_serializing_if = "String::is_empty",
1027 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1028 rename = "type"
1029 )]
1030 pub type_: String,
1031}
1032
1033#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1034pub struct SystemRamFreeReports {
1035 #[serde(
1039 default,
1040 skip_serializing_if = "Option::is_none",
1041 deserialize_with = "crate::utils::date_time_format::deserialize",
1042 rename = "reportTime"
1043 )]
1044 pub report_time: Option<chrono::DateTime<chrono::Utc>>,
1045 #[serde(
1046 default,
1047 skip_serializing_if = "Vec::is_empty",
1048 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
1049 rename = "systemRamFreeInfo"
1050 )]
1051 pub system_ram_free_info: Vec<i64>,
1052}
1053
1054#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1056pub struct TpmVersionInfo {
1057 #[serde(
1061 default,
1062 skip_serializing_if = "String::is_empty",
1063 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1064 )]
1065 pub family: String,
1066 #[serde(
1070 default,
1071 skip_serializing_if = "String::is_empty",
1072 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1073 rename = "firmwareVersion"
1074 )]
1075 pub firmware_version: String,
1076 #[serde(
1080 default,
1081 skip_serializing_if = "String::is_empty",
1082 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1083 )]
1084 pub manufacturer: String,
1085 #[serde(
1089 default,
1090 skip_serializing_if = "String::is_empty",
1091 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1092 rename = "specLevel"
1093 )]
1094 pub spec_level: String,
1095 #[serde(
1099 default,
1100 skip_serializing_if = "String::is_empty",
1101 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1102 rename = "tpmModel"
1103 )]
1104 pub tpm_model: String,
1105 #[serde(
1109 default,
1110 skip_serializing_if = "String::is_empty",
1111 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1112 rename = "vendorSpecific"
1113 )]
1114 pub vendor_specific: String,
1115}
1116
1117#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1119pub struct ChromeOsDevice {
1120 #[serde(
1124 default,
1125 skip_serializing_if = "Vec::is_empty",
1126 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
1127 rename = "activeTimeRanges"
1128 )]
1129 pub active_time_ranges: Vec<ActiveTimeRanges>,
1130 #[serde(
1134 default,
1135 skip_serializing_if = "String::is_empty",
1136 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1137 rename = "annotatedAssetId"
1138 )]
1139 pub annotated_asset_id: String,
1140 #[serde(
1144 default,
1145 skip_serializing_if = "String::is_empty",
1146 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1147 rename = "annotatedLocation"
1148 )]
1149 pub annotated_location: String,
1150 #[serde(
1154 default,
1155 skip_serializing_if = "String::is_empty",
1156 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1157 rename = "annotatedUser"
1158 )]
1159 pub annotated_user: String,
1160 #[serde(
1164 default,
1165 skip_serializing_if = "crate::utils::zero_i64",
1166 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
1167 rename = "autoUpdateExpiration"
1168 )]
1169 pub auto_update_expiration: i64,
1170 #[serde(
1174 default,
1175 skip_serializing_if = "String::is_empty",
1176 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1177 rename = "bootMode"
1178 )]
1179 pub boot_mode: String,
1180 #[serde(
1184 default,
1185 skip_serializing_if = "Vec::is_empty",
1186 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
1187 rename = "cpuStatusReports"
1188 )]
1189 pub cpu_status_reports: Vec<CpuStatusReports>,
1190 #[serde(
1194 default,
1195 skip_serializing_if = "Vec::is_empty",
1196 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
1197 rename = "deviceFiles"
1198 )]
1199 pub device_files: Vec<DeviceFiles>,
1200 #[serde(
1204 default,
1205 skip_serializing_if = "String::is_empty",
1206 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1207 rename = "deviceId"
1208 )]
1209 pub device_id: String,
1210 #[serde(
1214 default,
1215 skip_serializing_if = "Vec::is_empty",
1216 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
1217 rename = "diskVolumeReports"
1218 )]
1219 pub disk_volume_reports: Vec<DiskVolumeReports>,
1220 #[serde(
1224 default,
1225 skip_serializing_if = "String::is_empty",
1226 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1227 rename = "dockMacAddress"
1228 )]
1229 pub dock_mac_address: String,
1230 #[serde(
1234 default,
1235 skip_serializing_if = "String::is_empty",
1236 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1237 )]
1238 pub etag: String,
1239 #[serde(
1243 default,
1244 skip_serializing_if = "String::is_empty",
1245 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1246 rename = "ethernetMacAddress"
1247 )]
1248 pub ethernet_mac_address: String,
1249 #[serde(
1253 default,
1254 skip_serializing_if = "String::is_empty",
1255 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1256 rename = "ethernetMacAddress0"
1257 )]
1258 pub ethernet_mac_address_0: String,
1259 #[serde(
1263 default,
1264 skip_serializing_if = "String::is_empty",
1265 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1266 rename = "firmwareVersion"
1267 )]
1268 pub firmware_version: String,
1269 #[serde(
1273 default,
1274 skip_serializing_if = "String::is_empty",
1275 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1276 )]
1277 pub kind: String,
1278 #[serde(
1282 default,
1283 skip_serializing_if = "Option::is_none",
1284 deserialize_with = "crate::utils::date_time_format::deserialize",
1285 rename = "lastEnrollmentTime"
1286 )]
1287 pub last_enrollment_time: Option<chrono::DateTime<chrono::Utc>>,
1288 #[serde(
1292 default,
1293 skip_serializing_if = "Vec::is_empty",
1294 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
1295 rename = "lastKnownNetwork"
1296 )]
1297 pub last_known_network: Vec<LastKnownNetwork>,
1298 #[serde(
1302 default,
1303 skip_serializing_if = "Option::is_none",
1304 deserialize_with = "crate::utils::date_time_format::deserialize",
1305 rename = "lastSync"
1306 )]
1307 pub last_sync: Option<chrono::DateTime<chrono::Utc>>,
1308 #[serde(
1312 default,
1313 skip_serializing_if = "String::is_empty",
1314 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1315 rename = "macAddress"
1316 )]
1317 pub mac_address: String,
1318 #[serde(
1322 default,
1323 skip_serializing_if = "Option::is_none",
1324 deserialize_with = "crate::utils::date_format::deserialize",
1325 rename = "manufactureDate"
1326 )]
1327 pub manufacture_date: Option<chrono::NaiveDate>,
1328 #[serde(
1332 default,
1333 skip_serializing_if = "String::is_empty",
1334 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1335 )]
1336 pub meid: String,
1337 #[serde(
1341 default,
1342 skip_serializing_if = "String::is_empty",
1343 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1344 )]
1345 pub model: String,
1346 #[serde(
1350 default,
1351 skip_serializing_if = "String::is_empty",
1352 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1353 )]
1354 pub notes: String,
1355 #[serde(
1359 default,
1360 skip_serializing_if = "String::is_empty",
1361 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1362 rename = "orderNumber"
1363 )]
1364 pub order_number: String,
1365 #[serde(
1369 default,
1370 skip_serializing_if = "String::is_empty",
1371 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1372 rename = "orgUnitPath"
1373 )]
1374 pub org_unit_path: String,
1375 #[serde(
1379 default,
1380 skip_serializing_if = "String::is_empty",
1381 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1382 rename = "osVersion"
1383 )]
1384 pub os_version: String,
1385 #[serde(
1389 default,
1390 skip_serializing_if = "String::is_empty",
1391 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1392 rename = "platformVersion"
1393 )]
1394 pub platform_version: String,
1395 #[serde(
1399 default,
1400 skip_serializing_if = "Vec::is_empty",
1401 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
1402 rename = "recentUsers"
1403 )]
1404 pub recent_users: Vec<RecentUsers>,
1405 #[serde(
1409 default,
1410 skip_serializing_if = "Vec::is_empty",
1411 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
1412 rename = "screenshotFiles"
1413 )]
1414 pub screenshot_files: Vec<DeviceFiles>,
1415 #[serde(
1419 default,
1420 skip_serializing_if = "String::is_empty",
1421 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1422 rename = "serialNumber"
1423 )]
1424 pub serial_number: String,
1425 #[serde(
1429 default,
1430 skip_serializing_if = "String::is_empty",
1431 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1432 )]
1433 pub status: String,
1434 #[serde(
1438 default,
1439 skip_serializing_if = "Option::is_none",
1440 deserialize_with = "crate::utils::date_time_format::deserialize",
1441 rename = "supportEndDate"
1442 )]
1443 pub support_end_date: Option<chrono::DateTime<chrono::Utc>>,
1444 #[serde(
1448 default,
1449 skip_serializing_if = "Vec::is_empty",
1450 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
1451 rename = "systemRamFreeReports"
1452 )]
1453 pub system_ram_free_reports: Vec<SystemRamFreeReports>,
1454 #[serde(
1458 default,
1459 skip_serializing_if = "crate::utils::zero_i64",
1460 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
1461 rename = "systemRamTotal"
1462 )]
1463 pub system_ram_total: i64,
1464 #[serde(
1468 default,
1469 skip_serializing_if = "Option::is_none",
1470 rename = "tpmVersionInfo"
1471 )]
1472 pub tpm_version_info: Option<TpmVersionInfo>,
1473 #[serde(
1477 default,
1478 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
1479 rename = "willAutoRenew"
1480 )]
1481 pub will_auto_renew: bool,
1482}
1483
1484#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1485pub struct ChromeOsDeviceAction {
1486 #[serde(
1487 default,
1488 skip_serializing_if = "String::is_empty",
1489 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1490 )]
1491 pub action: String,
1492 #[serde(
1493 default,
1494 skip_serializing_if = "String::is_empty",
1495 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1496 rename = "deprovisionReason"
1497 )]
1498 pub deprovision_reason: String,
1499}
1500
1501#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1502pub struct ChromeOsDevices {
1503 #[serde(
1507 default,
1508 skip_serializing_if = "Vec::is_empty",
1509 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
1510 )]
1511 pub chromeosdevices: Vec<ChromeOsDevice>,
1512 #[serde(
1513 default,
1514 skip_serializing_if = "String::is_empty",
1515 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1516 )]
1517 pub etag: String,
1518 #[serde(
1519 default,
1520 skip_serializing_if = "String::is_empty",
1521 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1522 )]
1523 pub kind: String,
1524 #[serde(
1525 default,
1526 skip_serializing_if = "String::is_empty",
1527 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1528 rename = "nextPageToken"
1529 )]
1530 pub next_page_token: String,
1531}
1532
1533#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1534pub struct ChromeOsMoveDevicesOu {
1535 #[serde(
1536 default,
1537 skip_serializing_if = "Vec::is_empty",
1538 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
1539 rename = "deviceIds"
1540 )]
1541 pub device_ids: Vec<String>,
1542}
1543
1544#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1546pub struct CreatePrinterRequest {
1547 #[serde(
1551 default,
1552 skip_serializing_if = "String::is_empty",
1553 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1554 )]
1555 pub parent: String,
1556 #[serde(default, skip_serializing_if = "Option::is_none")]
1560 pub printer: Option<Printer>,
1561}
1562
1563#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1564pub struct Customer {
1565 #[serde(
1566 default,
1567 skip_serializing_if = "String::is_empty",
1568 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1569 rename = "alternateEmail"
1570 )]
1571 pub alternate_email: String,
1572 #[serde(
1576 default,
1577 skip_serializing_if = "Option::is_none",
1578 deserialize_with = "crate::utils::date_time_format::deserialize",
1579 rename = "customerCreationTime"
1580 )]
1581 pub customer_creation_time: Option<chrono::DateTime<chrono::Utc>>,
1582 #[serde(
1583 default,
1584 skip_serializing_if = "String::is_empty",
1585 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1586 rename = "customerDomain"
1587 )]
1588 pub customer_domain: String,
1589 #[serde(
1590 default,
1591 skip_serializing_if = "String::is_empty",
1592 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1593 )]
1594 pub etag: String,
1595 #[serde(
1596 default,
1597 skip_serializing_if = "String::is_empty",
1598 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1599 )]
1600 pub id: String,
1601 #[serde(
1602 default,
1603 skip_serializing_if = "String::is_empty",
1604 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1605 )]
1606 pub kind: String,
1607 #[serde(
1608 default,
1609 skip_serializing_if = "String::is_empty",
1610 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1611 )]
1612 pub language: String,
1613 #[serde(
1614 default,
1615 skip_serializing_if = "String::is_empty",
1616 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1617 rename = "phoneNumber"
1618 )]
1619 pub phone_number: String,
1620 #[serde(
1621 default,
1622 skip_serializing_if = "Option::is_none",
1623 rename = "postalAddress"
1624 )]
1625 pub postal_address: Option<CustomerPostalAddress>,
1626}
1627
1628#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1629pub struct CustomerPostalAddress {
1630 #[serde(
1631 default,
1632 skip_serializing_if = "String::is_empty",
1633 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1634 rename = "addressLine1"
1635 )]
1636 pub address_line_1: String,
1637 #[serde(
1638 default,
1639 skip_serializing_if = "String::is_empty",
1640 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1641 rename = "addressLine2"
1642 )]
1643 pub address_line_2: String,
1644 #[serde(
1645 default,
1646 skip_serializing_if = "String::is_empty",
1647 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1648 rename = "addressLine3"
1649 )]
1650 pub address_line_3: String,
1651 #[serde(
1652 default,
1653 skip_serializing_if = "String::is_empty",
1654 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1655 rename = "contactName"
1656 )]
1657 pub contact_name: String,
1658 #[serde(
1659 default,
1660 skip_serializing_if = "String::is_empty",
1661 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1662 rename = "countryCode"
1663 )]
1664 pub country_code: String,
1665 #[serde(
1666 default,
1667 skip_serializing_if = "String::is_empty",
1668 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1669 )]
1670 pub locality: String,
1671 #[serde(
1672 default,
1673 skip_serializing_if = "String::is_empty",
1674 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1675 rename = "organizationName"
1676 )]
1677 pub organization_name: String,
1678 #[serde(
1679 default,
1680 skip_serializing_if = "String::is_empty",
1681 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1682 rename = "postalCode"
1683 )]
1684 pub postal_code: String,
1685 #[serde(
1686 default,
1687 skip_serializing_if = "String::is_empty",
1688 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1689 )]
1690 pub region: String,
1691}
1692
1693#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
1697pub enum State {
1698 #[serde(rename = "ACKED_BY_CLIENT")]
1699 AckedByClient,
1700 #[serde(rename = "CANCELLED")]
1701 Cancelled,
1702 #[serde(rename = "EXECUTED_BY_CLIENT")]
1703 ExecutedByClient,
1704 #[serde(rename = "EXPIRED")]
1705 Expired,
1706 #[serde(rename = "PENDING")]
1707 Pending,
1708 #[serde(rename = "SENT_TO_CLIENT")]
1709 SentToClient,
1710 #[serde(rename = "STATE_UNSPECIFIED")]
1711 StateUnspecified,
1712 #[serde(rename = "")]
1713 #[default]
1714 Noop,
1715 #[serde(other)]
1716 FallthroughString,
1717}
1718
1719impl std::fmt::Display for State {
1720 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1721 match self {
1722 State::AckedByClient => "ACKED_BY_CLIENT",
1723 State::Cancelled => "CANCELLED",
1724 State::ExecutedByClient => "EXECUTED_BY_CLIENT",
1725 State::Expired => "EXPIRED",
1726 State::Pending => "PENDING",
1727 State::SentToClient => "SENT_TO_CLIENT",
1728 State::StateUnspecified => "STATE_UNSPECIFIED",
1729 State::Noop => "",
1730 State::FallthroughString => "*",
1731 }
1732 .fmt(f)
1733 }
1734}
1735
1736impl State {
1737 pub fn is_noop(&self) -> bool {
1738 matches!(self, State::Noop)
1739 }
1740}
1741
1742#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
1746pub enum Type {
1747 #[serde(rename = "COMMAND_TYPE_UNSPECIFIED")]
1748 CommandTypeUnspecified,
1749 #[serde(rename = "REBOOT")]
1750 Reboot,
1751 #[serde(rename = "REMOTE_POWERWASH")]
1752 RemotePowerwash,
1753 #[serde(rename = "SET_VOLUME")]
1754 SetVolume,
1755 #[serde(rename = "TAKE_A_SCREENSHOT")]
1756 TakeAScreenshot,
1757 #[serde(rename = "WIPE_USERS")]
1758 WipeUsers,
1759 #[serde(rename = "")]
1760 #[default]
1761 Noop,
1762 #[serde(other)]
1763 FallthroughString,
1764}
1765
1766impl std::fmt::Display for Type {
1767 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1768 match self {
1769 Type::CommandTypeUnspecified => "COMMAND_TYPE_UNSPECIFIED",
1770 Type::Reboot => "REBOOT",
1771 Type::RemotePowerwash => "REMOTE_POWERWASH",
1772 Type::SetVolume => "SET_VOLUME",
1773 Type::TakeAScreenshot => "TAKE_A_SCREENSHOT",
1774 Type::WipeUsers => "WIPE_USERS",
1775 Type::Noop => "",
1776 Type::FallthroughString => "*",
1777 }
1778 .fmt(f)
1779 }
1780}
1781
1782impl Type {
1783 pub fn is_noop(&self) -> bool {
1784 matches!(self, Type::Noop)
1785 }
1786}
1787
1788#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1790pub struct DirectoryChromeosdevicesCommand {
1791 #[serde(
1795 default,
1796 skip_serializing_if = "Option::is_none",
1797 deserialize_with = "crate::utils::date_time_format::deserialize",
1798 rename = "commandExpireTime"
1799 )]
1800 pub command_expire_time: Option<chrono::DateTime<chrono::Utc>>,
1801 #[serde(
1805 default,
1806 skip_serializing_if = "crate::utils::zero_i64",
1807 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
1808 rename = "commandId"
1809 )]
1810 pub command_id: i64,
1811 #[serde(
1815 default,
1816 skip_serializing_if = "Option::is_none",
1817 rename = "commandResult"
1818 )]
1819 pub command_result: Option<DirectoryChromeosdevicesCommandResult>,
1820 #[serde(
1824 default,
1825 skip_serializing_if = "Option::is_none",
1826 deserialize_with = "crate::utils::date_time_format::deserialize",
1827 rename = "issueTime"
1828 )]
1829 pub issue_time: Option<chrono::DateTime<chrono::Utc>>,
1830 #[serde(
1834 default,
1835 skip_serializing_if = "String::is_empty",
1836 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1837 )]
1838 pub payload: String,
1839 #[serde(default, skip_serializing_if = "Option::is_none")]
1843 pub state: Option<State>,
1844 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
1848 pub type_: Option<Type>,
1849}
1850
1851#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
1855pub enum Result {
1856 #[serde(rename = "COMMAND_RESULT_TYPE_UNSPECIFIED")]
1857 CommandResultTypeUnspecified,
1858 #[serde(rename = "FAILURE")]
1859 Failure,
1860 #[serde(rename = "IGNORED")]
1861 Ignored,
1862 #[serde(rename = "SUCCESS")]
1863 Success,
1864 #[serde(rename = "")]
1865 #[default]
1866 Noop,
1867 #[serde(other)]
1868 FallthroughString,
1869}
1870
1871impl std::fmt::Display for Result {
1872 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1873 match self {
1874 Result::CommandResultTypeUnspecified => "COMMAND_RESULT_TYPE_UNSPECIFIED",
1875 Result::Failure => "FAILURE",
1876 Result::Ignored => "IGNORED",
1877 Result::Success => "SUCCESS",
1878 Result::Noop => "",
1879 Result::FallthroughString => "*",
1880 }
1881 .fmt(f)
1882 }
1883}
1884
1885impl Result {
1886 pub fn is_noop(&self) -> bool {
1887 matches!(self, Result::Noop)
1888 }
1889}
1890
1891#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1893pub struct DirectoryChromeosdevicesCommandResult {
1894 #[serde(
1898 default,
1899 skip_serializing_if = "String::is_empty",
1900 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1901 rename = "errorMessage"
1902 )]
1903 pub error_message: String,
1904 #[serde(
1908 default,
1909 skip_serializing_if = "Option::is_none",
1910 deserialize_with = "crate::utils::date_time_format::deserialize",
1911 rename = "executeTime"
1912 )]
1913 pub execute_time: Option<chrono::DateTime<chrono::Utc>>,
1914 #[serde(default, skip_serializing_if = "Option::is_none")]
1918 pub result: Option<Result>,
1919}
1920
1921#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1923pub struct DirectoryChromeosdevicesIssueCommandRequest {
1924 #[serde(
1928 default,
1929 skip_serializing_if = "Option::is_none",
1930 rename = "commandType"
1931 )]
1932 pub command_type: Option<Type>,
1933 #[serde(
1937 default,
1938 skip_serializing_if = "String::is_empty",
1939 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1940 )]
1941 pub payload: String,
1942}
1943
1944#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1946pub struct DirectoryChromeosdevicesIssueCommandResponse {
1947 #[serde(
1951 default,
1952 skip_serializing_if = "crate::utils::zero_i64",
1953 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
1954 rename = "commandId"
1955 )]
1956 pub command_id: i64,
1957}
1958
1959#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1960pub struct DomainAlias {
1961 #[serde(
1965 default,
1966 skip_serializing_if = "crate::utils::zero_i64",
1967 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
1968 rename = "creationTime"
1969 )]
1970 pub creation_time: i64,
1971 #[serde(
1972 default,
1973 skip_serializing_if = "String::is_empty",
1974 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1975 rename = "domainAliasName"
1976 )]
1977 pub domain_alias_name: String,
1978 #[serde(
1979 default,
1980 skip_serializing_if = "String::is_empty",
1981 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1982 )]
1983 pub etag: String,
1984 #[serde(
1985 default,
1986 skip_serializing_if = "String::is_empty",
1987 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1988 )]
1989 pub kind: String,
1990 #[serde(
1991 default,
1992 skip_serializing_if = "String::is_empty",
1993 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1994 rename = "parentDomainName"
1995 )]
1996 pub parent_domain_name: String,
1997 #[serde(
2001 default,
2002 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
2003 )]
2004 pub verified: bool,
2005}
2006
2007#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2008pub struct DomainAliases {
2009 #[serde(
2013 default,
2014 skip_serializing_if = "Vec::is_empty",
2015 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
2016 rename = "domainAliases"
2017 )]
2018 pub domain_aliases: Vec<DomainAlias>,
2019 #[serde(
2020 default,
2021 skip_serializing_if = "String::is_empty",
2022 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2023 )]
2024 pub etag: String,
2025 #[serde(
2026 default,
2027 skip_serializing_if = "String::is_empty",
2028 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2029 )]
2030 pub kind: String,
2031}
2032
2033#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2034pub struct Domains {
2035 #[serde(
2039 default,
2040 skip_serializing_if = "crate::utils::zero_i64",
2041 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
2042 rename = "creationTime"
2043 )]
2044 pub creation_time: i64,
2045 #[serde(
2049 default,
2050 skip_serializing_if = "Vec::is_empty",
2051 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
2052 rename = "domainAliases"
2053 )]
2054 pub domain_aliases: Vec<DomainAlias>,
2055 #[serde(
2056 default,
2057 skip_serializing_if = "String::is_empty",
2058 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2059 rename = "domainName"
2060 )]
2061 pub domain_name: String,
2062 #[serde(
2063 default,
2064 skip_serializing_if = "String::is_empty",
2065 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2066 )]
2067 pub etag: String,
2068 #[serde(
2072 default,
2073 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
2074 rename = "isPrimary"
2075 )]
2076 pub is_primary: bool,
2077 #[serde(
2078 default,
2079 skip_serializing_if = "String::is_empty",
2080 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2081 )]
2082 pub kind: String,
2083 #[serde(
2087 default,
2088 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
2089 )]
2090 pub verified: bool,
2091}
2092
2093#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2094pub struct Domains2 {
2095 #[serde(
2099 default,
2100 skip_serializing_if = "Vec::is_empty",
2101 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
2102 )]
2103 pub domains: Vec<Domains>,
2104 #[serde(
2105 default,
2106 skip_serializing_if = "String::is_empty",
2107 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2108 )]
2109 pub etag: String,
2110 #[serde(
2111 default,
2112 skip_serializing_if = "String::is_empty",
2113 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2114 )]
2115 pub kind: String,
2116}
2117
2118#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2120pub struct Empty {}
2121
2122#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
2126pub enum ErrorCode {
2127 #[serde(rename = "ABORTED")]
2128 Aborted,
2129 #[serde(rename = "ALREADY_EXISTS")]
2130 AlreadyExists,
2131 #[serde(rename = "CANCELLED")]
2132 Cancelled,
2133 #[serde(rename = "DATA_LOSS")]
2134 DataLoss,
2135 #[serde(rename = "DEADLINE_EXCEEDED")]
2136 DeadlineExceeded,
2137 #[serde(rename = "FAILED_PRECONDITION")]
2138 FailedPrecondition,
2139 #[serde(rename = "INTERNAL")]
2140 Internal,
2141 #[serde(rename = "INVALID_ARGUMENT")]
2142 InvalidArgument,
2143 #[serde(rename = "NOT_FOUND")]
2144 NotFound,
2145 #[serde(rename = "OK")]
2146 Ok,
2147 #[serde(rename = "OUT_OF_RANGE")]
2148 OutOfRange,
2149 #[serde(rename = "PERMISSION_DENIED")]
2150 PermissionDenied,
2151 #[serde(rename = "RESOURCE_EXHAUSTED")]
2152 ResourceExhausted,
2153 #[serde(rename = "UNAUTHENTICATED")]
2154 Unauthenticated,
2155 #[serde(rename = "UNAVAILABLE")]
2156 Unavailable,
2157 #[serde(rename = "UNIMPLEMENTED")]
2158 Unimplemented,
2159 #[serde(rename = "UNKNOWN")]
2160 Unknown,
2161 #[serde(rename = "")]
2162 #[default]
2163 Noop,
2164 #[serde(other)]
2165 FallthroughString,
2166}
2167
2168impl std::fmt::Display for ErrorCode {
2169 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2170 match self {
2171 ErrorCode::Aborted => "ABORTED",
2172 ErrorCode::AlreadyExists => "ALREADY_EXISTS",
2173 ErrorCode::Cancelled => "CANCELLED",
2174 ErrorCode::DataLoss => "DATA_LOSS",
2175 ErrorCode::DeadlineExceeded => "DEADLINE_EXCEEDED",
2176 ErrorCode::FailedPrecondition => "FAILED_PRECONDITION",
2177 ErrorCode::Internal => "INTERNAL",
2178 ErrorCode::InvalidArgument => "INVALID_ARGUMENT",
2179 ErrorCode::NotFound => "NOT_FOUND",
2180 ErrorCode::Ok => "OK",
2181 ErrorCode::OutOfRange => "OUT_OF_RANGE",
2182 ErrorCode::PermissionDenied => "PERMISSION_DENIED",
2183 ErrorCode::ResourceExhausted => "RESOURCE_EXHAUSTED",
2184 ErrorCode::Unauthenticated => "UNAUTHENTICATED",
2185 ErrorCode::Unavailable => "UNAVAILABLE",
2186 ErrorCode::Unimplemented => "UNIMPLEMENTED",
2187 ErrorCode::Unknown => "UNKNOWN",
2188 ErrorCode::Noop => "",
2189 ErrorCode::FallthroughString => "*",
2190 }
2191 .fmt(f)
2192 }
2193}
2194
2195impl ErrorCode {
2196 pub fn is_noop(&self) -> bool {
2197 matches!(self, ErrorCode::Noop)
2198 }
2199}
2200
2201#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2203pub struct FailureInfo {
2204 #[serde(default, skip_serializing_if = "Option::is_none", rename = "errorCode")]
2208 pub error_code: Option<ErrorCode>,
2209 #[serde(
2213 default,
2214 skip_serializing_if = "String::is_empty",
2215 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2216 rename = "errorMessage"
2217 )]
2218 pub error_message: String,
2219 #[serde(default, skip_serializing_if = "Option::is_none")]
2223 pub printer: Option<Printer>,
2224 #[serde(
2228 default,
2229 skip_serializing_if = "String::is_empty",
2230 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2231 rename = "printerId"
2232 )]
2233 pub printer_id: String,
2234}
2235
2236#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2238pub struct Feature {
2239 #[serde(
2243 default,
2244 skip_serializing_if = "String::is_empty",
2245 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2246 )]
2247 pub etags: String,
2248 #[serde(
2252 default,
2253 skip_serializing_if = "String::is_empty",
2254 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2255 )]
2256 pub kind: String,
2257 #[serde(
2261 default,
2262 skip_serializing_if = "String::is_empty",
2263 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2264 )]
2265 pub name: String,
2266}
2267
2268#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2270pub struct FeatureInstance {
2271 #[serde(default, skip_serializing_if = "Option::is_none")]
2275 pub feature: Option<Feature>,
2276}
2277
2278#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2279pub struct FeatureRename {
2280 #[serde(
2281 default,
2282 skip_serializing_if = "String::is_empty",
2283 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2284 rename = "newName"
2285 )]
2286 pub new_name: String,
2287}
2288
2289#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2291pub struct Features {
2292 #[serde(
2296 default,
2297 skip_serializing_if = "String::is_empty",
2298 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2299 )]
2300 pub etag: String,
2301 #[serde(
2305 default,
2306 skip_serializing_if = "Vec::is_empty",
2307 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
2308 )]
2309 pub features: Vec<Feature>,
2310 #[serde(
2314 default,
2315 skip_serializing_if = "String::is_empty",
2316 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2317 )]
2318 pub kind: String,
2319 #[serde(
2323 default,
2324 skip_serializing_if = "String::is_empty",
2325 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2326 rename = "nextPageToken"
2327 )]
2328 pub next_page_token: String,
2329}
2330
2331#[derive(Serialize, Default, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2333pub struct Group {
2334 #[serde(
2338 default,
2339 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
2340 rename = "adminCreated"
2341 )]
2342 pub admin_created: bool,
2343 #[serde(
2347 default,
2348 skip_serializing_if = "Vec::is_empty",
2349 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
2350 )]
2351 pub aliases: Vec<String>,
2352 #[serde(
2356 default,
2357 skip_serializing_if = "String::is_empty",
2358 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2359 )]
2360 pub description: String,
2361 #[serde(
2365 default,
2366 skip_serializing_if = "crate::utils::zero_i64",
2367 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
2368 rename = "directMembersCount"
2369 )]
2370 pub direct_members_count: i64,
2371 #[serde(
2375 default,
2376 skip_serializing_if = "String::is_empty",
2377 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2378 )]
2379 pub email: String,
2380 #[serde(
2384 default,
2385 skip_serializing_if = "String::is_empty",
2386 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2387 )]
2388 pub etag: String,
2389 #[serde(
2393 default,
2394 skip_serializing_if = "String::is_empty",
2395 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2396 )]
2397 pub id: String,
2398 #[serde(
2402 default,
2403 skip_serializing_if = "String::is_empty",
2404 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2405 )]
2406 pub kind: String,
2407 #[serde(
2411 default,
2412 skip_serializing_if = "String::is_empty",
2413 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2414 )]
2415 pub name: String,
2416 #[serde(
2420 default,
2421 skip_serializing_if = "Vec::is_empty",
2422 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
2423 rename = "nonEditableAliases"
2424 )]
2425 pub non_editable_aliases: Vec<String>,
2426}
2427
2428#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2429pub struct Groups {
2430 #[serde(
2431 default,
2432 skip_serializing_if = "String::is_empty",
2433 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2434 )]
2435 pub etag: String,
2436 #[serde(
2440 default,
2441 skip_serializing_if = "Vec::is_empty",
2442 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
2443 )]
2444 pub groups: Vec<Group>,
2445 #[serde(
2446 default,
2447 skip_serializing_if = "String::is_empty",
2448 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2449 )]
2450 pub kind: String,
2451 #[serde(
2452 default,
2453 skip_serializing_if = "String::is_empty",
2454 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2455 rename = "nextPageToken"
2456 )]
2457 pub next_page_token: String,
2458}
2459
2460#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2462pub struct ListPrinterModelsResponse {
2463 #[serde(
2467 default,
2468 skip_serializing_if = "String::is_empty",
2469 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2470 rename = "nextPageToken"
2471 )]
2472 pub next_page_token: String,
2473 #[serde(
2477 default,
2478 skip_serializing_if = "Vec::is_empty",
2479 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
2480 rename = "printerModels"
2481 )]
2482 pub printer_models: Vec<PrinterModel>,
2483}
2484
2485#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2487pub struct ListPrintersResponse {
2488 #[serde(
2492 default,
2493 skip_serializing_if = "String::is_empty",
2494 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2495 rename = "nextPageToken"
2496 )]
2497 pub next_page_token: String,
2498 #[serde(
2502 default,
2503 skip_serializing_if = "Vec::is_empty",
2504 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
2505 )]
2506 pub printers: Vec<Printer>,
2507}
2508
2509#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2511pub struct Member {
2512 #[serde(
2516 default,
2517 skip_serializing_if = "String::is_empty",
2518 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2519 )]
2520 pub delivery_settings: String,
2521 #[serde(
2525 default,
2526 skip_serializing_if = "String::is_empty",
2527 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2528 )]
2529 pub email: String,
2530 #[serde(
2534 default,
2535 skip_serializing_if = "String::is_empty",
2536 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2537 )]
2538 pub etag: String,
2539 #[serde(
2543 default,
2544 skip_serializing_if = "String::is_empty",
2545 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2546 )]
2547 pub id: String,
2548 #[serde(
2552 default,
2553 skip_serializing_if = "String::is_empty",
2554 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2555 )]
2556 pub kind: String,
2557 #[serde(
2561 default,
2562 skip_serializing_if = "String::is_empty",
2563 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2564 )]
2565 pub role: String,
2566 #[serde(
2570 default,
2571 skip_serializing_if = "String::is_empty",
2572 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2573 )]
2574 pub status: String,
2575 #[serde(
2579 default,
2580 skip_serializing_if = "String::is_empty",
2581 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2582 rename = "type"
2583 )]
2584 pub type_: String,
2585}
2586
2587#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2588pub struct Members {
2589 #[serde(
2590 default,
2591 skip_serializing_if = "String::is_empty",
2592 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2593 )]
2594 pub etag: String,
2595 #[serde(
2596 default,
2597 skip_serializing_if = "String::is_empty",
2598 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2599 )]
2600 pub kind: String,
2601 #[serde(
2605 default,
2606 skip_serializing_if = "Vec::is_empty",
2607 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
2608 )]
2609 pub members: Vec<Member>,
2610 #[serde(
2611 default,
2612 skip_serializing_if = "String::is_empty",
2613 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2614 rename = "nextPageToken"
2615 )]
2616 pub next_page_token: String,
2617}
2618
2619#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2621pub struct MembersHasMember {
2622 #[serde(
2626 default,
2627 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
2628 rename = "isMember"
2629 )]
2630 pub is_member: bool,
2631}
2632
2633#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2634pub struct Applications {
2635 #[serde(
2636 default,
2637 skip_serializing_if = "String::is_empty",
2638 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2639 rename = "displayName"
2640 )]
2641 pub display_name: String,
2642 #[serde(
2643 default,
2644 skip_serializing_if = "String::is_empty",
2645 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2646 rename = "packageName"
2647 )]
2648 pub package_name: String,
2649 #[serde(
2650 default,
2651 skip_serializing_if = "Vec::is_empty",
2652 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
2653 )]
2654 pub permission: Vec<String>,
2655 #[serde(
2659 default,
2660 skip_serializing_if = "crate::utils::zero_i64",
2661 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
2662 rename = "versionCode"
2663 )]
2664 pub version_code: i64,
2665 #[serde(
2666 default,
2667 skip_serializing_if = "String::is_empty",
2668 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2669 rename = "versionName"
2670 )]
2671 pub version_name: String,
2672}
2673
2674#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2676pub struct MobileDevice {
2677 #[serde(
2681 default,
2682 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
2683 rename = "adbStatus"
2684 )]
2685 pub adb_status: bool,
2686 #[serde(
2690 default,
2691 skip_serializing_if = "Vec::is_empty",
2692 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
2693 )]
2694 pub applications: Vec<Applications>,
2695 #[serde(
2699 default,
2700 skip_serializing_if = "String::is_empty",
2701 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2702 rename = "basebandVersion"
2703 )]
2704 pub baseband_version: String,
2705 #[serde(
2709 default,
2710 skip_serializing_if = "String::is_empty",
2711 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2712 rename = "bootloaderVersion"
2713 )]
2714 pub bootloader_version: String,
2715 #[serde(
2719 default,
2720 skip_serializing_if = "String::is_empty",
2721 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2722 )]
2723 pub brand: String,
2724 #[serde(
2728 default,
2729 skip_serializing_if = "String::is_empty",
2730 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2731 rename = "buildNumber"
2732 )]
2733 pub build_number: String,
2734 #[serde(
2738 default,
2739 skip_serializing_if = "String::is_empty",
2740 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2741 rename = "defaultLanguage"
2742 )]
2743 pub default_language: String,
2744 #[serde(
2748 default,
2749 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
2750 rename = "developerOptionsStatus"
2751 )]
2752 pub developer_options_status: bool,
2753 #[serde(
2757 default,
2758 skip_serializing_if = "String::is_empty",
2759 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2760 rename = "deviceCompromisedStatus"
2761 )]
2762 pub device_compromised_status: String,
2763 #[serde(
2767 default,
2768 skip_serializing_if = "String::is_empty",
2769 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2770 rename = "deviceId"
2771 )]
2772 pub device_id: String,
2773 #[serde(
2777 default,
2778 skip_serializing_if = "String::is_empty",
2779 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2780 rename = "devicePasswordStatus"
2781 )]
2782 pub device_password_status: String,
2783 #[serde(
2787 default,
2788 skip_serializing_if = "Vec::is_empty",
2789 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
2790 )]
2791 pub email: Vec<String>,
2792 #[serde(
2796 default,
2797 skip_serializing_if = "String::is_empty",
2798 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2799 rename = "encryptionStatus"
2800 )]
2801 pub encryption_status: String,
2802 #[serde(
2806 default,
2807 skip_serializing_if = "String::is_empty",
2808 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2809 )]
2810 pub etag: String,
2811 #[serde(
2815 default,
2816 skip_serializing_if = "Option::is_none",
2817 deserialize_with = "crate::utils::date_time_format::deserialize",
2818 rename = "firstSync"
2819 )]
2820 pub first_sync: Option<chrono::DateTime<chrono::Utc>>,
2821 #[serde(
2825 default,
2826 skip_serializing_if = "String::is_empty",
2827 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2828 )]
2829 pub hardware: String,
2830 #[serde(
2834 default,
2835 skip_serializing_if = "String::is_empty",
2836 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2837 rename = "hardwareId"
2838 )]
2839 pub hardware_id: String,
2840 #[serde(
2844 default,
2845 skip_serializing_if = "String::is_empty",
2846 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2847 )]
2848 pub imei: String,
2849 #[serde(
2853 default,
2854 skip_serializing_if = "String::is_empty",
2855 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2856 rename = "kernelVersion"
2857 )]
2858 pub kernel_version: String,
2859 #[serde(
2863 default,
2864 skip_serializing_if = "String::is_empty",
2865 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2866 )]
2867 pub kind: String,
2868 #[serde(
2872 default,
2873 skip_serializing_if = "Option::is_none",
2874 deserialize_with = "crate::utils::date_time_format::deserialize",
2875 rename = "lastSync"
2876 )]
2877 pub last_sync: Option<chrono::DateTime<chrono::Utc>>,
2878 #[serde(
2882 default,
2883 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
2884 rename = "managedAccountIsOnOwnerProfile"
2885 )]
2886 pub managed_account_is_on_owner_profile: bool,
2887 #[serde(
2891 default,
2892 skip_serializing_if = "String::is_empty",
2893 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2894 )]
2895 pub manufacturer: String,
2896 #[serde(
2900 default,
2901 skip_serializing_if = "String::is_empty",
2902 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2903 )]
2904 pub meid: String,
2905 #[serde(
2909 default,
2910 skip_serializing_if = "String::is_empty",
2911 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2912 )]
2913 pub model: String,
2914 #[serde(
2918 default,
2919 skip_serializing_if = "Vec::is_empty",
2920 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
2921 )]
2922 pub name: Vec<String>,
2923 #[serde(
2927 default,
2928 skip_serializing_if = "String::is_empty",
2929 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2930 rename = "networkOperator"
2931 )]
2932 pub network_operator: String,
2933 #[serde(
2937 default,
2938 skip_serializing_if = "String::is_empty",
2939 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2940 )]
2941 pub os: String,
2942 #[serde(
2946 default,
2947 skip_serializing_if = "Vec::is_empty",
2948 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
2949 rename = "otherAccountsInfo"
2950 )]
2951 pub other_accounts_info: Vec<String>,
2952 #[serde(
2956 default,
2957 skip_serializing_if = "String::is_empty",
2958 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2959 )]
2960 pub privilege: String,
2961 #[serde(
2965 default,
2966 skip_serializing_if = "String::is_empty",
2967 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2968 rename = "releaseVersion"
2969 )]
2970 pub release_version: String,
2971 #[serde(
2975 default,
2976 skip_serializing_if = "String::is_empty",
2977 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2978 rename = "resourceId"
2979 )]
2980 pub resource_id: String,
2981 #[serde(
2985 default,
2986 skip_serializing_if = "crate::utils::zero_i64",
2987 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
2988 rename = "securityPatchLevel"
2989 )]
2990 pub security_patch_level: i64,
2991 #[serde(
2995 default,
2996 skip_serializing_if = "String::is_empty",
2997 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
2998 rename = "serialNumber"
2999 )]
3000 pub serial_number: String,
3001 #[serde(
3005 default,
3006 skip_serializing_if = "String::is_empty",
3007 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3008 )]
3009 pub status: String,
3010 #[serde(
3014 default,
3015 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
3016 rename = "supportsWorkProfile"
3017 )]
3018 pub supports_work_profile: bool,
3019 #[serde(
3023 default,
3024 skip_serializing_if = "String::is_empty",
3025 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3026 rename = "type"
3027 )]
3028 pub type_: String,
3029 #[serde(
3033 default,
3034 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
3035 rename = "unknownSourcesStatus"
3036 )]
3037 pub unknown_sources_status: bool,
3038 #[serde(
3042 default,
3043 skip_serializing_if = "String::is_empty",
3044 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3045 rename = "userAgent"
3046 )]
3047 pub user_agent: String,
3048 #[serde(
3052 default,
3053 skip_serializing_if = "String::is_empty",
3054 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3055 rename = "wifiMacAddress"
3056 )]
3057 pub wifi_mac_address: String,
3058}
3059
3060#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3061pub struct MobileDeviceAction {
3062 #[serde(
3063 default,
3064 skip_serializing_if = "String::is_empty",
3065 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3066 )]
3067 pub action: String,
3068}
3069
3070#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3071pub struct MobileDevices {
3072 #[serde(
3073 default,
3074 skip_serializing_if = "String::is_empty",
3075 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3076 )]
3077 pub etag: String,
3078 #[serde(
3079 default,
3080 skip_serializing_if = "String::is_empty",
3081 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3082 )]
3083 pub kind: String,
3084 #[serde(
3088 default,
3089 skip_serializing_if = "Vec::is_empty",
3090 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3091 )]
3092 pub mobiledevices: Vec<MobileDevice>,
3093 #[serde(
3094 default,
3095 skip_serializing_if = "String::is_empty",
3096 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3097 rename = "nextPageToken"
3098 )]
3099 pub next_page_token: String,
3100}
3101
3102#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3104pub struct OrgUnit {
3105 #[serde(
3109 default,
3110 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
3111 rename = "blockInheritance"
3112 )]
3113 pub block_inheritance: bool,
3114 #[serde(
3118 default,
3119 skip_serializing_if = "String::is_empty",
3120 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3121 )]
3122 pub description: String,
3123 #[serde(
3127 default,
3128 skip_serializing_if = "String::is_empty",
3129 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3130 )]
3131 pub etag: String,
3132 #[serde(
3136 default,
3137 skip_serializing_if = "String::is_empty",
3138 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3139 )]
3140 pub kind: String,
3141 #[serde(
3145 default,
3146 skip_serializing_if = "String::is_empty",
3147 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3148 )]
3149 pub name: String,
3150 #[serde(
3154 default,
3155 skip_serializing_if = "String::is_empty",
3156 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3157 rename = "orgUnitId"
3158 )]
3159 pub org_unit_id: String,
3160 #[serde(
3164 default,
3165 skip_serializing_if = "String::is_empty",
3166 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3167 rename = "orgUnitPath"
3168 )]
3169 pub org_unit_path: String,
3170 #[serde(
3174 default,
3175 skip_serializing_if = "String::is_empty",
3176 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3177 rename = "parentOrgUnitId"
3178 )]
3179 pub parent_org_unit_id: String,
3180 #[serde(
3184 default,
3185 skip_serializing_if = "String::is_empty",
3186 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3187 rename = "parentOrgUnitPath"
3188 )]
3189 pub parent_org_unit_path: String,
3190}
3191
3192#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3193pub struct OrgUnits {
3194 #[serde(
3195 default,
3196 skip_serializing_if = "String::is_empty",
3197 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3198 )]
3199 pub etag: String,
3200 #[serde(
3201 default,
3202 skip_serializing_if = "String::is_empty",
3203 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3204 )]
3205 pub kind: String,
3206 #[serde(
3210 default,
3211 skip_serializing_if = "Vec::is_empty",
3212 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
3213 rename = "organizationUnits"
3214 )]
3215 pub organization_units: Vec<OrgUnit>,
3216}
3217
3218#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3220pub struct Printer {
3221 #[serde(
3225 default,
3226 skip_serializing_if = "Vec::is_empty",
3227 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
3228 rename = "auxiliaryMessages"
3229 )]
3230 pub auxiliary_messages: Vec<AuxiliaryMessage>,
3231 #[serde(
3235 default,
3236 skip_serializing_if = "Option::is_none",
3237 deserialize_with = "crate::utils::date_time_format::deserialize",
3238 rename = "createTime"
3239 )]
3240 pub create_time: Option<chrono::DateTime<chrono::Utc>>,
3241 #[serde(
3245 default,
3246 skip_serializing_if = "String::is_empty",
3247 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3248 )]
3249 pub description: String,
3250 #[serde(
3254 default,
3255 skip_serializing_if = "String::is_empty",
3256 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3257 rename = "displayName"
3258 )]
3259 pub display_name: String,
3260 #[serde(
3264 default,
3265 skip_serializing_if = "String::is_empty",
3266 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3267 )]
3268 pub id: String,
3269 #[serde(
3273 default,
3274 skip_serializing_if = "String::is_empty",
3275 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3276 rename = "makeAndModel"
3277 )]
3278 pub make_and_model: String,
3279 #[serde(
3283 default,
3284 skip_serializing_if = "String::is_empty",
3285 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3286 )]
3287 pub name: String,
3288 #[serde(
3292 default,
3293 skip_serializing_if = "String::is_empty",
3294 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3295 rename = "orgUnitId"
3296 )]
3297 pub org_unit_id: String,
3298 #[serde(
3302 default,
3303 skip_serializing_if = "String::is_empty",
3304 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3305 )]
3306 pub uri: String,
3307 #[serde(
3311 default,
3312 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
3313 rename = "useDriverlessConfig"
3314 )]
3315 pub use_driverless_config: bool,
3316}
3317
3318#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3320pub struct PrinterModel {
3321 #[serde(
3325 default,
3326 skip_serializing_if = "String::is_empty",
3327 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3328 rename = "displayName"
3329 )]
3330 pub display_name: String,
3331 #[serde(
3335 default,
3336 skip_serializing_if = "String::is_empty",
3337 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3338 rename = "makeAndModel"
3339 )]
3340 pub make_and_model: String,
3341 #[serde(
3345 default,
3346 skip_serializing_if = "String::is_empty",
3347 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3348 )]
3349 pub manufacturer: String,
3350}
3351
3352#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3353pub struct Privilege {
3354 #[serde(
3358 default,
3359 skip_serializing_if = "Vec::is_empty",
3360 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
3361 rename = "childPrivileges"
3362 )]
3363 pub child_privileges: Vec<Privilege>,
3364 #[serde(
3365 default,
3366 skip_serializing_if = "String::is_empty",
3367 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3368 )]
3369 pub etag: String,
3370 #[serde(
3374 default,
3375 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
3376 rename = "isOuScopable"
3377 )]
3378 pub is_ou_scopable: bool,
3379 #[serde(
3380 default,
3381 skip_serializing_if = "String::is_empty",
3382 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3383 )]
3384 pub kind: String,
3385 #[serde(
3386 default,
3387 skip_serializing_if = "String::is_empty",
3388 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3389 rename = "privilegeName"
3390 )]
3391 pub privilege_name: String,
3392 #[serde(
3393 default,
3394 skip_serializing_if = "String::is_empty",
3395 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3396 rename = "serviceId"
3397 )]
3398 pub service_id: String,
3399 #[serde(
3400 default,
3401 skip_serializing_if = "String::is_empty",
3402 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3403 rename = "serviceName"
3404 )]
3405 pub service_name: String,
3406}
3407
3408#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3409pub struct Privileges {
3410 #[serde(
3411 default,
3412 skip_serializing_if = "String::is_empty",
3413 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3414 )]
3415 pub etag: String,
3416 #[serde(
3420 default,
3421 skip_serializing_if = "Vec::is_empty",
3422 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3423 )]
3424 pub items: Vec<Privilege>,
3425 #[serde(
3426 default,
3427 skip_serializing_if = "String::is_empty",
3428 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3429 )]
3430 pub kind: String,
3431}
3432
3433#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3434pub struct RolePrivileges {
3435 #[serde(
3436 default,
3437 skip_serializing_if = "String::is_empty",
3438 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3439 rename = "privilegeName"
3440 )]
3441 pub privilege_name: String,
3442 #[serde(
3443 default,
3444 skip_serializing_if = "String::is_empty",
3445 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3446 rename = "serviceId"
3447 )]
3448 pub service_id: String,
3449}
3450
3451#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3452pub struct Role {
3453 #[serde(
3454 default,
3455 skip_serializing_if = "String::is_empty",
3456 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3457 )]
3458 pub etag: String,
3459 #[serde(
3463 default,
3464 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
3465 rename = "isSuperAdminRole"
3466 )]
3467 pub is_super_admin_role: bool,
3468 #[serde(
3472 default,
3473 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
3474 rename = "isSystemRole"
3475 )]
3476 pub is_system_role: bool,
3477 #[serde(
3478 default,
3479 skip_serializing_if = "String::is_empty",
3480 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3481 )]
3482 pub kind: String,
3483 #[serde(
3484 default,
3485 skip_serializing_if = "String::is_empty",
3486 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3487 rename = "roleDescription"
3488 )]
3489 pub role_description: String,
3490 #[serde(
3494 default,
3495 skip_serializing_if = "crate::utils::zero_i64",
3496 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
3497 rename = "roleId"
3498 )]
3499 pub role_id: i64,
3500 #[serde(
3501 default,
3502 skip_serializing_if = "String::is_empty",
3503 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3504 rename = "roleName"
3505 )]
3506 pub role_name: String,
3507 #[serde(
3511 default,
3512 skip_serializing_if = "Vec::is_empty",
3513 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
3514 rename = "rolePrivileges"
3515 )]
3516 pub role_privileges: Vec<RolePrivileges>,
3517}
3518
3519#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3521pub struct RoleAssignment {
3522 #[serde(
3526 default,
3527 skip_serializing_if = "String::is_empty",
3528 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3529 rename = "assignedTo"
3530 )]
3531 pub assigned_to: String,
3532 #[serde(
3536 default,
3537 skip_serializing_if = "String::is_empty",
3538 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3539 )]
3540 pub etag: String,
3541 #[serde(
3545 default,
3546 skip_serializing_if = "String::is_empty",
3547 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3548 )]
3549 pub kind: String,
3550 #[serde(
3554 default,
3555 skip_serializing_if = "String::is_empty",
3556 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3557 rename = "orgUnitId"
3558 )]
3559 pub org_unit_id: String,
3560 #[serde(
3564 default,
3565 skip_serializing_if = "crate::utils::zero_i64",
3566 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
3567 rename = "roleAssignmentId"
3568 )]
3569 pub role_assignment_id: i64,
3570 #[serde(
3574 default,
3575 skip_serializing_if = "crate::utils::zero_i64",
3576 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
3577 rename = "roleId"
3578 )]
3579 pub role_id: i64,
3580 #[serde(
3584 default,
3585 skip_serializing_if = "String::is_empty",
3586 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3587 rename = "scopeType"
3588 )]
3589 pub scope_type: String,
3590}
3591
3592#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3593pub struct RoleAssignments {
3594 #[serde(
3595 default,
3596 skip_serializing_if = "String::is_empty",
3597 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3598 )]
3599 pub etag: String,
3600 #[serde(
3604 default,
3605 skip_serializing_if = "Vec::is_empty",
3606 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3607 )]
3608 pub items: Vec<RoleAssignment>,
3609 #[serde(
3610 default,
3611 skip_serializing_if = "String::is_empty",
3612 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3613 )]
3614 pub kind: String,
3615 #[serde(
3616 default,
3617 skip_serializing_if = "String::is_empty",
3618 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3619 rename = "nextPageToken"
3620 )]
3621 pub next_page_token: String,
3622}
3623
3624#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3625pub struct Roles {
3626 #[serde(
3627 default,
3628 skip_serializing_if = "String::is_empty",
3629 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3630 )]
3631 pub etag: String,
3632 #[serde(
3636 default,
3637 skip_serializing_if = "Vec::is_empty",
3638 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3639 )]
3640 pub items: Vec<Role>,
3641 #[serde(
3642 default,
3643 skip_serializing_if = "String::is_empty",
3644 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3645 )]
3646 pub kind: String,
3647 #[serde(
3648 default,
3649 skip_serializing_if = "String::is_empty",
3650 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3651 rename = "nextPageToken"
3652 )]
3653 pub next_page_token: String,
3654}
3655
3656#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3658pub struct Schema {
3659 #[serde(
3663 default,
3664 skip_serializing_if = "String::is_empty",
3665 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3666 rename = "displayName"
3667 )]
3668 pub display_name: String,
3669 #[serde(
3673 default,
3674 skip_serializing_if = "String::is_empty",
3675 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3676 )]
3677 pub etag: String,
3678 #[serde(
3682 default,
3683 skip_serializing_if = "Vec::is_empty",
3684 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3685 )]
3686 pub fields: Vec<SchemaFieldSpec>,
3687 #[serde(
3691 default,
3692 skip_serializing_if = "String::is_empty",
3693 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3694 )]
3695 pub kind: String,
3696 #[serde(
3700 default,
3701 skip_serializing_if = "String::is_empty",
3702 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3703 rename = "schemaId"
3704 )]
3705 pub schema_id: String,
3706 #[serde(
3710 default,
3711 skip_serializing_if = "String::is_empty",
3712 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3713 rename = "schemaName"
3714 )]
3715 pub schema_name: String,
3716}
3717
3718#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3720pub struct NumericIndexingSpec {
3721 #[serde(
3725 default,
3726 skip_serializing_if = "crate::utils::zero_f64",
3727 deserialize_with = "crate::utils::deserialize_null_f64::deserialize",
3728 rename = "maxValue"
3729 )]
3730 pub max_value: f64,
3731 #[serde(
3735 default,
3736 skip_serializing_if = "crate::utils::zero_f64",
3737 deserialize_with = "crate::utils::deserialize_null_f64::deserialize",
3738 rename = "minValue"
3739 )]
3740 pub min_value: f64,
3741}
3742
3743#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3745pub struct SchemaFieldSpec {
3746 #[serde(
3750 default,
3751 skip_serializing_if = "String::is_empty",
3752 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3753 rename = "displayName"
3754 )]
3755 pub display_name: String,
3756 #[serde(
3760 default,
3761 skip_serializing_if = "String::is_empty",
3762 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3763 )]
3764 pub etag: String,
3765 #[serde(
3769 default,
3770 skip_serializing_if = "String::is_empty",
3771 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3772 rename = "fieldId"
3773 )]
3774 pub field_id: String,
3775 #[serde(
3779 default,
3780 skip_serializing_if = "String::is_empty",
3781 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3782 rename = "fieldName"
3783 )]
3784 pub field_name: String,
3785 #[serde(
3789 default,
3790 skip_serializing_if = "String::is_empty",
3791 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3792 rename = "fieldType"
3793 )]
3794 pub field_type: String,
3795 #[serde(
3799 default,
3800 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3801 )]
3802 pub indexed: bool,
3803 #[serde(
3807 default,
3808 skip_serializing_if = "String::is_empty",
3809 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3810 )]
3811 pub kind: String,
3812 #[serde(
3816 default,
3817 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
3818 rename = "multiValued"
3819 )]
3820 pub multi_valued: bool,
3821 #[serde(
3825 default,
3826 skip_serializing_if = "Option::is_none",
3827 rename = "numericIndexingSpec"
3828 )]
3829 pub numeric_indexing_spec: Option<NumericIndexingSpec>,
3830 #[serde(
3834 default,
3835 skip_serializing_if = "String::is_empty",
3836 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3837 rename = "readAccessType"
3838 )]
3839 pub read_access_type: String,
3840}
3841
3842#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3844pub struct Schemas {
3845 #[serde(
3849 default,
3850 skip_serializing_if = "String::is_empty",
3851 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3852 )]
3853 pub etag: String,
3854 #[serde(
3858 default,
3859 skip_serializing_if = "String::is_empty",
3860 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3861 )]
3862 pub kind: String,
3863 #[serde(
3867 default,
3868 skip_serializing_if = "Vec::is_empty",
3869 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3870 )]
3871 pub schemas: Vec<Schema>,
3872}
3873
3874#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3876pub struct Token {
3877 #[serde(
3881 default,
3882 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3883 )]
3884 pub anonymous: bool,
3885 #[serde(
3889 default,
3890 skip_serializing_if = "String::is_empty",
3891 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3892 rename = "clientId"
3893 )]
3894 pub client_id: String,
3895 #[serde(
3899 default,
3900 skip_serializing_if = "String::is_empty",
3901 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3902 rename = "displayText"
3903 )]
3904 pub display_text: String,
3905 #[serde(
3909 default,
3910 skip_serializing_if = "String::is_empty",
3911 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3912 )]
3913 pub etag: String,
3914 #[serde(
3918 default,
3919 skip_serializing_if = "String::is_empty",
3920 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3921 )]
3922 pub kind: String,
3923 #[serde(
3927 default,
3928 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
3929 rename = "nativeApp"
3930 )]
3931 pub native_app: bool,
3932 #[serde(
3936 default,
3937 skip_serializing_if = "Vec::is_empty",
3938 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3939 )]
3940 pub scopes: Vec<String>,
3941 #[serde(
3945 default,
3946 skip_serializing_if = "String::is_empty",
3947 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3948 rename = "userKey"
3949 )]
3950 pub user_key: String,
3951}
3952
3953#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3955pub struct Tokens {
3956 #[serde(
3960 default,
3961 skip_serializing_if = "String::is_empty",
3962 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3963 )]
3964 pub etag: String,
3965 #[serde(
3969 default,
3970 skip_serializing_if = "Vec::is_empty",
3971 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3972 )]
3973 pub items: Vec<Token>,
3974 #[serde(
3978 default,
3979 skip_serializing_if = "String::is_empty",
3980 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3981 )]
3982 pub kind: String,
3983}
3984
3985#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3986pub struct Ims {
3987 #[serde(
3988 default,
3989 skip_serializing_if = "String::is_empty",
3990 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3991 rename = "customProtocol"
3992 )]
3993 pub custom_protocol: String,
3994 #[serde(
3995 default,
3996 skip_serializing_if = "String::is_empty",
3997 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3998 rename = "customType"
3999 )]
4000 pub custom_type: String,
4001 #[serde(
4002 default,
4003 skip_serializing_if = "String::is_empty",
4004 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4005 )]
4006 pub im: String,
4007 #[serde(
4011 default,
4012 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4013 )]
4014 pub primary: bool,
4015 #[serde(
4016 default,
4017 skip_serializing_if = "String::is_empty",
4018 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4019 )]
4020 pub protocol: String,
4021 #[serde(
4022 default,
4023 skip_serializing_if = "String::is_empty",
4024 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4025 rename = "type"
4026 )]
4027 pub type_: String,
4028}
4029
4030#[derive(Serialize, Default, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4032pub struct User {
4033 #[serde(
4037 default,
4038 skip_serializing_if = "Vec::is_empty",
4039 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
4040 )]
4041 pub addresses: Vec<UserAddress>,
4042 #[serde(
4046 default,
4047 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
4048 rename = "agreedToTerms"
4049 )]
4050 pub agreed_to_terms: bool,
4051 #[serde(
4055 default,
4056 skip_serializing_if = "Vec::is_empty",
4057 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
4058 )]
4059 pub aliases: Vec<String>,
4060 #[serde(
4064 default,
4065 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4066 )]
4067 pub archived: bool,
4068 #[serde(
4072 default,
4073 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
4074 rename = "changePasswordAtNextLogin"
4075 )]
4076 pub change_password_at_next_login: bool,
4077 #[serde(
4081 default,
4082 skip_serializing_if = "Option::is_none",
4083 deserialize_with = "crate::utils::date_time_format::deserialize",
4084 rename = "creationTime"
4085 )]
4086 pub creation_time: Option<chrono::DateTime<chrono::Utc>>,
4087 #[serde(
4091 default,
4092 skip_serializing_if = "std::collections::HashMap::is_empty",
4093 rename = "customSchemas"
4094 )]
4095 pub custom_schemas:
4096 std::collections::HashMap<String, std::collections::HashMap<String, serde_json::Value>>,
4097 #[serde(
4101 default,
4102 skip_serializing_if = "String::is_empty",
4103 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4104 rename = "customerId"
4105 )]
4106 pub customer_id: String,
4107 #[serde(
4111 default,
4112 skip_serializing_if = "Option::is_none",
4113 deserialize_with = "crate::utils::date_time_format::deserialize",
4114 rename = "deletionTime"
4115 )]
4116 pub deletion_time: Option<chrono::DateTime<chrono::Utc>>,
4117 #[serde(
4121 default,
4122 skip_serializing_if = "Vec::is_empty",
4123 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
4124 )]
4125 pub emails: Vec<UserEmail>,
4126 #[serde(
4130 default,
4131 skip_serializing_if = "String::is_empty",
4132 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4133 )]
4134 pub etag: String,
4135 #[serde(
4139 default,
4140 skip_serializing_if = "Option::is_none",
4141 rename = "externalIds"
4142 )]
4143 pub external_ids: Option<serde_json::Value>,
4144 #[serde(default, skip_serializing_if = "Option::is_none")]
4148 pub gender: Option<UserGender>,
4149 #[serde(
4153 default,
4154 skip_serializing_if = "String::is_empty",
4155 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4156 rename = "hashFunction"
4157 )]
4158 pub hash_function: String,
4159 #[serde(
4163 default,
4164 skip_serializing_if = "String::is_empty",
4165 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4166 )]
4167 pub id: String,
4168 #[serde(
4172 default,
4173 skip_serializing_if = "Vec::is_empty",
4174 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
4175 )]
4176 pub ims: Vec<Ims>,
4177 #[serde(
4181 default,
4182 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
4183 rename = "includeInGlobalAddressList"
4184 )]
4185 pub include_in_global_address_list: bool,
4186 #[serde(
4190 default,
4191 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
4192 rename = "ipWhitelisted"
4193 )]
4194 pub ip_whitelisted: bool,
4195 #[serde(
4199 default,
4200 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
4201 rename = "isAdmin"
4202 )]
4203 pub is_admin: bool,
4204 #[serde(
4208 default,
4209 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
4210 rename = "isDelegatedAdmin"
4211 )]
4212 pub is_delegated_admin: bool,
4213 #[serde(
4217 default,
4218 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
4219 rename = "isEnforcedIn2Sv"
4220 )]
4221 pub is_enforced_in_2_sv: bool,
4222 #[serde(
4226 default,
4227 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
4228 rename = "isEnrolledIn2Sv"
4229 )]
4230 pub is_enrolled_in_2_sv: bool,
4231 #[serde(
4235 default,
4236 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
4237 rename = "isMailboxSetup"
4238 )]
4239 pub is_mailbox_setup: bool,
4240 #[serde(default, skip_serializing_if = "Option::is_none")]
4244 pub keywords: Option<serde_json::Value>,
4245 #[serde(
4249 default,
4250 skip_serializing_if = "String::is_empty",
4251 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4252 )]
4253 pub kind: String,
4254 #[serde(default, skip_serializing_if = "Option::is_none")]
4258 pub languages: Option<serde_json::Value>,
4259 #[serde(
4263 default,
4264 skip_serializing_if = "Option::is_none",
4265 deserialize_with = "crate::utils::date_time_format::deserialize",
4266 rename = "lastLoginTime"
4267 )]
4268 pub last_login_time: Option<chrono::DateTime<chrono::Utc>>,
4269 #[serde(
4273 default,
4274 skip_serializing_if = "Vec::is_empty",
4275 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
4276 )]
4277 pub locations: Vec<UserLocation>,
4278 #[serde(default, skip_serializing_if = "Option::is_none")]
4282 pub name: Option<UserName>,
4283 #[serde(
4287 default,
4288 skip_serializing_if = "Vec::is_empty",
4289 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
4290 rename = "nonEditableAliases"
4291 )]
4292 pub non_editable_aliases: Vec<String>,
4293 #[serde(default, skip_serializing_if = "Option::is_none")]
4297 pub notes: Option<serde_json::Value>,
4298 #[serde(
4302 default,
4303 skip_serializing_if = "String::is_empty",
4304 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4305 rename = "orgUnitPath"
4306 )]
4307 pub org_unit_path: String,
4308 #[serde(default, skip_serializing_if = "Option::is_none")]
4312 pub organizations: Option<serde_json::Value>,
4313 #[serde(
4317 default,
4318 skip_serializing_if = "String::is_empty",
4319 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4320 )]
4321 pub password: String,
4322 #[serde(
4326 default,
4327 skip_serializing_if = "Vec::is_empty",
4328 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
4329 )]
4330 pub phones: Vec<UserPhone>,
4331 #[serde(
4335 default,
4336 skip_serializing_if = "Option::is_none",
4337 rename = "posixAccounts"
4338 )]
4339 pub posix_accounts: Option<serde_json::Value>,
4340 #[serde(
4344 default,
4345 skip_serializing_if = "String::is_empty",
4346 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4347 rename = "primaryEmail"
4348 )]
4349 pub primary_email: String,
4350 #[serde(
4354 default,
4355 skip_serializing_if = "String::is_empty",
4356 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4357 rename = "recoveryEmail"
4358 )]
4359 pub recovery_email: String,
4360 #[serde(
4364 default,
4365 skip_serializing_if = "String::is_empty",
4366 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4367 rename = "recoveryPhone"
4368 )]
4369 pub recovery_phone: String,
4370 #[serde(default, skip_serializing_if = "Option::is_none")]
4374 pub relations: Option<serde_json::Value>,
4375 #[serde(
4379 default,
4380 skip_serializing_if = "Vec::is_empty",
4381 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
4382 rename = "sshPublicKeys"
4383 )]
4384 pub ssh_public_keys: Vec<UserSshPublicKey>,
4385 #[serde(
4389 default,
4390 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4391 )]
4392 pub suspended: bool,
4393 #[serde(
4397 default,
4398 skip_serializing_if = "String::is_empty",
4399 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4400 rename = "suspensionReason"
4401 )]
4402 pub suspension_reason: String,
4403 #[serde(
4407 default,
4408 skip_serializing_if = "String::is_empty",
4409 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4410 rename = "thumbnailPhotoEtag"
4411 )]
4412 pub thumbnail_photo_etag: String,
4413 #[serde(
4417 default,
4418 skip_serializing_if = "String::is_empty",
4419 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4420 rename = "thumbnailPhotoUrl"
4421 )]
4422 pub thumbnail_photo_url: String,
4423 #[serde(default, skip_serializing_if = "Option::is_none")]
4427 pub websites: Option<serde_json::Value>,
4428}
4429
4430#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4432pub struct UserAbout {
4433 #[serde(
4437 default,
4438 skip_serializing_if = "String::is_empty",
4439 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4440 rename = "contentType"
4441 )]
4442 pub content_type: String,
4443 #[serde(
4447 default,
4448 skip_serializing_if = "String::is_empty",
4449 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4450 )]
4451 pub value: String,
4452}
4453
4454#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4456pub struct UserAddress {
4457 #[serde(
4461 default,
4462 skip_serializing_if = "String::is_empty",
4463 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4464 )]
4465 pub country: String,
4466 #[serde(
4470 default,
4471 skip_serializing_if = "String::is_empty",
4472 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4473 rename = "countryCode"
4474 )]
4475 pub country_code: String,
4476 #[serde(
4480 default,
4481 skip_serializing_if = "String::is_empty",
4482 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4483 rename = "customType"
4484 )]
4485 pub custom_type: String,
4486 #[serde(
4490 default,
4491 skip_serializing_if = "String::is_empty",
4492 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4493 rename = "extendedAddress"
4494 )]
4495 pub extended_address: String,
4496 #[serde(
4500 default,
4501 skip_serializing_if = "String::is_empty",
4502 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4503 )]
4504 pub formatted: String,
4505 #[serde(
4509 default,
4510 skip_serializing_if = "String::is_empty",
4511 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4512 )]
4513 pub locality: String,
4514 #[serde(
4518 default,
4519 skip_serializing_if = "String::is_empty",
4520 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4521 rename = "poBox"
4522 )]
4523 pub po_box: String,
4524 #[serde(
4528 default,
4529 skip_serializing_if = "String::is_empty",
4530 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4531 rename = "postalCode"
4532 )]
4533 pub postal_code: String,
4534 #[serde(
4538 default,
4539 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4540 )]
4541 pub primary: bool,
4542 #[serde(
4546 default,
4547 skip_serializing_if = "String::is_empty",
4548 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4549 )]
4550 pub region: String,
4551 #[serde(
4555 default,
4556 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
4557 rename = "sourceIsStructured"
4558 )]
4559 pub source_is_structured: bool,
4560 #[serde(
4564 default,
4565 skip_serializing_if = "String::is_empty",
4566 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4567 rename = "streetAddress"
4568 )]
4569 pub street_address: String,
4570 #[serde(
4574 default,
4575 skip_serializing_if = "String::is_empty",
4576 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4577 rename = "type"
4578 )]
4579 pub type_: String,
4580}
4581
4582#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4584pub struct UserEmail {
4585 #[serde(
4589 default,
4590 skip_serializing_if = "String::is_empty",
4591 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4592 )]
4593 pub address: String,
4594 #[serde(
4598 default,
4599 skip_serializing_if = "String::is_empty",
4600 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4601 rename = "customType"
4602 )]
4603 pub custom_type: String,
4604 #[serde(
4608 default,
4609 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4610 )]
4611 pub primary: bool,
4612 #[serde(
4616 default,
4617 skip_serializing_if = "String::is_empty",
4618 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4619 rename = "type"
4620 )]
4621 pub type_: String,
4622}
4623
4624#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4626pub struct UserExternalId {
4627 #[serde(
4631 default,
4632 skip_serializing_if = "String::is_empty",
4633 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4634 rename = "customType"
4635 )]
4636 pub custom_type: String,
4637 #[serde(
4641 default,
4642 skip_serializing_if = "String::is_empty",
4643 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4644 rename = "type"
4645 )]
4646 pub type_: String,
4647 #[serde(
4651 default,
4652 skip_serializing_if = "String::is_empty",
4653 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4654 )]
4655 pub value: String,
4656}
4657
4658#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4659pub struct UserGender {
4660 #[serde(
4661 default,
4662 skip_serializing_if = "String::is_empty",
4663 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4664 rename = "addressMeAs"
4665 )]
4666 pub address_me_as: String,
4667 #[serde(
4668 default,
4669 skip_serializing_if = "String::is_empty",
4670 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4671 rename = "customGender"
4672 )]
4673 pub custom_gender: String,
4674 #[serde(
4675 default,
4676 skip_serializing_if = "String::is_empty",
4677 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4678 rename = "type"
4679 )]
4680 pub type_: String,
4681}
4682
4683#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4685pub struct UserIm {
4686 #[serde(
4690 default,
4691 skip_serializing_if = "String::is_empty",
4692 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4693 rename = "customProtocol"
4694 )]
4695 pub custom_protocol: String,
4696 #[serde(
4700 default,
4701 skip_serializing_if = "String::is_empty",
4702 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4703 rename = "customType"
4704 )]
4705 pub custom_type: String,
4706 #[serde(
4710 default,
4711 skip_serializing_if = "String::is_empty",
4712 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4713 )]
4714 pub im: String,
4715 #[serde(
4719 default,
4720 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4721 )]
4722 pub primary: bool,
4723 #[serde(
4727 default,
4728 skip_serializing_if = "String::is_empty",
4729 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4730 )]
4731 pub protocol: String,
4732 #[serde(
4736 default,
4737 skip_serializing_if = "String::is_empty",
4738 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4739 rename = "type"
4740 )]
4741 pub type_: String,
4742}
4743
4744#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4746pub struct UserKeyword {
4747 #[serde(
4751 default,
4752 skip_serializing_if = "String::is_empty",
4753 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4754 rename = "customType"
4755 )]
4756 pub custom_type: String,
4757 #[serde(
4761 default,
4762 skip_serializing_if = "String::is_empty",
4763 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4764 rename = "type"
4765 )]
4766 pub type_: String,
4767 #[serde(
4771 default,
4772 skip_serializing_if = "String::is_empty",
4773 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4774 )]
4775 pub value: String,
4776}
4777
4778#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4780pub struct UserLanguage {
4781 #[serde(
4785 default,
4786 skip_serializing_if = "String::is_empty",
4787 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4788 rename = "customLanguage"
4789 )]
4790 pub custom_language: String,
4791 #[serde(
4795 default,
4796 skip_serializing_if = "String::is_empty",
4797 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4798 rename = "languageCode"
4799 )]
4800 pub language_code: String,
4801}
4802
4803#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4805pub struct UserLocation {
4806 #[serde(
4810 default,
4811 skip_serializing_if = "String::is_empty",
4812 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4813 )]
4814 pub area: String,
4815 #[serde(
4819 default,
4820 skip_serializing_if = "String::is_empty",
4821 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4822 rename = "buildingId"
4823 )]
4824 pub building_id: String,
4825 #[serde(
4829 default,
4830 skip_serializing_if = "String::is_empty",
4831 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4832 rename = "customType"
4833 )]
4834 pub custom_type: String,
4835 #[serde(
4839 default,
4840 skip_serializing_if = "String::is_empty",
4841 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4842 rename = "deskCode"
4843 )]
4844 pub desk_code: String,
4845 #[serde(
4849 default,
4850 skip_serializing_if = "String::is_empty",
4851 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4852 rename = "floorName"
4853 )]
4854 pub floor_name: String,
4855 #[serde(
4859 default,
4860 skip_serializing_if = "String::is_empty",
4861 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4862 rename = "floorSection"
4863 )]
4864 pub floor_section: String,
4865 #[serde(
4869 default,
4870 skip_serializing_if = "String::is_empty",
4871 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4872 rename = "type"
4873 )]
4874 pub type_: String,
4875}
4876
4877#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4878pub struct UserMakeAdmin {
4879 #[serde(
4883 default,
4884 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4885 )]
4886 pub status: bool,
4887}
4888
4889#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4890pub struct UserName {
4891 #[serde(
4892 default,
4893 skip_serializing_if = "String::is_empty",
4894 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4895 rename = "familyName"
4896 )]
4897 pub family_name: String,
4898 #[serde(
4899 default,
4900 skip_serializing_if = "String::is_empty",
4901 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4902 rename = "fullName"
4903 )]
4904 pub full_name: String,
4905 #[serde(
4906 default,
4907 skip_serializing_if = "String::is_empty",
4908 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4909 rename = "givenName"
4910 )]
4911 pub given_name: String,
4912}
4913
4914#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4916pub struct UserOrganization {
4917 #[serde(
4921 default,
4922 skip_serializing_if = "String::is_empty",
4923 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4924 rename = "costCenter"
4925 )]
4926 pub cost_center: String,
4927 #[serde(
4931 default,
4932 skip_serializing_if = "String::is_empty",
4933 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
4934 rename = "customType"
4935 )]
4936 pub custom_type: String,
4937 #[serde(
4941 default,
4942 skip_serializing_if = "String::is_empty",
4943 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4944 )]
4945 pub department: String,
4946 #[serde(
4950 default,
4951 skip_serializing_if = "String::is_empty",
4952 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4953 )]
4954 pub description: String,
4955 #[serde(
4959 default,
4960 skip_serializing_if = "String::is_empty",
4961 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4962 )]
4963 pub domain: String,
4964 #[serde(
4968 default,
4969 skip_serializing_if = "crate::utils::zero_i64",
4970 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
4971 rename = "fullTimeEquivalent"
4972 )]
4973 pub full_time_equivalent: i64,
4974 #[serde(
4978 default,
4979 skip_serializing_if = "String::is_empty",
4980 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4981 )]
4982 pub location: String,
4983 #[serde(
4987 default,
4988 skip_serializing_if = "String::is_empty",
4989 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4990 )]
4991 pub name: String,
4992 #[serde(
4996 default,
4997 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4998 )]
4999 pub primary: bool,
5000 #[serde(
5004 default,
5005 skip_serializing_if = "String::is_empty",
5006 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5007 )]
5008 pub symbol: String,
5009 #[serde(
5013 default,
5014 skip_serializing_if = "String::is_empty",
5015 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5016 )]
5017 pub title: String,
5018 #[serde(
5022 default,
5023 skip_serializing_if = "String::is_empty",
5024 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
5025 rename = "type"
5026 )]
5027 pub type_: String,
5028}
5029
5030#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5032pub struct UserPhone {
5033 #[serde(
5037 default,
5038 skip_serializing_if = "String::is_empty",
5039 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
5040 rename = "customType"
5041 )]
5042 pub custom_type: String,
5043 #[serde(
5047 default,
5048 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5049 )]
5050 pub primary: bool,
5051 #[serde(
5055 default,
5056 skip_serializing_if = "String::is_empty",
5057 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
5058 rename = "type"
5059 )]
5060 pub type_: String,
5061 #[serde(
5065 default,
5066 skip_serializing_if = "String::is_empty",
5067 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5068 )]
5069 pub value: String,
5070}
5071
5072#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5073pub struct UserPhoto {
5074 #[serde(
5075 default,
5076 skip_serializing_if = "String::is_empty",
5077 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5078 )]
5079 pub etag: String,
5080 #[serde(
5084 default,
5085 skip_serializing_if = "crate::utils::zero_i64",
5086 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
5087 )]
5088 pub height: i64,
5089 #[serde(
5090 default,
5091 skip_serializing_if = "String::is_empty",
5092 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5093 )]
5094 pub id: String,
5095 #[serde(
5096 default,
5097 skip_serializing_if = "String::is_empty",
5098 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5099 )]
5100 pub kind: String,
5101 #[serde(
5102 default,
5103 skip_serializing_if = "String::is_empty",
5104 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
5105 rename = "mimeType"
5106 )]
5107 pub mime_type: String,
5108 #[serde(default, skip_serializing_if = "Option::is_none", rename = "photoData")]
5112 pub photo_data: Option<bytes::Bytes>,
5113 #[serde(
5114 default,
5115 skip_serializing_if = "String::is_empty",
5116 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
5117 rename = "primaryEmail"
5118 )]
5119 pub primary_email: String,
5120 #[serde(
5124 default,
5125 skip_serializing_if = "crate::utils::zero_i64",
5126 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
5127 )]
5128 pub width: i64,
5129}
5130
5131#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5133pub struct UserPosixAccount {
5134 #[serde(
5138 default,
5139 skip_serializing_if = "String::is_empty",
5140 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
5141 rename = "accountId"
5142 )]
5143 pub account_id: String,
5144 #[serde(
5148 default,
5149 skip_serializing_if = "String::is_empty",
5150 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5151 )]
5152 pub gecos: String,
5153 #[serde(default, skip_serializing_if = "Option::is_none")]
5157 pub gid: Option<u64>,
5158 #[serde(
5162 default,
5163 skip_serializing_if = "String::is_empty",
5164 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
5165 rename = "homeDirectory"
5166 )]
5167 pub home_directory: String,
5168 #[serde(
5172 default,
5173 skip_serializing_if = "String::is_empty",
5174 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
5175 rename = "operatingSystemType"
5176 )]
5177 pub operating_system_type: String,
5178 #[serde(
5182 default,
5183 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5184 )]
5185 pub primary: bool,
5186 #[serde(
5190 default,
5191 skip_serializing_if = "String::is_empty",
5192 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5193 )]
5194 pub shell: String,
5195 #[serde(
5199 default,
5200 skip_serializing_if = "String::is_empty",
5201 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
5202 rename = "systemId"
5203 )]
5204 pub system_id: String,
5205 #[serde(default, skip_serializing_if = "Option::is_none")]
5209 pub uid: Option<u64>,
5210 #[serde(
5214 default,
5215 skip_serializing_if = "String::is_empty",
5216 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5217 )]
5218 pub username: String,
5219}
5220
5221#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5223pub struct UserRelation {
5224 #[serde(
5228 default,
5229 skip_serializing_if = "String::is_empty",
5230 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
5231 rename = "customType"
5232 )]
5233 pub custom_type: String,
5234 #[serde(
5238 default,
5239 skip_serializing_if = "String::is_empty",
5240 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
5241 rename = "type"
5242 )]
5243 pub type_: String,
5244 #[serde(
5248 default,
5249 skip_serializing_if = "String::is_empty",
5250 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5251 )]
5252 pub value: String,
5253}
5254
5255#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5257pub struct UserSshPublicKey {
5258 #[serde(
5262 default,
5263 skip_serializing_if = "crate::utils::zero_i64",
5264 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
5265 rename = "expirationTimeUsec"
5266 )]
5267 pub expiration_time_usec: i64,
5268 #[serde(
5272 default,
5273 skip_serializing_if = "String::is_empty",
5274 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5275 )]
5276 pub fingerprint: String,
5277 #[serde(
5281 default,
5282 skip_serializing_if = "String::is_empty",
5283 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5284 )]
5285 pub key: String,
5286}
5287
5288#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5289pub struct UserUndelete {
5290 #[serde(
5291 default,
5292 skip_serializing_if = "String::is_empty",
5293 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
5294 rename = "orgUnitPath"
5295 )]
5296 pub org_unit_path: String,
5297}
5298
5299#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5301pub struct UserWebsite {
5302 #[serde(
5306 default,
5307 skip_serializing_if = "String::is_empty",
5308 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
5309 rename = "customType"
5310 )]
5311 pub custom_type: String,
5312 #[serde(
5316 default,
5317 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5318 )]
5319 pub primary: bool,
5320 #[serde(
5324 default,
5325 skip_serializing_if = "String::is_empty",
5326 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
5327 rename = "type"
5328 )]
5329 pub type_: String,
5330 #[serde(
5334 default,
5335 skip_serializing_if = "String::is_empty",
5336 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5337 )]
5338 pub value: String,
5339}
5340
5341#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5342pub struct Users {
5343 #[serde(
5344 default,
5345 skip_serializing_if = "String::is_empty",
5346 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5347 )]
5348 pub etag: String,
5349 #[serde(
5350 default,
5351 skip_serializing_if = "String::is_empty",
5352 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5353 )]
5354 pub kind: String,
5355 #[serde(
5356 default,
5357 skip_serializing_if = "String::is_empty",
5358 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
5359 rename = "nextPageToken"
5360 )]
5361 pub next_page_token: String,
5362 #[serde(
5363 default,
5364 skip_serializing_if = "String::is_empty",
5365 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5366 )]
5367 pub trigger_event: String,
5368 #[serde(
5372 default,
5373 skip_serializing_if = "Vec::is_empty",
5374 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
5375 )]
5376 pub users: Vec<User>,
5377}
5378
5379#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5381pub struct VerificationCode {
5382 #[serde(
5386 default,
5387 skip_serializing_if = "String::is_empty",
5388 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5389 )]
5390 pub etag: String,
5391 #[serde(
5395 default,
5396 skip_serializing_if = "String::is_empty",
5397 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5398 )]
5399 pub kind: String,
5400 #[serde(
5404 default,
5405 skip_serializing_if = "String::is_empty",
5406 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
5407 rename = "userId"
5408 )]
5409 pub user_id: String,
5410 #[serde(
5414 default,
5415 skip_serializing_if = "String::is_empty",
5416 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
5417 rename = "verificationCode"
5418 )]
5419 pub verification_code: String,
5420}
5421
5422#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5424pub struct VerificationCodes {
5425 #[serde(
5429 default,
5430 skip_serializing_if = "String::is_empty",
5431 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5432 )]
5433 pub etag: String,
5434 #[serde(
5438 default,
5439 skip_serializing_if = "Vec::is_empty",
5440 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
5441 )]
5442 pub items: Vec<VerificationCode>,
5443 #[serde(
5447 default,
5448 skip_serializing_if = "String::is_empty",
5449 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5450 )]
5451 pub kind: String,
5452}
5453
5454#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
5458pub enum Xgafv {
5459 #[serde(rename = "1")]
5460 One,
5461 #[serde(rename = "2")]
5462 Two,
5463 #[serde(rename = "")]
5464 #[default]
5465 Noop,
5466 #[serde(other)]
5467 FallthroughString,
5468}
5469
5470impl std::fmt::Display for Xgafv {
5471 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5472 match self {
5473 Xgafv::One => "1",
5474 Xgafv::Two => "2",
5475 Xgafv::Noop => "",
5476 Xgafv::FallthroughString => "*",
5477 }
5478 .fmt(f)
5479 }
5480}
5481
5482impl Xgafv {
5483 pub fn is_noop(&self) -> bool {
5484 matches!(self, Xgafv::Noop)
5485 }
5486}
5487
5488#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
5492pub enum Alt {
5493 #[serde(rename = "json")]
5494 Json,
5495 #[serde(rename = "media")]
5496 Media,
5497 #[serde(rename = "proto")]
5498 Proto,
5499 #[serde(rename = "")]
5500 #[default]
5501 Noop,
5502 #[serde(other)]
5503 FallthroughString,
5504}
5505
5506impl std::fmt::Display for Alt {
5507 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5508 match self {
5509 Alt::Json => "json",
5510 Alt::Media => "media",
5511 Alt::Proto => "proto",
5512 Alt::Noop => "",
5513 Alt::FallthroughString => "*",
5514 }
5515 .fmt(f)
5516 }
5517}
5518
5519impl Alt {
5520 pub fn is_noop(&self) -> bool {
5521 matches!(self, Alt::Noop)
5522 }
5523}
5524
5525#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
5529pub enum OrderBy {
5530 #[serde(rename = "annotatedLocation")]
5531 AnnotatedLocation,
5532 #[serde(rename = "annotatedUser")]
5533 AnnotatedUser,
5534 #[serde(rename = "lastSync")]
5535 LastSync,
5536 #[serde(rename = "notes")]
5537 Notes,
5538 #[serde(rename = "serialNumber")]
5539 SerialNumber,
5540 #[serde(rename = "status")]
5541 Status,
5542 #[serde(rename = "supportEndDate")]
5543 SupportEndDate,
5544 #[serde(rename = "")]
5545 #[default]
5546 Noop,
5547 #[serde(other)]
5548 FallthroughString,
5549}
5550
5551impl std::fmt::Display for OrderBy {
5552 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5553 match self {
5554 OrderBy::AnnotatedLocation => "annotatedLocation",
5555 OrderBy::AnnotatedUser => "annotatedUser",
5556 OrderBy::LastSync => "lastSync",
5557 OrderBy::Notes => "notes",
5558 OrderBy::SerialNumber => "serialNumber",
5559 OrderBy::Status => "status",
5560 OrderBy::SupportEndDate => "supportEndDate",
5561 OrderBy::Noop => "",
5562 OrderBy::FallthroughString => "*",
5563 }
5564 .fmt(f)
5565 }
5566}
5567
5568impl OrderBy {
5569 pub fn is_noop(&self) -> bool {
5570 matches!(self, OrderBy::Noop)
5571 }
5572}
5573
5574#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
5578pub enum Projection {
5579 #[serde(rename = "BASIC")]
5580 Basic,
5581 #[serde(rename = "FULL")]
5582 Full,
5583 #[serde(rename = "")]
5584 #[default]
5585 Noop,
5586 #[serde(other)]
5587 FallthroughString,
5588}
5589
5590impl std::fmt::Display for Projection {
5591 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5592 match self {
5593 Projection::Basic => "BASIC",
5594 Projection::Full => "FULL",
5595 Projection::Noop => "",
5596 Projection::FallthroughString => "*",
5597 }
5598 .fmt(f)
5599 }
5600}
5601
5602impl Projection {
5603 pub fn is_noop(&self) -> bool {
5604 matches!(self, Projection::Noop)
5605 }
5606}
5607
5608#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
5612pub enum SortOrder {
5613 #[serde(rename = "ASCENDING")]
5614 Ascending,
5615 #[serde(rename = "DESCENDING")]
5616 Descending,
5617 #[serde(rename = "")]
5618 #[default]
5619 Noop,
5620 #[serde(other)]
5621 FallthroughString,
5622}
5623
5624impl std::fmt::Display for SortOrder {
5625 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5626 match self {
5627 SortOrder::Ascending => "ASCENDING",
5628 SortOrder::Descending => "DESCENDING",
5629 SortOrder::Noop => "",
5630 SortOrder::FallthroughString => "*",
5631 }
5632 .fmt(f)
5633 }
5634}
5635
5636impl SortOrder {
5637 pub fn is_noop(&self) -> bool {
5638 matches!(self, SortOrder::Noop)
5639 }
5640}
5641
5642#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
5646pub enum DirectoryMobiledevicesListOrderBy {
5647 #[serde(rename = "deviceId")]
5648 DeviceId,
5649 #[serde(rename = "email")]
5650 Email,
5651 #[serde(rename = "lastSync")]
5652 LastSync,
5653 #[serde(rename = "model")]
5654 Model,
5655 #[serde(rename = "name")]
5656 Name,
5657 #[serde(rename = "os")]
5658 Os,
5659 #[serde(rename = "status")]
5660 Status,
5661 #[serde(rename = "type")]
5662 Type,
5663 #[serde(rename = "")]
5664 #[default]
5665 Noop,
5666 #[serde(other)]
5667 FallthroughString,
5668}
5669
5670impl std::fmt::Display for DirectoryMobiledevicesListOrderBy {
5671 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5672 match self {
5673 DirectoryMobiledevicesListOrderBy::DeviceId => "deviceId",
5674 DirectoryMobiledevicesListOrderBy::Email => "email",
5675 DirectoryMobiledevicesListOrderBy::LastSync => "lastSync",
5676 DirectoryMobiledevicesListOrderBy::Model => "model",
5677 DirectoryMobiledevicesListOrderBy::Name => "name",
5678 DirectoryMobiledevicesListOrderBy::Os => "os",
5679 DirectoryMobiledevicesListOrderBy::Status => "status",
5680 DirectoryMobiledevicesListOrderBy::Type => "type",
5681 DirectoryMobiledevicesListOrderBy::Noop => "",
5682 DirectoryMobiledevicesListOrderBy::FallthroughString => "*",
5683 }
5684 .fmt(f)
5685 }
5686}
5687
5688impl DirectoryMobiledevicesListOrderBy {
5689 pub fn is_noop(&self) -> bool {
5690 matches!(self, DirectoryMobiledevicesListOrderBy::Noop)
5691 }
5692}
5693
5694#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
5698pub enum DirectoryOrgunitsListType {
5699 #[serde(rename = "all")]
5700 All,
5701 #[serde(rename = "children")]
5702 Children,
5703 #[serde(rename = "")]
5704 #[default]
5705 Noop,
5706 #[serde(other)]
5707 FallthroughString,
5708}
5709
5710impl std::fmt::Display for DirectoryOrgunitsListType {
5711 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5712 match self {
5713 DirectoryOrgunitsListType::All => "all",
5714 DirectoryOrgunitsListType::Children => "children",
5715 DirectoryOrgunitsListType::Noop => "",
5716 DirectoryOrgunitsListType::FallthroughString => "*",
5717 }
5718 .fmt(f)
5719 }
5720}
5721
5722impl DirectoryOrgunitsListType {
5723 pub fn is_noop(&self) -> bool {
5724 matches!(self, DirectoryOrgunitsListType::Noop)
5725 }
5726}
5727
5728#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
5732pub enum CoordinatesSource {
5733 #[serde(rename = "CLIENT_SPECIFIED")]
5734 ClientSpecified,
5735 #[serde(rename = "RESOLVED_FROM_ADDRESS")]
5736 ResolvedFromAddress,
5737 #[serde(rename = "SOURCE_UNSPECIFIED")]
5738 SourceUnspecified,
5739 #[serde(rename = "")]
5740 #[default]
5741 Noop,
5742 #[serde(other)]
5743 FallthroughString,
5744}
5745
5746impl std::fmt::Display for CoordinatesSource {
5747 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5748 match self {
5749 CoordinatesSource::ClientSpecified => "CLIENT_SPECIFIED",
5750 CoordinatesSource::ResolvedFromAddress => "RESOLVED_FROM_ADDRESS",
5751 CoordinatesSource::SourceUnspecified => "SOURCE_UNSPECIFIED",
5752 CoordinatesSource::Noop => "",
5753 CoordinatesSource::FallthroughString => "*",
5754 }
5755 .fmt(f)
5756 }
5757}
5758
5759impl CoordinatesSource {
5760 pub fn is_noop(&self) -> bool {
5761 matches!(self, CoordinatesSource::Noop)
5762 }
5763}
5764
5765#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
5769pub enum DirectoryGroupsListOrderBy {
5770 #[serde(rename = "email")]
5771 Email,
5772 #[serde(rename = "")]
5773 #[default]
5774 Noop,
5775 #[serde(other)]
5776 FallthroughString,
5777}
5778
5779impl std::fmt::Display for DirectoryGroupsListOrderBy {
5780 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5781 match self {
5782 DirectoryGroupsListOrderBy::Email => "email",
5783 DirectoryGroupsListOrderBy::Noop => "",
5784 DirectoryGroupsListOrderBy::FallthroughString => "*",
5785 }
5786 .fmt(f)
5787 }
5788}
5789
5790impl DirectoryGroupsListOrderBy {
5791 pub fn is_noop(&self) -> bool {
5792 matches!(self, DirectoryGroupsListOrderBy::Noop)
5793 }
5794}
5795
5796#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
5800pub enum Event {
5801 #[serde(rename = "add")]
5802 Add,
5803 #[serde(rename = "delete")]
5804 Delete,
5805 #[serde(rename = "makeAdmin")]
5806 MakeAdmin,
5807 #[serde(rename = "undelete")]
5808 Undelete,
5809 #[serde(rename = "update")]
5810 Update,
5811 #[serde(rename = "")]
5812 #[default]
5813 Noop,
5814 #[serde(other)]
5815 FallthroughString,
5816}
5817
5818impl std::fmt::Display for Event {
5819 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5820 match self {
5821 Event::Add => "add",
5822 Event::Delete => "delete",
5823 Event::MakeAdmin => "makeAdmin",
5824 Event::Undelete => "undelete",
5825 Event::Update => "update",
5826 Event::Noop => "",
5827 Event::FallthroughString => "*",
5828 }
5829 .fmt(f)
5830 }
5831}
5832
5833impl Event {
5834 pub fn is_noop(&self) -> bool {
5835 matches!(self, Event::Noop)
5836 }
5837}
5838
5839#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
5843pub enum DirectoryUsersListOrderBy {
5844 #[serde(rename = "email")]
5845 Email,
5846 #[serde(rename = "familyName")]
5847 FamilyName,
5848 #[serde(rename = "givenName")]
5849 GivenName,
5850 #[serde(rename = "")]
5851 #[default]
5852 Noop,
5853 #[serde(other)]
5854 FallthroughString,
5855}
5856
5857impl std::fmt::Display for DirectoryUsersListOrderBy {
5858 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5859 match self {
5860 DirectoryUsersListOrderBy::Email => "email",
5861 DirectoryUsersListOrderBy::FamilyName => "familyName",
5862 DirectoryUsersListOrderBy::GivenName => "givenName",
5863 DirectoryUsersListOrderBy::Noop => "",
5864 DirectoryUsersListOrderBy::FallthroughString => "*",
5865 }
5866 .fmt(f)
5867 }
5868}
5869
5870impl DirectoryUsersListOrderBy {
5871 pub fn is_noop(&self) -> bool {
5872 matches!(self, DirectoryUsersListOrderBy::Noop)
5873 }
5874}
5875
5876#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
5880pub enum DirectoryUsersListProjection {
5881 #[serde(rename = "basic")]
5882 Basic,
5883 #[serde(rename = "custom")]
5884 Custom,
5885 #[serde(rename = "full")]
5886 Full,
5887 #[serde(rename = "")]
5888 #[default]
5889 Noop,
5890 #[serde(other)]
5891 FallthroughString,
5892}
5893
5894impl std::fmt::Display for DirectoryUsersListProjection {
5895 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5896 match self {
5897 DirectoryUsersListProjection::Basic => "basic",
5898 DirectoryUsersListProjection::Custom => "custom",
5899 DirectoryUsersListProjection::Full => "full",
5900 DirectoryUsersListProjection::Noop => "",
5901 DirectoryUsersListProjection::FallthroughString => "*",
5902 }
5903 .fmt(f)
5904 }
5905}
5906
5907impl DirectoryUsersListProjection {
5908 pub fn is_noop(&self) -> bool {
5909 matches!(self, DirectoryUsersListProjection::Noop)
5910 }
5911}
5912
5913#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
5917pub enum ViewType {
5918 #[serde(rename = "admin_view")]
5919 AdminView,
5920 #[serde(rename = "domain_public")]
5921 DomainPublic,
5922 #[serde(rename = "")]
5923 #[default]
5924 Noop,
5925 #[serde(other)]
5926 FallthroughString,
5927}
5928
5929impl std::fmt::Display for ViewType {
5930 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5931 match self {
5932 ViewType::AdminView => "admin_view",
5933 ViewType::DomainPublic => "domain_public",
5934 ViewType::Noop => "",
5935 ViewType::FallthroughString => "*",
5936 }
5937 .fmt(f)
5938 }
5939}
5940
5941impl ViewType {
5942 pub fn is_noop(&self) -> bool {
5943 matches!(self, ViewType::Noop)
5944 }
5945}
5946
5947#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
5951pub enum DirectoryUsersAliasesListEvent {
5952 #[serde(rename = "add")]
5953 Add,
5954 #[serde(rename = "delete")]
5955 Delete,
5956 #[serde(rename = "")]
5957 #[default]
5958 Noop,
5959 #[serde(other)]
5960 FallthroughString,
5961}
5962
5963impl std::fmt::Display for DirectoryUsersAliasesListEvent {
5964 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5965 match self {
5966 DirectoryUsersAliasesListEvent::Add => "add",
5967 DirectoryUsersAliasesListEvent::Delete => "delete",
5968 DirectoryUsersAliasesListEvent::Noop => "",
5969 DirectoryUsersAliasesListEvent::FallthroughString => "*",
5970 }
5971 .fmt(f)
5972 }
5973}
5974
5975impl DirectoryUsersAliasesListEvent {
5976 pub fn is_noop(&self) -> bool {
5977 matches!(self, DirectoryUsersAliasesListEvent::Noop)
5978 }
5979}