1use schemars::JsonSchema;
3use serde::{Deserialize, Serialize};
4
5#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
9pub enum PayMode {
10 #[serde(rename = "master")]
11 #[default]
12 Master,
13 #[serde(rename = "sub")]
14 Sub,
15 #[serde(other)]
16 FallthroughString,
17}
18
19impl std::fmt::Display for PayMode {
20 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21 match self {
22 PayMode::Master => "master",
23 PayMode::Sub => "sub",
24 PayMode::FallthroughString => "*",
25 }
26 .fmt(f)
27 }
28}
29
30#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32pub struct Options {
33 #[serde(
37 default,
38 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
39 )]
40 pub billing_auto_renew: bool,
41 #[serde(
45 default,
46 skip_serializing_if = "Vec::is_empty",
47 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
48 )]
49 pub meeting_connector_list: Vec<String>,
50 #[serde(default, skip_serializing_if = "Option::is_none")]
54 pub pay_mode: Option<PayMode>,
55 #[serde(
59 default,
60 skip_serializing_if = "Vec::is_empty",
61 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
62 )]
63 pub room_connector_list: Vec<String>,
64 #[serde(
68 default,
69 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
70 )]
71 pub share_mc: bool,
72 #[serde(
76 default,
77 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
78 )]
79 pub share_rc: bool,
80}
81
82#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
84pub struct Account {
85 #[serde(
89 default,
90 skip_serializing_if = "String::is_empty",
91 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
92 )]
93 pub email: String,
94 #[serde(
98 default,
99 skip_serializing_if = "String::is_empty",
100 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
101 )]
102 pub first_name: String,
103 #[serde(
107 default,
108 skip_serializing_if = "String::is_empty",
109 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
110 )]
111 pub last_name: String,
112 #[serde(default, skip_serializing_if = "Option::is_none")]
116 pub options: Option<Options>,
117 #[serde(
121 default,
122 skip_serializing_if = "String::is_empty",
123 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
124 )]
125 pub password: String,
126 #[serde(
130 default,
131 skip_serializing_if = "String::is_empty",
132 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
133 )]
134 pub vanity_url: String,
135}
136
137#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
138pub struct Accounts {
139 #[serde(
143 default,
144 skip_serializing_if = "String::is_empty",
145 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
146 )]
147 pub account_name: String,
148 #[serde(
152 default,
153 skip_serializing_if = "String::is_empty",
154 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
155 )]
156 pub account_number: String,
157 #[serde(
161 default,
162 skip_serializing_if = "String::is_empty",
163 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
164 )]
165 pub account_type: String,
166 #[serde(
170 default,
171 skip_serializing_if = "Option::is_none",
172 deserialize_with = "crate::utils::date_time_format::deserialize"
173 )]
174 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
175 #[serde(
179 default,
180 skip_serializing_if = "String::is_empty",
181 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
182 )]
183 pub id: String,
184 #[serde(
188 default,
189 skip_serializing_if = "String::is_empty",
190 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
191 )]
192 pub owner_email: String,
193 #[serde(
197 default,
198 skip_serializing_if = "crate::utils::zero_i64",
199 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
200 )]
201 pub seats: i64,
202 #[serde(
206 default,
207 skip_serializing_if = "Option::is_none",
208 deserialize_with = "crate::utils::date_time_format::deserialize"
209 )]
210 pub subscription_end_time: Option<chrono::DateTime<chrono::Utc>>,
211 #[serde(
215 default,
216 skip_serializing_if = "Option::is_none",
217 deserialize_with = "crate::utils::date_time_format::deserialize"
218 )]
219 pub subscription_start_time: Option<chrono::DateTime<chrono::Utc>>,
220}
221
222#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
224pub struct AccountListItem {
225 #[serde(
229 default,
230 skip_serializing_if = "Vec::is_empty",
231 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
232 )]
233 pub accounts: Vec<Accounts>,
234}
235
236#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
237pub struct Domains {}
238
239#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
241pub struct AccountPlan {
242 #[serde(
246 default,
247 skip_serializing_if = "crate::utils::zero_i64",
248 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
249 )]
250 pub hosts: i64,
251 #[serde(
255 default,
256 skip_serializing_if = "String::is_empty",
257 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
258 rename = "type"
259 )]
260 pub type_: String,
261}
262
263#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
265pub struct PlanBase {
266 #[serde(
270 default,
271 skip_serializing_if = "crate::utils::zero_i64",
272 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
273 )]
274 pub hosts: i64,
275 #[serde(
279 default,
280 skip_serializing_if = "String::is_empty",
281 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
282 rename = "type"
283 )]
284 pub type_: String,
285}
286
287#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
289pub struct PlanAudio {
290 #[serde(
294 default,
295 skip_serializing_if = "String::is_empty",
296 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
297 )]
298 pub callout_countries: String,
299 #[serde(
303 default,
304 skip_serializing_if = "crate::utils::zero_i64",
305 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
306 )]
307 pub ddi_numbers: i64,
308 #[serde(
312 default,
313 skip_serializing_if = "String::is_empty",
314 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
315 )]
316 pub premium_countries: String,
317 #[serde(
321 default,
322 skip_serializing_if = "String::is_empty",
323 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
324 )]
325 pub tollfree_countries: String,
326 #[serde(
330 default,
331 skip_serializing_if = "String::is_empty",
332 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
333 rename = "type"
334 )]
335 pub type_: String,
336}
337
338#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
340pub struct AccountPlansPhonePlanBase {
341 #[serde(
345 default,
346 skip_serializing_if = "String::is_empty",
347 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
348 )]
349 pub callout_countries: String,
350 #[serde(
354 default,
355 skip_serializing_if = "String::is_empty",
356 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
357 rename = "type"
358 )]
359 pub type_: String,
360}
361
362#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
363pub struct PlanNumber {
364 #[serde(
368 default,
369 skip_serializing_if = "crate::utils::zero_i64",
370 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
371 )]
372 pub hosts: i64,
373 #[serde(
377 default,
378 skip_serializing_if = "String::is_empty",
379 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
380 rename = "type"
381 )]
382 pub type_: String,
383}
384
385#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
387pub struct PhonePlan {
388 #[serde(default, skip_serializing_if = "Option::is_none")]
392 pub plan_base: Option<AccountPlansPhonePlanBase>,
393 #[serde(
397 default,
398 skip_serializing_if = "Vec::is_empty",
399 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
400 )]
401 pub plan_calling: Vec<PlanNumber>,
402 #[serde(
406 default,
407 skip_serializing_if = "Vec::is_empty",
408 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
409 )]
410 pub plan_number: Vec<PlanNumber>,
411}
412
413#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
415pub struct AccountPlans {
416 #[serde(default, skip_serializing_if = "Option::is_none")]
420 pub plan_audio: Option<PlanAudio>,
421 pub plan_base: PlanBase,
425 #[serde(
429 default,
430 skip_serializing_if = "Vec::is_empty",
431 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
432 )]
433 pub plan_large_meeting: Vec<AccountPlan>,
434 #[serde(default, skip_serializing_if = "Option::is_none")]
438 pub plan_phone: Option<PhonePlan>,
439 #[serde(
443 default,
444 skip_serializing_if = "String::is_empty",
445 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
446 )]
447 pub plan_recording: String,
448 #[serde(default, skip_serializing_if = "Option::is_none")]
452 pub plan_room_connector: Option<AccountPlan>,
453 #[serde(
457 default,
458 skip_serializing_if = "Vec::is_empty",
459 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
460 )]
461 pub plan_webinar: Vec<AccountPlan>,
462 #[serde(default, skip_serializing_if = "Option::is_none")]
466 pub plan_zoom_rooms: Option<AccountPlan>,
467}
468
469#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
473pub enum AudioType {
474 #[serde(rename = "both")]
475 #[default]
476 Both,
477 #[serde(rename = "telephony")]
478 Telephony,
479 #[serde(rename = "thirdParty")]
480 ThirdParty,
481 #[serde(rename = "voip")]
482 Voip,
483 #[serde(other)]
484 FallthroughString,
485}
486
487impl std::fmt::Display for AudioType {
488 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
489 match self {
490 AudioType::Both => "both",
491 AudioType::Telephony => "telephony",
492 AudioType::ThirdParty => "thirdParty",
493 AudioType::Voip => "voip",
494 AudioType::FallthroughString => "*",
495 }
496 .fmt(f)
497 }
498}
499
500#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
505pub enum RequirePasswordPmiMeetings {
506 #[serde(rename = "all")]
507 All,
508 #[serde(rename = "jbh_only")]
509 JbhOnly,
510 #[serde(rename = "none")]
511 None,
512 #[serde(rename = "")]
513 #[default]
514 Noop,
515 #[serde(other)]
516 FallthroughString,
517}
518
519impl std::fmt::Display for RequirePasswordPmiMeetings {
520 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
521 match self {
522 RequirePasswordPmiMeetings::All => "all",
523 RequirePasswordPmiMeetings::JbhOnly => "jbh_only",
524 RequirePasswordPmiMeetings::None => "none",
525 RequirePasswordPmiMeetings::Noop => "",
526 RequirePasswordPmiMeetings::FallthroughString => "*",
527 }
528 .fmt(f)
529 }
530}
531
532impl RequirePasswordPmiMeetings {
533 pub fn is_noop(&self) -> bool {
534 matches!(self, RequirePasswordPmiMeetings::Noop)
535 }
536}
537
538#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
540pub struct MeetingPasswordRequirement {
541 #[serde(
545 default,
546 skip_serializing_if = "crate::utils::zero_i64",
547 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
548 )]
549 pub consecutive_characters_length: i64,
550 #[serde(
554 default,
555 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
556 )]
557 pub have_letter: bool,
558 #[serde(
562 default,
563 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
564 )]
565 pub have_number: bool,
566 #[serde(
570 default,
571 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
572 )]
573 pub have_special_character: bool,
574 #[serde(
578 default,
579 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
580 )]
581 pub have_upper_and_lower_characters: bool,
582 #[serde(
586 default,
587 skip_serializing_if = "crate::utils::zero_i64",
588 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
589 )]
590 pub length: i64,
591 #[serde(
595 default,
596 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
597 )]
598 pub only_allow_numeric: bool,
599 #[serde(
603 default,
604 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
605 )]
606 pub weak_enhance_detection: bool,
607}
608
609#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
611pub struct ScheduleMeeting {
612 #[serde(default, skip_serializing_if = "Option::is_none")]
616 pub audio_type: Option<AudioType>,
617 #[serde(
621 default,
622 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
623 )]
624 pub enforce_login: bool,
625 #[serde(
629 default,
630 skip_serializing_if = "String::is_empty",
631 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
632 )]
633 pub enforce_login_domains: String,
634 #[serde(
638 default,
639 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
640 )]
641 pub enforce_login_with_domains: bool,
642 #[serde(
646 default,
647 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
648 )]
649 pub force_pmi_jbh_password: bool,
650 #[serde(
654 default,
655 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
656 )]
657 pub host_video: bool,
658 #[serde(
662 default,
663 skip_serializing_if = "crate::utils::zero_i64",
664 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
665 )]
666 pub jbh_time: i64,
667 #[serde(
671 default,
672 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
673 )]
674 pub join_before_host: bool,
675 #[serde(default, skip_serializing_if = "Option::is_none")]
679 pub meeting_password_requirement: Option<MeetingPasswordRequirement>,
680 #[serde(
684 default,
685 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
686 )]
687 pub not_store_meeting_topic: bool,
688 #[serde(
692 default,
693 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
694 )]
695 pub participant_video: bool,
696 #[serde(
700 default,
701 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
702 )]
703 pub personal_meeting: bool,
704 #[serde(
708 default,
709 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
710 )]
711 pub require_password_for_instant_meetings: bool,
712 #[serde(default, skip_serializing_if = "Option::is_none")]
716 pub require_password_for_pmi_meetings: Option<RequirePasswordPmiMeetings>,
717 #[serde(
721 default,
722 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
723 )]
724 pub require_password_for_scheduled_meetings: bool,
725 #[serde(
729 default,
730 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
731 )]
732 pub require_password_for_scheduling_new_meetings: bool,
733 #[serde(
737 default,
738 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
739 )]
740 pub use_pmi_for_instant_meetings: bool,
741 #[serde(
745 default,
746 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
747 )]
748 pub use_pmi_for_scheduled_meetings: bool,
749}
750
751#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
755pub enum EntryExitChime {
756 #[serde(rename = "all")]
757 All,
758 #[serde(rename = "host")]
759 Host,
760 #[serde(rename = "none")]
761 None,
762 #[serde(rename = "")]
763 #[default]
764 Noop,
765 #[serde(other)]
766 FallthroughString,
767}
768
769impl std::fmt::Display for EntryExitChime {
770 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
771 match self {
772 EntryExitChime::All => "all",
773 EntryExitChime::Host => "host",
774 EntryExitChime::None => "none",
775 EntryExitChime::Noop => "",
776 EntryExitChime::FallthroughString => "*",
777 }
778 .fmt(f)
779 }
780}
781
782impl EntryExitChime {
783 pub fn is_noop(&self) -> bool {
784 matches!(self, EntryExitChime::Noop)
785 }
786}
787
788#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
789pub struct Files {
790 #[serde(
794 default,
795 skip_serializing_if = "String::is_empty",
796 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
797 )]
798 pub id: String,
799 #[serde(
803 default,
804 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
805 )]
806 pub is_default: bool,
807 #[serde(
811 default,
812 skip_serializing_if = "String::is_empty",
813 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
814 )]
815 pub name: String,
816 #[serde(
820 default,
821 skip_serializing_if = "String::is_empty",
822 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
823 )]
824 pub size: String,
825 #[serde(
829 default,
830 skip_serializing_if = "String::is_empty",
831 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
832 rename = "type"
833 )]
834 pub type_: String,
835}
836
837#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
839pub struct VirtualBackgroundSettings {
840 #[serde(
844 default,
845 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
846 )]
847 pub allow_upload_custom: bool,
848 #[serde(
852 default,
853 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
854 )]
855 pub allow_videos: bool,
856 #[serde(
860 default,
861 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
862 )]
863 pub enable: bool,
864 #[serde(
868 default,
869 skip_serializing_if = "Vec::is_empty",
870 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
871 )]
872 pub files: Vec<Files>,
873}
874
875#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
882pub enum WhoCanShareScreen {
883 #[serde(rename = "all")]
884 All,
885 #[serde(rename = "host")]
886 Host,
887 #[serde(rename = "")]
888 #[default]
889 Noop,
890 #[serde(other)]
891 FallthroughString,
892}
893
894impl std::fmt::Display for WhoCanShareScreen {
895 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
896 match self {
897 WhoCanShareScreen::All => "all",
898 WhoCanShareScreen::Host => "host",
899 WhoCanShareScreen::Noop => "",
900 WhoCanShareScreen::FallthroughString => "*",
901 }
902 .fmt(f)
903 }
904}
905
906impl WhoCanShareScreen {
907 pub fn is_noop(&self) -> bool {
908 matches!(self, WhoCanShareScreen::Noop)
909 }
910}
911
912#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
914pub struct InMeeting {
915 #[serde(
919 default,
920 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
921 )]
922 pub alert_guest_join: bool,
923 #[serde(
927 default,
928 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
929 )]
930 pub allow_live_streaming: bool,
931 #[serde(
935 default,
936 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
937 )]
938 pub allow_participants_to_rename: bool,
939 #[serde(
943 default,
944 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
945 )]
946 pub allow_show_zoom_windows: bool,
947 #[serde(
951 default,
952 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
953 )]
954 pub annotation: bool,
955 #[serde(
959 default,
960 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
961 )]
962 pub anonymous_question_answer: bool,
963 #[serde(
967 default,
968 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
969 )]
970 pub attendee_on_hold: bool,
971 #[serde(
975 default,
976 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
977 )]
978 pub auto_answer: bool,
979 #[serde(
983 default,
984 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
985 )]
986 pub auto_saving_chat: bool,
987 #[serde(
991 default,
992 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
993 )]
994 pub breakout_room: bool,
995 #[serde(
999 default,
1000 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1001 )]
1002 pub chat: bool,
1003 #[serde(
1007 default,
1008 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1009 )]
1010 pub closed_caption: bool,
1011 #[serde(
1015 default,
1016 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1017 )]
1018 pub co_host: bool,
1019 #[serde(
1023 default,
1024 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1025 )]
1026 pub custom_data_center_regions: bool,
1027 #[serde(
1031 default,
1032 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1033 )]
1034 pub custom_live_streaming_service: bool,
1035 #[serde(
1039 default,
1040 skip_serializing_if = "String::is_empty",
1041 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1042 )]
1043 pub custom_service_instructions: String,
1044 #[serde(
1048 default,
1049 skip_serializing_if = "Vec::is_empty",
1050 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
1051 )]
1052 pub data_center_regions: Vec<String>,
1053 #[serde(
1057 default,
1058 skip_serializing_if = "crate::utils::zero_i64",
1059 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
1060 )]
1061 pub dscp_audio: i64,
1062 #[serde(
1066 default,
1067 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1068 )]
1069 pub dscp_marking: bool,
1070 #[serde(
1074 default,
1075 skip_serializing_if = "crate::utils::zero_i64",
1076 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
1077 )]
1078 pub dscp_video: i64,
1079 #[serde(
1083 default,
1084 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
1085 rename = "e2e_encryption"
1086 )]
1087 pub e_2e_encryption: bool,
1088 #[serde(default, skip_serializing_if = "Option::is_none")]
1092 pub entry_exit_chime: Option<EntryExitChime>,
1093 #[serde(
1097 default,
1098 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1099 )]
1100 pub far_end_camera_control: bool,
1101 #[serde(
1105 default,
1106 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1107 )]
1108 pub feedback: bool,
1109 #[serde(
1113 default,
1114 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1115 )]
1116 pub file_transfer: bool,
1117 #[serde(
1121 default,
1122 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1123 )]
1124 pub group_hd: bool,
1125 #[serde(
1129 default,
1130 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1131 )]
1132 pub join_from_desktop: bool,
1133 #[serde(
1137 default,
1138 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1139 )]
1140 pub join_from_mobile: bool,
1141 #[serde(
1145 default,
1146 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1147 )]
1148 pub meeting_reactions: bool,
1149 #[serde(
1153 default,
1154 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1155 )]
1156 pub original_audio: bool,
1157 #[serde(
1161 default,
1162 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
1163 rename = "p2p_connetion"
1164 )]
1165 pub p_2p_connetion: bool,
1166 #[serde(
1170 default,
1171 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
1172 rename = "p2p_ports"
1173 )]
1174 pub p_2p_ports: bool,
1175 #[serde(
1179 default,
1180 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1181 )]
1182 pub polling: bool,
1183 #[serde(
1187 default,
1188 skip_serializing_if = "String::is_empty",
1189 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1190 )]
1191 pub ports_range: String,
1192 #[serde(
1196 default,
1197 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1198 )]
1199 pub post_meeting_feedback: bool,
1200 #[serde(
1204 default,
1205 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1206 )]
1207 pub private_chat: bool,
1208 #[serde(
1212 default,
1213 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1214 )]
1215 pub record_play_own_voice: bool,
1216 #[serde(
1220 default,
1221 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1222 )]
1223 pub remote_control: bool,
1224 #[serde(
1228 default,
1229 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1230 )]
1231 pub request_permission_to_unmute: bool,
1232 #[serde(
1236 default,
1237 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1238 )]
1239 pub screen_sharing: bool,
1240 #[serde(
1244 default,
1245 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1246 )]
1247 pub sending_default_email_invites: bool,
1248 #[serde(
1252 default,
1253 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1254 )]
1255 pub show_a_join_from_your_browser_link: bool,
1256 #[serde(
1260 default,
1261 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1262 )]
1263 pub show_meeting_control_toolbar: bool,
1264 #[serde(
1268 default,
1269 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1270 )]
1271 pub stereo_audio: bool,
1272 #[serde(
1276 default,
1277 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1278 )]
1279 pub use_html_format_email: bool,
1280 #[serde(
1284 default,
1285 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1286 )]
1287 pub virtual_background: bool,
1288 #[serde(default, skip_serializing_if = "Option::is_none")]
1292 pub virtual_background_settings: Option<VirtualBackgroundSettings>,
1293 #[serde(
1297 default,
1298 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1299 )]
1300 pub watermark: bool,
1301 #[serde(
1305 default,
1306 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1307 )]
1308 pub webinar_question_answer: bool,
1309 #[serde(
1313 default,
1314 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1315 )]
1316 pub whiteboard: bool,
1317 #[serde(default, skip_serializing_if = "Option::is_none")]
1321 pub who_can_share_screen: Option<WhoCanShareScreen>,
1322 #[serde(default, skip_serializing_if = "Option::is_none")]
1326 pub who_can_share_screen_when_someone_is_sharing: Option<WhoCanShareScreen>,
1327 #[serde(
1331 default,
1332 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1333 )]
1334 pub workplace_by_facebook: bool,
1335}
1336
1337#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1339pub struct EmailNotification {
1340 #[serde(
1344 default,
1345 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1346 )]
1347 pub alternative_host_reminder: bool,
1348 #[serde(
1352 default,
1353 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1354 )]
1355 pub cancel_meeting_reminder: bool,
1356 #[serde(
1360 default,
1361 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1362 )]
1363 pub cloud_recording_avaliable_reminder: bool,
1364 #[serde(
1368 default,
1369 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1370 )]
1371 pub jbh_reminder: bool,
1372 #[serde(
1376 default,
1377 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1378 )]
1379 pub low_host_count_reminder: bool,
1380 #[serde(
1384 default,
1385 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1386 )]
1387 pub schedule_for_reminder: bool,
1388}
1389
1390#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1392pub struct ZoomRooms {
1393 #[serde(
1397 default,
1398 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1399 )]
1400 pub auto_start_stop_scheduled_meetings: bool,
1401 #[serde(
1405 default,
1406 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1407 )]
1408 pub cmr_for_instant_meeting: bool,
1409 #[serde(
1413 default,
1414 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1415 )]
1416 pub force_private_meeting: bool,
1417 #[serde(
1421 default,
1422 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1423 )]
1424 pub hide_host_information: bool,
1425 #[serde(
1429 default,
1430 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1431 )]
1432 pub list_meetings_with_calendar: bool,
1433 #[serde(
1437 default,
1438 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1439 )]
1440 pub start_airplay_manually: bool,
1441 #[serde(
1445 default,
1446 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1447 )]
1448 pub ultrasonic: bool,
1449 #[serde(
1453 default,
1454 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1455 )]
1456 pub upcoming_meeting_alert: bool,
1457 #[serde(
1461 default,
1462 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1463 )]
1464 pub weekly_system_restart: bool,
1465 #[serde(
1469 default,
1470 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1471 )]
1472 pub zr_post_meeting_feedback: bool,
1473}
1474
1475#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1477pub struct PasswordRequirement {
1478 #[serde(
1482 default,
1483 skip_serializing_if = "crate::utils::zero_i64",
1484 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
1485 )]
1486 pub consecutive_characters_length: i64,
1487 #[serde(
1491 default,
1492 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1493 )]
1494 pub have_special_character: bool,
1495 #[serde(
1499 default,
1500 skip_serializing_if = "crate::utils::zero_i64",
1501 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
1502 )]
1503 pub minimum_password_length: i64,
1504 #[serde(
1508 default,
1509 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1510 )]
1511 pub weak_enhance_detection: bool,
1512}
1513
1514#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
1524pub enum SignInWithTwoFactorAuth {
1525 #[serde(rename = "all")]
1526 All,
1527 #[serde(rename = "group")]
1528 Group,
1529 #[serde(rename = "none")]
1530 None,
1531 #[serde(rename = "role")]
1532 Role,
1533 #[serde(rename = "")]
1534 #[default]
1535 Noop,
1536 #[serde(other)]
1537 FallthroughString,
1538}
1539
1540impl std::fmt::Display for SignInWithTwoFactorAuth {
1541 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1542 match self {
1543 SignInWithTwoFactorAuth::All => "all",
1544 SignInWithTwoFactorAuth::Group => "group",
1545 SignInWithTwoFactorAuth::None => "none",
1546 SignInWithTwoFactorAuth::Role => "role",
1547 SignInWithTwoFactorAuth::Noop => "",
1548 SignInWithTwoFactorAuth::FallthroughString => "*",
1549 }
1550 .fmt(f)
1551 }
1552}
1553
1554impl SignInWithTwoFactorAuth {
1555 pub fn is_noop(&self) -> bool {
1556 matches!(self, SignInWithTwoFactorAuth::Noop)
1557 }
1558}
1559
1560#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1562pub struct Security {
1563 #[serde(
1567 default,
1568 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1569 )]
1570 pub admin_change_name_pic: bool,
1571 #[serde(
1575 default,
1576 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1577 )]
1578 pub hide_billing_info: bool,
1579 #[serde(
1583 default,
1584 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1585 )]
1586 pub import_photos_from_devices: bool,
1587 #[serde(default, skip_serializing_if = "Option::is_none")]
1591 pub password_requirement: Option<PasswordRequirement>,
1592 #[serde(
1596 default,
1597 skip_serializing_if = "crate::utils::zero_i64",
1598 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
1599 )]
1600 pub sign_again_period_for_inactivity_on_client: i64,
1601 #[serde(
1605 default,
1606 skip_serializing_if = "crate::utils::zero_i64",
1607 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
1608 )]
1609 pub sign_again_period_for_inactivity_on_web: i64,
1610 #[serde(default, skip_serializing_if = "Option::is_none")]
1614 pub sign_in_with_two_factor_auth: Option<SignInWithTwoFactorAuth>,
1615 #[serde(
1619 default,
1620 skip_serializing_if = "Vec::is_empty",
1621 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
1622 )]
1623 pub sign_in_with_two_factor_auth_groups: Vec<String>,
1624 #[serde(
1628 default,
1629 skip_serializing_if = "Vec::is_empty",
1630 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
1631 )]
1632 pub sign_in_with_two_factor_auth_roles: Vec<String>,
1633}
1634
1635#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
1639pub enum AutoRecording {
1640 #[serde(rename = "cloud")]
1641 Cloud,
1642 #[serde(rename = "local")]
1643 Local,
1644 #[serde(rename = "none")]
1645 None,
1646 #[serde(rename = "")]
1647 #[default]
1648 Noop,
1649 #[serde(other)]
1650 FallthroughString,
1651}
1652
1653impl std::fmt::Display for AutoRecording {
1654 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1655 match self {
1656 AutoRecording::Cloud => "cloud",
1657 AutoRecording::Local => "local",
1658 AutoRecording::None => "none",
1659 AutoRecording::Noop => "",
1660 AutoRecording::FallthroughString => "*",
1661 }
1662 .fmt(f)
1663 }
1664}
1665
1666impl AutoRecording {
1667 pub fn is_noop(&self) -> bool {
1668 matches!(self, AutoRecording::Noop)
1669 }
1670}
1671
1672#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1674pub struct RecordingPasswordRequirement {
1675 #[serde(
1679 default,
1680 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1681 )]
1682 pub have_letter: bool,
1683 #[serde(
1687 default,
1688 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1689 )]
1690 pub have_number: bool,
1691 #[serde(
1695 default,
1696 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1697 )]
1698 pub have_special_character: bool,
1699 #[serde(
1703 default,
1704 skip_serializing_if = "crate::utils::zero_i64",
1705 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
1706 )]
1707 pub length: i64,
1708 #[serde(
1712 default,
1713 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1714 )]
1715 pub only_allow_numeric: bool,
1716}
1717
1718#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1721pub struct IpAddressAccessControl {
1722 #[serde(
1727 default,
1728 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1729 )]
1730 pub enable: bool,
1731 #[serde(
1736 default,
1737 skip_serializing_if = "String::is_empty",
1738 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1739 )]
1740 pub ip_addresses_or_ranges: String,
1741}
1742
1743#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1744pub struct Settings {
1745 #[serde(
1749 default,
1750 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1751 )]
1752 pub audio_file: bool,
1753 #[serde(
1757 default,
1758 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1759 )]
1760 pub cc_transcript_file: bool,
1761 #[serde(
1765 default,
1766 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1767 )]
1768 pub chat_file: bool,
1769 #[serde(
1773 default,
1774 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1775 )]
1776 pub chat_with_sender_email: bool,
1777 #[serde(
1781 default,
1782 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1783 )]
1784 pub video_file: bool,
1785}
1786
1787#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1789pub struct Archive {
1790 #[serde(
1794 default,
1795 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1796 )]
1797 pub enable: bool,
1798 #[serde(default, skip_serializing_if = "Option::is_none")]
1802 pub settings: Option<Settings>,
1803 #[serde(
1807 default,
1808 skip_serializing_if = "crate::utils::zero_i64",
1809 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
1810 rename = "type"
1811 )]
1812 pub type_: i64,
1813}
1814
1815#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1817pub struct Recording {
1818 #[serde(
1822 default,
1823 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1824 )]
1825 pub account_user_access_recording: bool,
1826 #[serde(
1830 default,
1831 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1832 )]
1833 pub allow_recovery_deleted_cloud_recordings: bool,
1834 #[serde(default, skip_serializing_if = "Option::is_none")]
1838 pub archive: Option<Archive>,
1839 #[serde(
1843 default,
1844 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1845 )]
1846 pub auto_delete_cmr: bool,
1847 #[serde(
1851 default,
1852 skip_serializing_if = "crate::utils::zero_i64",
1853 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
1854 )]
1855 pub auto_delete_cmr_days: i64,
1856 #[serde(default, skip_serializing_if = "Option::is_none")]
1860 pub auto_recording: Option<AutoRecording>,
1861 #[serde(
1865 default,
1866 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1867 )]
1868 pub cloud_recording: bool,
1869 #[serde(
1873 default,
1874 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1875 )]
1876 pub cloud_recording_download: bool,
1877 #[serde(
1881 default,
1882 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1883 )]
1884 pub cloud_recording_download_host: bool,
1885 #[serde(
1889 default,
1890 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1891 )]
1892 pub host_delete_cloud_recording: bool,
1893 #[serde(default, skip_serializing_if = "Option::is_none")]
1897 pub ip_address_access_control: Option<IpAddressAccessControl>,
1898 #[serde(
1902 default,
1903 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1904 )]
1905 pub local_recording: bool,
1906 #[serde(
1910 default,
1911 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1912 )]
1913 pub prevent_host_access_recording: bool,
1914 #[serde(
1918 default,
1919 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1920 )]
1921 pub record_audio_file: bool,
1922 #[serde(
1926 default,
1927 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1928 )]
1929 pub record_audio_file_each_participant: bool,
1930 #[serde(
1934 default,
1935 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1936 )]
1937 pub record_gallery_view: bool,
1938 #[serde(
1942 default,
1943 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1944 )]
1945 pub record_speaker_view: bool,
1946 #[serde(
1950 default,
1951 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1952 )]
1953 pub recording_audio_transcript: bool,
1954 #[serde(
1958 default,
1959 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1960 )]
1961 pub recording_disclaimer: bool,
1962 #[serde(default, skip_serializing_if = "Option::is_none")]
1966 pub recording_password_requirement: Option<RecordingPasswordRequirement>,
1967 #[serde(
1971 default,
1972 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1973 )]
1974 pub required_password_for_existing_cloud_recordings: bool,
1975 #[serde(
1979 default,
1980 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1981 )]
1982 pub save_chat_text: bool,
1983 #[serde(
1987 default,
1988 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1989 )]
1990 pub show_timestamp: bool,
1991}
1992
1993#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1995pub struct TelephonyRegions {
1996 #[serde(
2000 default,
2001 skip_serializing_if = "Vec::is_empty",
2002 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
2003 )]
2004 pub allowed_values: Vec<String>,
2005 #[serde(
2009 default,
2010 skip_serializing_if = "Vec::is_empty",
2011 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
2012 )]
2013 pub selection_values: Vec<String>,
2014}
2015
2016#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2018pub struct Telephony {
2019 #[serde(
2023 default,
2024 skip_serializing_if = "String::is_empty",
2025 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2026 )]
2027 pub audio_conference_info: String,
2028 #[serde(default, skip_serializing_if = "Option::is_none")]
2032 pub telephony_regions: Option<TelephonyRegions>,
2033 #[serde(
2037 default,
2038 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
2039 )]
2040 pub third_party_audio: bool,
2041}
2042
2043#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2045pub struct Integration {
2046 #[serde(
2050 default,
2051 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
2052 rename = "box"
2053 )]
2054 pub box_: bool,
2055 #[serde(
2059 default,
2060 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
2061 )]
2062 pub dropbox: bool,
2063 #[serde(
2067 default,
2068 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
2069 )]
2070 pub google_calendar: bool,
2071 #[serde(
2075 default,
2076 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
2077 )]
2078 pub google_drive: bool,
2079 #[serde(
2083 default,
2084 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
2085 )]
2086 pub kubi: bool,
2087 #[serde(
2091 default,
2092 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
2093 )]
2094 pub microsoft_one_drive: bool,
2095}
2096
2097#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2099pub struct Feature {
2100 #[serde(
2104 default,
2105 skip_serializing_if = "crate::utils::zero_i64",
2106 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
2107 )]
2108 pub meeting_capacity: i64,
2109}
2110
2111#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2113pub struct Tsp {
2114 #[serde(
2118 default,
2119 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
2120 )]
2121 pub call_out: bool,
2122 #[serde(
2126 default,
2127 skip_serializing_if = "Vec::is_empty",
2128 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
2129 )]
2130 pub call_out_countries: Vec<String>,
2131 #[serde(
2135 default,
2136 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
2137 )]
2138 pub display_toll_free_numbers: bool,
2139 #[serde(
2143 default,
2144 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
2145 )]
2146 pub show_international_numbers_link: bool,
2147}
2148
2149#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2150pub struct RecordingStorageLocation {
2151 #[serde(
2158 default,
2159 skip_serializing_if = "Vec::is_empty",
2160 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
2161 )]
2162 pub allowed_values: Vec<String>,
2163 #[serde(
2167 default,
2168 skip_serializing_if = "String::is_empty",
2169 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2170 )]
2171 pub value: String,
2172}
2173
2174#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2175pub struct Profile {
2176 #[serde(default, skip_serializing_if = "Option::is_none")]
2177 pub recording_storage_location: Option<RecordingStorageLocation>,
2178}
2179
2180#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2181pub struct AccountSettings {
2182 #[serde(default, skip_serializing_if = "Option::is_none")]
2183 pub email_notification: Option<EmailNotification>,
2184 #[serde(default, skip_serializing_if = "Option::is_none")]
2185 pub feature: Option<Feature>,
2186 #[serde(default, skip_serializing_if = "Option::is_none")]
2187 pub in_meeting: Option<InMeeting>,
2188 #[serde(default, skip_serializing_if = "Option::is_none")]
2189 pub integration: Option<Integration>,
2190 #[serde(default, skip_serializing_if = "Option::is_none")]
2191 pub profile: Option<Profile>,
2192 #[serde(default, skip_serializing_if = "Option::is_none")]
2193 pub recording: Option<Recording>,
2194 #[serde(default, skip_serializing_if = "Option::is_none")]
2195 pub schedule_meeting: Option<ScheduleMeeting>,
2196 #[serde(default, skip_serializing_if = "Option::is_none")]
2197 pub security: Option<Security>,
2198 #[serde(default, skip_serializing_if = "Option::is_none")]
2199 pub telephony: Option<Telephony>,
2200 #[serde(default, skip_serializing_if = "Option::is_none")]
2201 pub tsp: Option<Tsp>,
2202 #[serde(default, skip_serializing_if = "Option::is_none")]
2203 pub zoom_rooms: Option<ZoomRooms>,
2204}
2205
2206#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2208pub struct UpdateAccountSettingsTelephonyRegions {
2209 #[serde(
2213 default,
2214 skip_serializing_if = "Vec::is_empty",
2215 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
2216 )]
2217 pub selection_values: Vec<String>,
2218}
2219
2220#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2222pub struct UpdateAccountSettingsTelephony {
2223 #[serde(
2227 default,
2228 skip_serializing_if = "String::is_empty",
2229 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2230 )]
2231 pub audio_conference_info: String,
2232 #[serde(default, skip_serializing_if = "Option::is_none")]
2236 pub telephony_regions: Option<UpdateAccountSettingsTelephonyRegions>,
2237 #[serde(
2241 default,
2242 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
2243 )]
2244 pub third_party_audio: bool,
2245}
2246
2247#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2248pub struct UpdateAccountSettings {
2249 #[serde(default, skip_serializing_if = "Option::is_none")]
2250 pub email_notification: Option<EmailNotification>,
2251 #[serde(default, skip_serializing_if = "Option::is_none")]
2252 pub feature: Option<Feature>,
2253 #[serde(default, skip_serializing_if = "Option::is_none")]
2254 pub in_meeting: Option<InMeeting>,
2255 #[serde(default, skip_serializing_if = "Option::is_none")]
2256 pub integration: Option<Integration>,
2257 #[serde(default, skip_serializing_if = "Option::is_none")]
2258 pub profile: Option<Profile>,
2259 #[serde(default, skip_serializing_if = "Option::is_none")]
2260 pub recording: Option<Recording>,
2261 #[serde(default, skip_serializing_if = "Option::is_none")]
2262 pub schedule_meeting: Option<ScheduleMeeting>,
2263 #[serde(default, skip_serializing_if = "Option::is_none")]
2264 pub security: Option<Security>,
2265 #[serde(default, skip_serializing_if = "Option::is_none")]
2266 pub telephony: Option<UpdateAccountSettingsTelephony>,
2267 #[serde(default, skip_serializing_if = "Option::is_none")]
2268 pub tsp: Option<Tsp>,
2269 #[serde(default, skip_serializing_if = "Option::is_none")]
2270 pub zoom_rooms: Option<ZoomRooms>,
2271}
2272
2273#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2275pub struct DomainsList {
2276 #[serde(
2280 default,
2281 skip_serializing_if = "Vec::is_empty",
2282 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
2283 )]
2284 pub domains: Vec<Domains>,
2285 #[serde(
2289 default,
2290 skip_serializing_if = "crate::utils::zero_i64",
2291 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
2292 )]
2293 pub total_records: i64,
2294}
2295
2296#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2298pub struct BillingContact {
2299 #[serde(
2303 default,
2304 skip_serializing_if = "String::is_empty",
2305 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2306 )]
2307 pub address: String,
2308 #[serde(
2312 default,
2313 skip_serializing_if = "String::is_empty",
2314 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2315 )]
2316 pub apt: String,
2317 #[serde(
2321 default,
2322 skip_serializing_if = "String::is_empty",
2323 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2324 )]
2325 pub city: String,
2326 #[serde(
2330 default,
2331 skip_serializing_if = "String::is_empty",
2332 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2333 )]
2334 pub country: String,
2335 #[serde(
2339 default,
2340 skip_serializing_if = "String::is_empty",
2341 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2342 )]
2343 pub email: String,
2344 #[serde(
2348 default,
2349 skip_serializing_if = "String::is_empty",
2350 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2351 )]
2352 pub first_name: String,
2353 #[serde(
2357 default,
2358 skip_serializing_if = "String::is_empty",
2359 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2360 )]
2361 pub last_name: String,
2362 #[serde(
2366 default,
2367 skip_serializing_if = "String::is_empty",
2368 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2369 )]
2370 pub phone_number: String,
2371 #[serde(
2375 default,
2376 skip_serializing_if = "String::is_empty",
2377 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2378 )]
2379 pub state: String,
2380 #[serde(
2384 default,
2385 skip_serializing_if = "String::is_empty",
2386 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2387 )]
2388 pub zip: String,
2389}
2390
2391#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2393pub struct Contact {
2394 #[serde(
2398 default,
2399 skip_serializing_if = "String::is_empty",
2400 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2401 )]
2402 pub address: String,
2403 #[serde(
2407 default,
2408 skip_serializing_if = "String::is_empty",
2409 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2410 )]
2411 pub apt: String,
2412 #[serde(
2416 default,
2417 skip_serializing_if = "String::is_empty",
2418 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2419 )]
2420 pub city: String,
2421 #[serde(
2425 default,
2426 skip_serializing_if = "String::is_empty",
2427 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2428 )]
2429 pub country: String,
2430 #[serde(
2434 default,
2435 skip_serializing_if = "String::is_empty",
2436 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2437 )]
2438 pub email: String,
2439 #[serde(
2443 default,
2444 skip_serializing_if = "String::is_empty",
2445 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2446 )]
2447 pub first_name: String,
2448 #[serde(
2452 default,
2453 skip_serializing_if = "String::is_empty",
2454 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2455 )]
2456 pub last_name: String,
2457 #[serde(
2461 default,
2462 skip_serializing_if = "String::is_empty",
2463 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2464 )]
2465 pub phone_number: String,
2466 #[serde(
2470 default,
2471 skip_serializing_if = "String::is_empty",
2472 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2473 )]
2474 pub state: String,
2475 #[serde(
2479 default,
2480 skip_serializing_if = "String::is_empty",
2481 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2482 )]
2483 pub zip: String,
2484}
2485
2486#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2488pub struct CustomQuestion {
2489 #[serde(
2493 default,
2494 skip_serializing_if = "String::is_empty",
2495 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2496 )]
2497 pub title: String,
2498 #[serde(
2502 default,
2503 skip_serializing_if = "String::is_empty",
2504 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2505 )]
2506 pub value: String,
2507}
2508
2509#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2511pub struct DateTime {
2512 #[serde(
2516 default,
2517 skip_serializing_if = "Option::is_none",
2518 deserialize_with = "crate::utils::date_format::deserialize"
2519 )]
2520 pub from: Option<chrono::NaiveDate>,
2521 #[serde(
2525 default,
2526 skip_serializing_if = "Option::is_none",
2527 deserialize_with = "crate::utils::date_format::deserialize"
2528 )]
2529 pub to: Option<chrono::NaiveDate>,
2530}
2531
2532#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
2536pub enum Protocol {
2537 #[serde(rename = "H.323")]
2538 H323,
2539 #[serde(rename = "SIP")]
2540 Sip,
2541 #[serde(rename = "")]
2542 #[default]
2543 Noop,
2544 #[serde(other)]
2545 FallthroughString,
2546}
2547
2548impl std::fmt::Display for Protocol {
2549 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2550 match self {
2551 Protocol::H323 => "H.323",
2552 Protocol::Sip => "SIP",
2553 Protocol::Noop => "",
2554 Protocol::FallthroughString => "*",
2555 }
2556 .fmt(f)
2557 }
2558}
2559
2560impl Protocol {
2561 pub fn is_noop(&self) -> bool {
2562 matches!(self, Protocol::Noop)
2563 }
2564}
2565
2566#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
2570pub enum Encryption {
2571 #[serde(rename = "auto")]
2572 Auto,
2573 #[serde(rename = "no")]
2574 No,
2575 #[serde(rename = "yes")]
2576 Yes,
2577 #[serde(rename = "")]
2578 #[default]
2579 Noop,
2580 #[serde(other)]
2581 FallthroughString,
2582}
2583
2584impl std::fmt::Display for Encryption {
2585 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2586 match self {
2587 Encryption::Auto => "auto",
2588 Encryption::No => "no",
2589 Encryption::Yes => "yes",
2590 Encryption::Noop => "",
2591 Encryption::FallthroughString => "*",
2592 }
2593 .fmt(f)
2594 }
2595}
2596
2597impl Encryption {
2598 pub fn is_noop(&self) -> bool {
2599 matches!(self, Encryption::Noop)
2600 }
2601}
2602
2603#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2605pub struct Device {
2606 #[serde(default, skip_serializing_if = "Encryption::is_noop")]
2610 pub encryption: Encryption,
2611 #[serde(
2615 default,
2616 skip_serializing_if = "String::is_empty",
2617 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2618 )]
2619 pub ip: String,
2620 #[serde(
2624 default,
2625 skip_serializing_if = "String::is_empty",
2626 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2627 )]
2628 pub name: String,
2629 #[serde(default, skip_serializing_if = "Protocol::is_noop")]
2633 pub protocol: Protocol,
2634}
2635
2636#[derive(Serialize, Default, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2638pub struct Group {
2639 #[serde(
2643 default,
2644 skip_serializing_if = "String::is_empty",
2645 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2646 )]
2647 pub name: String,
2648 #[serde(
2652 default,
2653 skip_serializing_if = "crate::utils::zero_i64",
2654 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
2655 )]
2656 pub total_members: i64,
2657}
2658
2659#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2660pub struct Groups {
2661 #[serde(
2665 default,
2666 skip_serializing_if = "String::is_empty",
2667 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2668 )]
2669 pub id: String,
2670}
2671
2672#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2678pub struct GroupsAllOf {
2679 #[serde(flatten)]
2683 pub group: Group,
2684 #[serde(flatten)]
2685 pub groups: Groups,
2686}
2687
2688#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2690pub struct GroupList {
2691 #[serde(
2695 default,
2696 skip_serializing_if = "Vec::is_empty",
2697 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
2698 )]
2699 pub groups: Vec<GroupsAllOf>,
2700 #[serde(
2704 default,
2705 skip_serializing_if = "crate::utils::zero_i64",
2706 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
2707 )]
2708 pub total_records: i64,
2709}
2710
2711#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2713pub struct GroupMember {
2714 #[serde(
2718 default,
2719 skip_serializing_if = "String::is_empty",
2720 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2721 )]
2722 pub email: String,
2723 #[serde(
2727 default,
2728 skip_serializing_if = "String::is_empty",
2729 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2730 )]
2731 pub first_name: String,
2732 #[serde(
2736 default,
2737 skip_serializing_if = "String::is_empty",
2738 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2739 )]
2740 pub id: String,
2741 #[serde(
2745 default,
2746 skip_serializing_if = "String::is_empty",
2747 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2748 )]
2749 pub last_name: String,
2750 #[serde(
2754 default,
2755 skip_serializing_if = "crate::utils::zero_i64",
2756 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
2757 rename = "type"
2758 )]
2759 pub type_: i64,
2760}
2761
2762#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2763pub struct TrackingFields {
2764 #[serde(
2768 default,
2769 skip_serializing_if = "String::is_empty",
2770 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2771 )]
2772 pub field: String,
2773 #[serde(
2777 default,
2778 skip_serializing_if = "String::is_empty",
2779 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2780 )]
2781 pub value: String,
2782 #[serde(
2786 default,
2787 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
2788 )]
2789 pub visible: bool,
2790}
2791
2792#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2794pub struct Occurrence {
2795 #[serde(
2799 default,
2800 skip_serializing_if = "crate::utils::zero_i64",
2801 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
2802 )]
2803 pub duration: i64,
2804 #[serde(
2808 default,
2809 skip_serializing_if = "String::is_empty",
2810 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2811 )]
2812 pub occurrence_id: String,
2813 #[serde(
2817 default,
2818 skip_serializing_if = "Option::is_none",
2819 deserialize_with = "crate::utils::date_time_format::deserialize"
2820 )]
2821 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
2822 #[serde(
2826 default,
2827 skip_serializing_if = "String::is_empty",
2828 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2829 )]
2830 pub status: String,
2831}
2832
2833#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
2837pub enum Audio {
2838 #[serde(rename = "both")]
2839 #[default]
2840 Both,
2841 #[serde(rename = "telephony")]
2842 Telephony,
2843 #[serde(rename = "voip")]
2844 Voip,
2845 #[serde(other)]
2846 FallthroughString,
2847}
2848
2849impl std::fmt::Display for Audio {
2850 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2851 match self {
2852 Audio::Both => "both",
2853 Audio::Telephony => "telephony",
2854 Audio::Voip => "voip",
2855 Audio::FallthroughString => "*",
2856 }
2857 .fmt(f)
2858 }
2859}
2860
2861#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
2865pub enum Type {
2866 #[serde(rename = "toll")]
2867 Toll,
2868 #[serde(rename = "tollfree")]
2869 Tollfree,
2870 #[serde(rename = "")]
2871 #[default]
2872 Noop,
2873 #[serde(other)]
2874 FallthroughString,
2875}
2876
2877impl std::fmt::Display for Type {
2878 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2879 match self {
2880 Type::Toll => "toll",
2881 Type::Tollfree => "tollfree",
2882 Type::Noop => "",
2883 Type::FallthroughString => "*",
2884 }
2885 .fmt(f)
2886 }
2887}
2888
2889impl Type {
2890 pub fn is_noop(&self) -> bool {
2891 matches!(self, Type::Noop)
2892 }
2893}
2894
2895#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
2896pub struct GlobalDialInNumbers {
2897 #[serde(
2901 default,
2902 skip_serializing_if = "String::is_empty",
2903 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2904 )]
2905 pub city: String,
2906 #[serde(
2910 default,
2911 skip_serializing_if = "String::is_empty",
2912 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2913 )]
2914 pub country: String,
2915 #[serde(
2919 default,
2920 skip_serializing_if = "String::is_empty",
2921 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2922 )]
2923 pub country_name: String,
2924 #[serde(
2928 default,
2929 skip_serializing_if = "String::is_empty",
2930 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
2931 )]
2932 pub number: String,
2933 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
2937 pub type_: Option<Type>,
2938}
2939
2940#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
2947pub enum EncryptionType {
2948 #[serde(rename = "e2ee")]
2949 E2Ee,
2950 #[serde(rename = "enhanced_encryption")]
2951 EnhancedEncryption,
2952 #[serde(rename = "")]
2953 #[default]
2954 Noop,
2955 #[serde(other)]
2956 FallthroughString,
2957}
2958
2959impl std::fmt::Display for EncryptionType {
2960 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2961 match self {
2962 EncryptionType::E2Ee => "e2ee",
2963 EncryptionType::EnhancedEncryption => "enhanced_encryption",
2964 EncryptionType::Noop => "",
2965 EncryptionType::FallthroughString => "*",
2966 }
2967 .fmt(f)
2968 }
2969}
2970
2971impl EncryptionType {
2972 pub fn is_noop(&self) -> bool {
2973 matches!(self, EncryptionType::Noop)
2974 }
2975}
2976
2977#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
2983pub enum Method {
2984 #[serde(rename = "approve")]
2985 Approve,
2986 #[serde(rename = "deny")]
2987 Deny,
2988 #[serde(rename = "")]
2989 #[default]
2990 Noop,
2991 #[serde(other)]
2992 FallthroughString,
2993}
2994
2995impl std::fmt::Display for Method {
2996 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2997 match self {
2998 Method::Approve => "approve",
2999 Method::Deny => "deny",
3000 Method::Noop => "",
3001 Method::FallthroughString => "*",
3002 }
3003 .fmt(f)
3004 }
3005}
3006
3007impl Method {
3008 pub fn is_noop(&self) -> bool {
3009 matches!(self, Method::Noop)
3010 }
3011}
3012
3013#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3016pub struct ApprovedDeniedCountriesRegions {
3017 #[serde(
3022 default,
3023 skip_serializing_if = "Vec::is_empty",
3024 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3025 )]
3026 pub approved_list: Vec<String>,
3027 #[serde(
3032 default,
3033 skip_serializing_if = "Vec::is_empty",
3034 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3035 )]
3036 pub denied_list: Vec<String>,
3037 #[serde(
3042 default,
3043 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3044 )]
3045 pub enable: bool,
3046 #[serde(default, skip_serializing_if = "Option::is_none")]
3051 pub method: Option<Method>,
3052}
3053
3054#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3055pub struct AuthenticationException {
3056 #[serde(
3060 default,
3061 skip_serializing_if = "String::is_empty",
3062 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3063 )]
3064 pub email: String,
3065 #[serde(
3069 default,
3070 skip_serializing_if = "String::is_empty",
3071 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3072 )]
3073 pub name: String,
3074}
3075
3076#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3077pub struct Rooms {
3078 #[serde(
3082 default,
3083 skip_serializing_if = "String::is_empty",
3084 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3085 )]
3086 pub name: String,
3087 #[serde(
3094 default,
3095 skip_serializing_if = "Vec::is_empty",
3096 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3097 )]
3098 pub participants: Vec<String>,
3099}
3100
3101#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3103pub struct BreakoutRoom {
3104 #[serde(
3108 default,
3109 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3110 )]
3111 pub enable: bool,
3112 #[serde(
3116 default,
3117 skip_serializing_if = "Vec::is_empty",
3118 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3119 )]
3120 pub rooms: Vec<Rooms>,
3121}
3122
3123#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3124pub struct Interpreters {
3125 #[serde(
3129 default,
3130 skip_serializing_if = "String::is_empty",
3131 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3132 )]
3133 pub email: String,
3134 #[serde(
3138 default,
3139 skip_serializing_if = "String::is_empty",
3140 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3141 )]
3142 pub languages: String,
3143}
3144
3145#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3146pub struct LanguageInterpretation {
3147 #[serde(
3151 default,
3152 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3153 )]
3154 pub enable: bool,
3155 #[serde(
3159 default,
3160 skip_serializing_if = "Vec::is_empty",
3161 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3162 )]
3163 pub interpreters: Vec<Interpreters>,
3164}
3165
3166#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3167pub struct CustomKeys {
3168 #[serde(
3172 default,
3173 skip_serializing_if = "String::is_empty",
3174 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3175 )]
3176 pub key: String,
3177 #[serde(
3181 default,
3182 skip_serializing_if = "String::is_empty",
3183 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3184 )]
3185 pub value: String,
3186}
3187
3188#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3190pub struct MeetingSettings {
3191 #[serde(
3195 default,
3196 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3197 )]
3198 pub allow_multiple_devices: bool,
3199 #[serde(
3203 default,
3204 skip_serializing_if = "String::is_empty",
3205 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3206 )]
3207 pub alternative_hosts: String,
3208 #[serde(
3212 default,
3213 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3214 )]
3215 pub alternative_hosts_email_notification: bool,
3216 #[serde(
3220 default,
3221 skip_serializing_if = "crate::utils::zero_i64",
3222 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
3223 )]
3224 pub approval_type: i64,
3225 #[serde(default, skip_serializing_if = "Option::is_none")]
3229 pub approved_or_denied_countries_or_regions: Option<ApprovedDeniedCountriesRegions>,
3230 #[serde(default, skip_serializing_if = "Option::is_none")]
3234 pub audio: Option<Audio>,
3235 #[serde(
3239 default,
3240 skip_serializing_if = "String::is_empty",
3241 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3242 )]
3243 pub authentication_domains: String,
3244 #[serde(
3248 default,
3249 skip_serializing_if = "Vec::is_empty",
3250 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3251 )]
3252 pub authentication_exception: Vec<AuthenticationException>,
3253 #[serde(
3257 default,
3258 skip_serializing_if = "String::is_empty",
3259 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3260 )]
3261 pub authentication_name: String,
3262 #[serde(
3266 default,
3267 skip_serializing_if = "String::is_empty",
3268 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3269 )]
3270 pub authentication_option: String,
3271 #[serde(default, skip_serializing_if = "Option::is_none")]
3275 pub auto_recording: Option<AutoRecording>,
3276 #[serde(default, skip_serializing_if = "Option::is_none")]
3280 pub breakout_room: Option<BreakoutRoom>,
3281 #[serde(
3285 default,
3286 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3287 )]
3288 pub close_registration: bool,
3289 #[serde(
3293 default,
3294 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3295 )]
3296 pub cn_meeting: bool,
3297 #[serde(
3301 default,
3302 skip_serializing_if = "String::is_empty",
3303 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3304 )]
3305 pub contact_email: String,
3306 #[serde(
3310 default,
3311 skip_serializing_if = "String::is_empty",
3312 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3313 )]
3314 pub contact_name: String,
3315 #[serde(
3319 default,
3320 skip_serializing_if = "Vec::is_empty",
3321 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3322 )]
3323 pub custom_keys: Vec<CustomKeys>,
3324 #[serde(default, skip_serializing_if = "Option::is_none")]
3328 pub encryption_type: Option<EncryptionType>,
3329 #[serde(
3333 default,
3334 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3335 )]
3336 pub enforce_login: bool,
3337 #[serde(
3341 default,
3342 skip_serializing_if = "String::is_empty",
3343 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3344 )]
3345 pub enforce_login_domains: String,
3346 #[serde(
3350 default,
3351 skip_serializing_if = "Vec::is_empty",
3352 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3353 )]
3354 pub global_dial_in_countries: Vec<String>,
3355 #[serde(
3359 default,
3360 skip_serializing_if = "Vec::is_empty",
3361 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3362 )]
3363 pub global_dial_in_numbers: Vec<GlobalDialInNumbers>,
3364 #[serde(
3368 default,
3369 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3370 )]
3371 pub host_video: bool,
3372 #[serde(
3376 default,
3377 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3378 )]
3379 pub in_meeting: bool,
3380 #[serde(
3384 default,
3385 skip_serializing_if = "crate::utils::zero_i64",
3386 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
3387 )]
3388 pub jbh_time: i64,
3389 #[serde(
3393 default,
3394 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3395 )]
3396 pub join_before_host: bool,
3397 #[serde(default, skip_serializing_if = "Option::is_none")]
3401 pub language_interpretation: Option<LanguageInterpretation>,
3402 #[serde(
3406 default,
3407 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3408 )]
3409 pub meeting_authentication: bool,
3410 #[serde(
3414 default,
3415 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3416 )]
3417 pub mute_upon_entry: bool,
3418 #[serde(
3422 default,
3423 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3424 )]
3425 pub participant_video: bool,
3426 #[serde(
3430 default,
3431 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3432 )]
3433 pub registrants_confirmation_email: bool,
3434 #[serde(
3438 default,
3439 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3440 )]
3441 pub registrants_email_notification: bool,
3442 #[serde(
3446 default,
3447 skip_serializing_if = "crate::utils::zero_i64",
3448 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
3449 )]
3450 pub registration_type: i64,
3451 #[serde(
3455 default,
3456 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3457 )]
3458 pub show_share_button: bool,
3459 #[serde(
3463 default,
3464 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3465 )]
3466 pub use_pmi: bool,
3467 #[serde(
3471 default,
3472 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3473 )]
3474 pub waiting_room: bool,
3475 #[serde(
3479 default,
3480 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3481 )]
3482 pub watermark: bool,
3483}
3484
3485#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
3491pub enum WeeklyDays {
3492 #[serde(rename = "1")]
3493 #[default]
3494 One,
3495 #[serde(rename = "2")]
3496 Two,
3497 #[serde(rename = "3")]
3498 Three,
3499 #[serde(rename = "4")]
3500 Four,
3501 #[serde(rename = "5")]
3502 Five,
3503 #[serde(rename = "6")]
3504 Six,
3505 #[serde(rename = "7")]
3506 Seven,
3507 #[serde(other)]
3508 FallthroughString,
3509}
3510
3511impl std::fmt::Display for WeeklyDays {
3512 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3513 match self {
3514 WeeklyDays::One => "1",
3515 WeeklyDays::Two => "2",
3516 WeeklyDays::Three => "3",
3517 WeeklyDays::Four => "4",
3518 WeeklyDays::Five => "5",
3519 WeeklyDays::Six => "6",
3520 WeeklyDays::Seven => "7",
3521 WeeklyDays::FallthroughString => "*",
3522 }
3523 .fmt(f)
3524 }
3525}
3526
3527#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3529pub struct Recurrence {
3530 #[serde(
3534 default,
3535 skip_serializing_if = "Option::is_none",
3536 deserialize_with = "crate::utils::date_time_format::deserialize"
3537 )]
3538 pub end_date_time: Option<chrono::DateTime<chrono::Utc>>,
3539 #[serde(
3543 default,
3544 skip_serializing_if = "crate::utils::zero_i64",
3545 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
3546 )]
3547 pub end_times: i64,
3548 #[serde(
3552 default,
3553 skip_serializing_if = "crate::utils::zero_i64",
3554 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
3555 )]
3556 pub monthly_day: i64,
3557 #[serde(
3561 default,
3562 skip_serializing_if = "crate::utils::zero_i64",
3563 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
3564 )]
3565 pub monthly_week: i64,
3566 #[serde(
3570 default,
3571 skip_serializing_if = "crate::utils::zero_i64",
3572 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
3573 )]
3574 pub monthly_week_day: i64,
3575 #[serde(
3579 default,
3580 skip_serializing_if = "crate::utils::zero_i64",
3581 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
3582 )]
3583 pub repeat_interval: i64,
3584 #[serde(
3588 default,
3589 skip_serializing_if = "crate::utils::zero_i64",
3590 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
3591 rename = "type"
3592 )]
3593 pub type_: i64,
3594 #[serde(default, skip_serializing_if = "Option::is_none")]
3598 pub weekly_days: Option<WeeklyDays>,
3599}
3600
3601#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3603pub struct MeetingInfo {
3604 #[serde(
3608 default,
3609 skip_serializing_if = "String::is_empty",
3610 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3611 )]
3612 pub agenda: String,
3613 #[serde(
3617 default,
3618 skip_serializing_if = "Option::is_none",
3619 deserialize_with = "crate::utils::date_time_format::deserialize"
3620 )]
3621 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
3622 #[serde(
3626 default,
3627 skip_serializing_if = "crate::utils::zero_i64",
3628 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
3629 )]
3630 pub duration: i64,
3631 #[serde(
3635 default,
3636 skip_serializing_if = "String::is_empty",
3637 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3638 rename = "h323_password"
3639 )]
3640 pub h_323_password: String,
3641 #[serde(
3645 default,
3646 skip_serializing_if = "String::is_empty",
3647 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3648 )]
3649 pub join_url: String,
3650 #[serde(
3654 default,
3655 skip_serializing_if = "Vec::is_empty",
3656 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3657 )]
3658 pub occurrences: Vec<Occurrence>,
3659 #[serde(
3663 default,
3664 skip_serializing_if = "String::is_empty",
3665 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3666 )]
3667 pub password: String,
3668 #[serde(
3672 default,
3673 skip_serializing_if = "crate::utils::zero_i64",
3674 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
3675 )]
3676 pub pmi: i64,
3677 #[serde(
3681 default,
3682 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3683 )]
3684 pub pre_schedule: bool,
3685 #[serde(default, skip_serializing_if = "Option::is_none")]
3689 pub recurrence: Option<Recurrence>,
3690 #[serde(default, skip_serializing_if = "Option::is_none")]
3694 pub settings: Option<MeetingSettings>,
3695 #[serde(
3699 default,
3700 skip_serializing_if = "Option::is_none",
3701 deserialize_with = "crate::utils::date_time_format::deserialize"
3702 )]
3703 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
3704 #[serde(
3708 default,
3709 skip_serializing_if = "String::is_empty",
3710 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3711 )]
3712 pub start_url: String,
3713 #[serde(
3717 default,
3718 skip_serializing_if = "String::is_empty",
3719 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3720 )]
3721 pub timezone: String,
3722 #[serde(
3726 default,
3727 skip_serializing_if = "String::is_empty",
3728 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3729 )]
3730 pub topic: String,
3731 #[serde(
3735 default,
3736 skip_serializing_if = "Vec::is_empty",
3737 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3738 )]
3739 pub tracking_fields: Vec<TrackingFields>,
3740 #[serde(
3744 default,
3745 skip_serializing_if = "crate::utils::zero_i64",
3746 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
3747 rename = "type"
3748 )]
3749 pub type_: i64,
3750}
3751
3752#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
3756pub enum Status {
3757 #[serde(rename = "started")]
3758 Started,
3759 #[serde(rename = "waiting")]
3760 Waiting,
3761 #[serde(rename = "")]
3762 #[default]
3763 Noop,
3764 #[serde(other)]
3765 FallthroughString,
3766}
3767
3768impl std::fmt::Display for Status {
3769 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3770 match self {
3771 Status::Started => "started",
3772 Status::Waiting => "waiting",
3773 Status::Noop => "",
3774 Status::FallthroughString => "*",
3775 }
3776 .fmt(f)
3777 }
3778}
3779
3780impl Status {
3781 pub fn is_noop(&self) -> bool {
3782 matches!(self, Status::Noop)
3783 }
3784}
3785
3786#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3788pub struct MeetingInfoGet {
3789 #[serde(
3793 default,
3794 skip_serializing_if = "String::is_empty",
3795 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3796 )]
3797 pub agenda: String,
3798 #[serde(
3802 default,
3803 skip_serializing_if = "Option::is_none",
3804 deserialize_with = "crate::utils::date_time_format::deserialize"
3805 )]
3806 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
3807 #[serde(
3811 default,
3812 skip_serializing_if = "crate::utils::zero_i64",
3813 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
3814 )]
3815 pub duration: i64,
3816 #[serde(
3820 default,
3821 skip_serializing_if = "String::is_empty",
3822 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3823 )]
3824 pub encrypted_password: String,
3825 #[serde(
3829 default,
3830 skip_serializing_if = "String::is_empty",
3831 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
3832 rename = "h323_password"
3833 )]
3834 pub h_323_password: String,
3835 #[serde(
3839 default,
3840 skip_serializing_if = "String::is_empty",
3841 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3842 )]
3843 pub join_url: String,
3844 #[serde(
3848 default,
3849 skip_serializing_if = "Vec::is_empty",
3850 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3851 )]
3852 pub occurrences: Vec<Occurrence>,
3853 #[serde(
3857 default,
3858 skip_serializing_if = "String::is_empty",
3859 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3860 )]
3861 pub password: String,
3862 #[serde(
3866 default,
3867 skip_serializing_if = "crate::utils::zero_i64",
3868 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
3869 )]
3870 pub pmi: i64,
3871 #[serde(
3875 default,
3876 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
3877 )]
3878 pub pre_schedule: bool,
3879 #[serde(default, skip_serializing_if = "Option::is_none")]
3883 pub recurrence: Option<Recurrence>,
3884 #[serde(default, skip_serializing_if = "Option::is_none")]
3888 pub settings: Option<MeetingSettings>,
3889 #[serde(
3893 default,
3894 skip_serializing_if = "Option::is_none",
3895 deserialize_with = "crate::utils::date_time_format::deserialize"
3896 )]
3897 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
3898 #[serde(
3902 default,
3903 skip_serializing_if = "String::is_empty",
3904 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3905 )]
3906 pub start_url: String,
3907 #[serde(default, skip_serializing_if = "Option::is_none")]
3911 pub status: Option<Status>,
3912 #[serde(
3916 default,
3917 skip_serializing_if = "String::is_empty",
3918 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3919 )]
3920 pub timezone: String,
3921 #[serde(
3925 default,
3926 skip_serializing_if = "String::is_empty",
3927 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3928 )]
3929 pub topic: String,
3930 #[serde(
3934 default,
3935 skip_serializing_if = "Vec::is_empty",
3936 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3937 )]
3938 pub tracking_fields: Vec<TrackingFields>,
3939 #[serde(
3943 default,
3944 skip_serializing_if = "crate::utils::zero_i64",
3945 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
3946 rename = "type"
3947 )]
3948 pub type_: i64,
3949}
3950
3951#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
3953pub struct MeetingMetric {
3954 #[serde(
3958 default,
3959 skip_serializing_if = "Vec::is_empty",
3960 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
3961 )]
3962 pub custom_keys: Vec<CustomKeys>,
3963 #[serde(
3967 default,
3968 skip_serializing_if = "String::is_empty",
3969 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3970 )]
3971 pub dept: String,
3972 #[serde(
3976 default,
3977 skip_serializing_if = "String::is_empty",
3978 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3979 )]
3980 pub duration: String,
3981 #[serde(
3985 default,
3986 skip_serializing_if = "String::is_empty",
3987 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
3988 )]
3989 pub email: String,
3990 #[serde(
3994 default,
3995 skip_serializing_if = "Option::is_none",
3996 deserialize_with = "crate::utils::date_time_format::deserialize"
3997 )]
3998 pub end_time: Option<chrono::DateTime<chrono::Utc>>,
3999 #[serde(
4003 default,
4004 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4005 )]
4006 pub has_3rd_party_audio: bool,
4007 #[serde(
4011 default,
4012 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4013 )]
4014 pub has_pstn: bool,
4015 #[serde(
4019 default,
4020 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4021 )]
4022 pub has_recording: bool,
4023 #[serde(
4027 default,
4028 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4029 )]
4030 pub has_screen_share: bool,
4031 #[serde(
4035 default,
4036 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4037 )]
4038 pub has_sip: bool,
4039 #[serde(
4043 default,
4044 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4045 )]
4046 pub has_video: bool,
4047 #[serde(
4051 default,
4052 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4053 )]
4054 pub has_voip: bool,
4055 #[serde(
4059 default,
4060 skip_serializing_if = "String::is_empty",
4061 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4062 )]
4063 pub host: String,
4064 #[serde(
4068 default,
4069 skip_serializing_if = "crate::utils::zero_i64",
4070 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
4071 )]
4072 pub id: i64,
4073 #[serde(
4077 default,
4078 skip_serializing_if = "crate::utils::zero_i64",
4079 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
4080 )]
4081 pub in_room_participants: i64,
4082 #[serde(
4086 default,
4087 skip_serializing_if = "crate::utils::zero_i64",
4088 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
4089 )]
4090 pub participants: i64,
4091 #[serde(
4095 default,
4096 skip_serializing_if = "Option::is_none",
4097 deserialize_with = "crate::utils::date_time_format::deserialize"
4098 )]
4099 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
4100 #[serde(
4104 default,
4105 skip_serializing_if = "String::is_empty",
4106 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4107 )]
4108 pub topic: String,
4109 #[serde(
4113 default,
4114 skip_serializing_if = "String::is_empty",
4115 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4116 )]
4117 pub user_type: String,
4118 #[serde(
4122 default,
4123 skip_serializing_if = "String::is_empty",
4124 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4125 )]
4126 pub uuid: String,
4127}
4128
4129#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4131pub struct MeetingInvitation {
4132 #[serde(
4136 default,
4137 skip_serializing_if = "String::is_empty",
4138 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4139 )]
4140 pub invitation: String,
4141}
4142
4143#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4145pub struct MeetingLiveStream {
4146 #[serde(
4150 default,
4151 skip_serializing_if = "String::is_empty",
4152 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4153 )]
4154 pub page_url: String,
4155 #[serde(
4159 default,
4160 skip_serializing_if = "String::is_empty",
4161 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4162 )]
4163 pub stream_key: String,
4164 #[serde(
4168 default,
4169 skip_serializing_if = "String::is_empty",
4170 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4171 )]
4172 pub stream_url: String,
4173}
4174
4175#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
4183pub enum Action {
4184 #[serde(rename = "start")]
4185 Start,
4186 #[serde(rename = "stop")]
4187 Stop,
4188 #[serde(rename = "")]
4189 #[default]
4190 Noop,
4191 #[serde(other)]
4192 FallthroughString,
4193}
4194
4195impl std::fmt::Display for Action {
4196 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4197 match self {
4198 Action::Start => "start",
4199 Action::Stop => "stop",
4200 Action::Noop => "",
4201 Action::FallthroughString => "*",
4202 }
4203 .fmt(f)
4204 }
4205}
4206
4207impl Action {
4208 pub fn is_noop(&self) -> bool {
4209 matches!(self, Action::Noop)
4210 }
4211}
4212
4213#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4215pub struct MeetingLiveStreamStatusSettings {
4216 #[serde(
4220 default,
4221 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4222 )]
4223 pub active_speaker_name: bool,
4224 #[serde(
4228 default,
4229 skip_serializing_if = "String::is_empty",
4230 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4231 )]
4232 pub display_name: String,
4233}
4234
4235#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4237pub struct MeetingLiveStreamStatus {
4238 #[serde(default, skip_serializing_if = "Option::is_none")]
4242 pub action: Option<Action>,
4243 #[serde(default, skip_serializing_if = "Option::is_none")]
4247 pub settings: Option<MeetingLiveStreamStatusSettings>,
4248}
4249
4250#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4252pub struct WebinarLiveStreamStatusSettings {
4253 #[serde(
4257 default,
4258 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4259 )]
4260 pub active_speaker_name: bool,
4261 #[serde(
4265 default,
4266 skip_serializing_if = "String::is_empty",
4267 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4268 )]
4269 pub display_name: String,
4270}
4271
4272#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4274pub struct WebinarLiveStreamStatus {
4275 #[serde(default, skip_serializing_if = "Option::is_none")]
4279 pub action: Option<Action>,
4280 #[serde(default, skip_serializing_if = "Option::is_none")]
4284 pub settings: Option<WebinarLiveStreamStatusSettings>,
4285}
4286
4287#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4289pub struct Pagination {
4290 #[serde(
4294 default,
4295 skip_serializing_if = "String::is_empty",
4296 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4297 )]
4298 pub next_page_token: String,
4299 #[serde(
4303 default,
4304 skip_serializing_if = "crate::utils::zero_i64",
4305 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
4306 )]
4307 pub page_count: i64,
4308 #[serde(
4312 default,
4313 skip_serializing_if = "crate::utils::zero_i64",
4314 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
4315 )]
4316 pub page_number: i64,
4317 #[serde(
4321 default,
4322 skip_serializing_if = "crate::utils::zero_i64",
4323 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
4324 )]
4325 pub page_size: i64,
4326 #[serde(
4330 default,
4331 skip_serializing_if = "crate::utils::zero_i64",
4332 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
4333 )]
4334 pub total_records: i64,
4335}
4336
4337#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4339pub struct PaginationToken {
4340 #[serde(
4344 default,
4345 skip_serializing_if = "String::is_empty",
4346 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4347 )]
4348 pub next_page_token: String,
4349 #[serde(
4353 default,
4354 skip_serializing_if = "crate::utils::zero_i64",
4355 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
4356 )]
4357 pub page_count: i64,
4358 #[serde(
4362 default,
4363 skip_serializing_if = "crate::utils::zero_i64",
4364 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
4365 )]
4366 pub page_size: i64,
4367 #[serde(
4371 default,
4372 skip_serializing_if = "crate::utils::zero_i64",
4373 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
4374 )]
4375 pub total_records: i64,
4376}
4377
4378#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4380pub struct PaginationToken4ImChat {
4381 #[serde(
4385 default,
4386 skip_serializing_if = "String::is_empty",
4387 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4388 )]
4389 pub next_page_token: String,
4390 #[serde(
4394 default,
4395 skip_serializing_if = "crate::utils::zero_i64",
4396 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
4397 )]
4398 pub page_size: i64,
4399}
4400
4401#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4403pub struct Panelist {
4404 #[serde(
4408 default,
4409 skip_serializing_if = "String::is_empty",
4410 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4411 )]
4412 pub email: String,
4413 #[serde(
4417 default,
4418 skip_serializing_if = "String::is_empty",
4419 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4420 )]
4421 pub name: String,
4422}
4423
4424#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4425pub struct Panelists {
4426 #[serde(
4430 default,
4431 skip_serializing_if = "String::is_empty",
4432 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4433 )]
4434 pub join_url: String,
4435}
4436
4437#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4444pub struct PanelistsAllOf {
4445 #[serde(flatten)]
4446 pub groups: Groups,
4447 #[serde(flatten)]
4451 pub panelist: Panelist,
4452 #[serde(flatten)]
4453 pub panelists: Panelists,
4454}
4455
4456#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4458pub struct PanelistList {
4459 #[serde(
4463 default,
4464 skip_serializing_if = "Vec::is_empty",
4465 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
4466 )]
4467 pub panelists: Vec<PanelistsAllOf>,
4468 #[serde(
4472 default,
4473 skip_serializing_if = "crate::utils::zero_i64",
4474 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
4475 )]
4476 pub total_records: i64,
4477}
4478
4479#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4481pub struct QosAudio {
4482 #[serde(
4486 default,
4487 skip_serializing_if = "String::is_empty",
4488 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4489 )]
4490 pub avg_loss: String,
4491 #[serde(
4495 default,
4496 skip_serializing_if = "String::is_empty",
4497 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4498 )]
4499 pub bitrate: String,
4500 #[serde(
4504 default,
4505 skip_serializing_if = "String::is_empty",
4506 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4507 )]
4508 pub jitter: String,
4509 #[serde(
4513 default,
4514 skip_serializing_if = "String::is_empty",
4515 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4516 )]
4517 pub latency: String,
4518 #[serde(
4522 default,
4523 skip_serializing_if = "String::is_empty",
4524 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4525 )]
4526 pub max_loss: String,
4527}
4528
4529#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
4533pub enum RecordingStatus {
4534 #[serde(rename = "completed")]
4535 Completed,
4536 #[serde(rename = "")]
4537 #[default]
4538 Noop,
4539 #[serde(other)]
4540 FallthroughString,
4541}
4542
4543impl std::fmt::Display for RecordingStatus {
4544 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4545 match self {
4546 RecordingStatus::Completed => "completed",
4547 RecordingStatus::Noop => "",
4548 RecordingStatus::FallthroughString => "*",
4549 }
4550 .fmt(f)
4551 }
4552}
4553
4554impl RecordingStatus {
4555 pub fn is_noop(&self) -> bool {
4556 matches!(self, RecordingStatus::Noop)
4557 }
4558}
4559
4560#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4562pub struct RecordingData {
4563 #[serde(
4567 default,
4568 skip_serializing_if = "String::is_empty",
4569 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4570 )]
4571 pub deleted_time: String,
4572 #[serde(
4576 default,
4577 skip_serializing_if = "String::is_empty",
4578 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4579 )]
4580 pub download_url: String,
4581 #[serde(
4585 default,
4586 skip_serializing_if = "crate::utils::zero_f64",
4587 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
4588 )]
4589 pub file_size: f64,
4590 #[serde(
4594 default,
4595 skip_serializing_if = "String::is_empty",
4596 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4597 )]
4598 pub file_type: String,
4599 #[serde(
4603 default,
4604 skip_serializing_if = "String::is_empty",
4605 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4606 )]
4607 pub id: String,
4608 #[serde(
4612 default,
4613 skip_serializing_if = "String::is_empty",
4614 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4615 )]
4616 pub meeting_id: String,
4617 #[serde(
4621 default,
4622 skip_serializing_if = "String::is_empty",
4623 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4624 )]
4625 pub play_url: String,
4626 #[serde(
4630 default,
4631 skip_serializing_if = "String::is_empty",
4632 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4633 )]
4634 pub recording_end: String,
4635 #[serde(
4639 default,
4640 skip_serializing_if = "String::is_empty",
4641 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4642 )]
4643 pub recording_start: String,
4644 #[serde(
4648 default,
4649 skip_serializing_if = "String::is_empty",
4650 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4651 )]
4652 pub recording_type: String,
4653 #[serde(default, skip_serializing_if = "Option::is_none")]
4657 pub status: Option<RecordingStatus>,
4658}
4659
4660#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4662pub struct RecordingSeparateAudio {
4663 #[serde(
4667 default,
4668 skip_serializing_if = "String::is_empty",
4669 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4670 )]
4671 pub download_url: String,
4672 #[serde(
4676 default,
4677 skip_serializing_if = "String::is_empty",
4678 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4679 )]
4680 pub file_name: String,
4681 #[serde(
4685 default,
4686 skip_serializing_if = "crate::utils::zero_f64",
4687 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
4688 )]
4689 pub file_size: f64,
4690 #[serde(
4694 default,
4695 skip_serializing_if = "String::is_empty",
4696 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4697 )]
4698 pub file_type: String,
4699 #[serde(
4703 default,
4704 skip_serializing_if = "String::is_empty",
4705 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4706 )]
4707 pub id: String,
4708 #[serde(
4712 default,
4713 skip_serializing_if = "String::is_empty",
4714 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4715 )]
4716 pub play_url: String,
4717 #[serde(
4721 default,
4722 skip_serializing_if = "Option::is_none",
4723 deserialize_with = "crate::utils::date_time_format::deserialize"
4724 )]
4725 pub recording_end: Option<chrono::DateTime<chrono::Utc>>,
4726 #[serde(
4730 default,
4731 skip_serializing_if = "Option::is_none",
4732 deserialize_with = "crate::utils::date_time_format::deserialize"
4733 )]
4734 pub recording_start: Option<chrono::DateTime<chrono::Utc>>,
4735 #[serde(default, skip_serializing_if = "Option::is_none")]
4739 pub status: Option<RecordingStatus>,
4740}
4741
4742#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
4746pub enum ShareRecording {
4747 #[serde(rename = "internally")]
4748 Internally,
4749 #[serde(rename = "none")]
4750 None,
4751 #[serde(rename = "publicly")]
4752 Publicly,
4753 #[serde(rename = "")]
4754 #[default]
4755 Noop,
4756 #[serde(other)]
4757 FallthroughString,
4758}
4759
4760impl std::fmt::Display for ShareRecording {
4761 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4762 match self {
4763 ShareRecording::Internally => "internally",
4764 ShareRecording::None => "none",
4765 ShareRecording::Publicly => "publicly",
4766 ShareRecording::Noop => "",
4767 ShareRecording::FallthroughString => "*",
4768 }
4769 .fmt(f)
4770 }
4771}
4772
4773impl ShareRecording {
4774 pub fn is_noop(&self) -> bool {
4775 matches!(self, ShareRecording::Noop)
4776 }
4777}
4778
4779#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4780pub struct RecordingSettings {
4781 #[serde(
4782 default,
4783 skip_serializing_if = "crate::utils::zero_i64",
4784 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
4785 )]
4786 pub approval_type: i64,
4787 #[serde(
4788 default,
4789 skip_serializing_if = "String::is_empty",
4790 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4791 )]
4792 pub authentication_domains: String,
4793 #[serde(
4794 default,
4795 skip_serializing_if = "String::is_empty",
4796 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4797 )]
4798 pub authentication_option: String,
4799 #[serde(
4800 default,
4801 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4802 )]
4803 pub on_demand: bool,
4804 #[serde(
4805 default,
4806 skip_serializing_if = "String::is_empty",
4807 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4808 )]
4809 pub password: String,
4810 #[serde(
4811 default,
4812 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4813 )]
4814 pub recording_authentication: bool,
4815 #[serde(
4816 default,
4817 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4818 )]
4819 pub send_email_to_host: bool,
4820 #[serde(default, skip_serializing_if = "Option::is_none")]
4821 pub share_recording: Option<ShareRecording>,
4822 #[serde(
4823 default,
4824 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4825 )]
4826 pub show_social_share_buttons: bool,
4827 #[serde(
4828 default,
4829 skip_serializing_if = "String::is_empty",
4830 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4831 )]
4832 pub topic: String,
4833 #[serde(
4834 default,
4835 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
4836 )]
4837 pub viewer_download: bool,
4838}
4839
4840#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4842pub struct RecordingRegistrantStatus {
4843 #[serde(default, skip_serializing_if = "Method::is_noop")]
4849 pub action: Method,
4850 #[serde(
4854 default,
4855 skip_serializing_if = "Vec::is_empty",
4856 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
4857 )]
4858 pub registrants: Vec<String>,
4859}
4860
4861#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
4863pub struct Registrant {
4864 #[serde(
4868 default,
4869 skip_serializing_if = "String::is_empty",
4870 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4871 )]
4872 pub address: String,
4873 #[serde(
4877 default,
4878 skip_serializing_if = "String::is_empty",
4879 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4880 )]
4881 pub city: String,
4882 #[serde(
4886 default,
4887 skip_serializing_if = "String::is_empty",
4888 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4889 )]
4890 pub comments: String,
4891 #[serde(
4895 default,
4896 skip_serializing_if = "String::is_empty",
4897 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4898 )]
4899 pub country: String,
4900 #[serde(
4904 default,
4905 skip_serializing_if = "Vec::is_empty",
4906 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
4907 )]
4908 pub custom_questions: Vec<CustomQuestion>,
4909 #[serde(
4913 default,
4914 skip_serializing_if = "String::is_empty",
4915 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4916 )]
4917 pub email: String,
4918 #[serde(
4922 default,
4923 skip_serializing_if = "String::is_empty",
4924 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4925 )]
4926 pub first_name: String,
4927 #[serde(
4931 default,
4932 skip_serializing_if = "String::is_empty",
4933 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4934 )]
4935 pub industry: String,
4936 #[serde(
4940 default,
4941 skip_serializing_if = "String::is_empty",
4942 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4943 )]
4944 pub job_title: String,
4945 #[serde(
4949 default,
4950 skip_serializing_if = "String::is_empty",
4951 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4952 )]
4953 pub last_name: String,
4954 #[serde(
4958 default,
4959 skip_serializing_if = "String::is_empty",
4960 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4961 )]
4962 pub no_of_employees: String,
4963 #[serde(
4967 default,
4968 skip_serializing_if = "String::is_empty",
4969 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4970 )]
4971 pub org: String,
4972 #[serde(
4976 default,
4977 skip_serializing_if = "String::is_empty",
4978 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4979 )]
4980 pub phone: String,
4981 #[serde(
4985 default,
4986 skip_serializing_if = "String::is_empty",
4987 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4988 )]
4989 pub purchasing_time_frame: String,
4990 #[serde(
4994 default,
4995 skip_serializing_if = "String::is_empty",
4996 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
4997 )]
4998 pub role_in_purchase_process: String,
4999 #[serde(
5003 default,
5004 skip_serializing_if = "String::is_empty",
5005 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5006 )]
5007 pub state: String,
5008 #[serde(
5012 default,
5013 skip_serializing_if = "String::is_empty",
5014 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5015 )]
5016 pub zip: String,
5017}
5018
5019#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
5023pub enum RegistrantStatusAction {
5024 #[serde(rename = "approve")]
5025 Approve,
5026 #[serde(rename = "cancel")]
5027 Cancel,
5028 #[serde(rename = "deny")]
5029 Deny,
5030 #[serde(rename = "")]
5031 #[default]
5032 Noop,
5033 #[serde(other)]
5034 FallthroughString,
5035}
5036
5037impl std::fmt::Display for RegistrantStatusAction {
5038 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5039 match self {
5040 RegistrantStatusAction::Approve => "approve",
5041 RegistrantStatusAction::Cancel => "cancel",
5042 RegistrantStatusAction::Deny => "deny",
5043 RegistrantStatusAction::Noop => "",
5044 RegistrantStatusAction::FallthroughString => "*",
5045 }
5046 .fmt(f)
5047 }
5048}
5049
5050impl RegistrantStatusAction {
5051 pub fn is_noop(&self) -> bool {
5052 matches!(self, RegistrantStatusAction::Noop)
5053 }
5054}
5055
5056#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5057pub struct Assistants {
5058 #[serde(
5062 default,
5063 skip_serializing_if = "String::is_empty",
5064 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5065 )]
5066 pub email: String,
5067 #[serde(
5071 default,
5072 skip_serializing_if = "String::is_empty",
5073 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5074 )]
5075 pub id: String,
5076}
5077
5078#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5079pub struct RegistrantStatus {
5080 #[serde(default, skip_serializing_if = "RegistrantStatusAction::is_noop")]
5084 pub action: RegistrantStatusAction,
5085 #[serde(
5089 default,
5090 skip_serializing_if = "Vec::is_empty",
5091 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
5092 )]
5093 pub registrants: Vec<Assistants>,
5094}
5095
5096#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5098pub struct RoleMembersList {
5099 #[serde(
5103 default,
5104 skip_serializing_if = "Vec::is_empty",
5105 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
5106 )]
5107 pub members: Vec<Domains>,
5108 #[serde(
5112 default,
5113 skip_serializing_if = "String::is_empty",
5114 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5115 )]
5116 pub next_page_token: String,
5117 #[serde(
5121 default,
5122 skip_serializing_if = "crate::utils::zero_i64",
5123 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
5124 )]
5125 pub page_count: i64,
5126 #[serde(
5130 default,
5131 skip_serializing_if = "crate::utils::zero_i64",
5132 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
5133 )]
5134 pub page_number: i64,
5135 #[serde(
5139 default,
5140 skip_serializing_if = "crate::utils::zero_i64",
5141 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
5142 )]
5143 pub page_size: i64,
5144 #[serde(
5148 default,
5149 skip_serializing_if = "crate::utils::zero_i64",
5150 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
5151 )]
5152 pub total_records: i64,
5153}
5154
5155#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5157pub struct AddRoleMembers {
5158 #[serde(
5162 default,
5163 skip_serializing_if = "Vec::is_empty",
5164 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
5165 )]
5166 pub members: Vec<String>,
5167}
5168
5169#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5171pub struct Session {
5172 #[serde(
5176 default,
5177 skip_serializing_if = "String::is_empty",
5178 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5179 )]
5180 pub agenda: String,
5181 #[serde(
5185 default,
5186 skip_serializing_if = "crate::utils::zero_i64",
5187 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
5188 )]
5189 pub duration: i64,
5190 #[serde(
5194 default,
5195 skip_serializing_if = "String::is_empty",
5196 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5197 )]
5198 pub password: String,
5199 #[serde(default, skip_serializing_if = "Option::is_none")]
5203 pub recurrence: Option<Recurrence>,
5204 #[serde(default, skip_serializing_if = "Option::is_none")]
5208 pub settings: Option<MeetingSettings>,
5209 #[serde(
5213 default,
5214 skip_serializing_if = "Option::is_none",
5215 deserialize_with = "crate::utils::date_time_format::deserialize"
5216 )]
5217 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
5218 #[serde(
5222 default,
5223 skip_serializing_if = "String::is_empty",
5224 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5225 )]
5226 pub timezone: String,
5227 #[serde(
5231 default,
5232 skip_serializing_if = "String::is_empty",
5233 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5234 )]
5235 pub topic: String,
5236 #[serde(
5240 default,
5241 skip_serializing_if = "Vec::is_empty",
5242 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
5243 )]
5244 pub tracking_fields: Vec<String>,
5245 #[serde(
5249 default,
5250 skip_serializing_if = "crate::utils::zero_i64",
5251 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
5252 rename = "type"
5253 )]
5254 pub type_: i64,
5255}
5256
5257#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5258pub struct SessionUpdateTrackingFields {
5259 #[serde(
5263 default,
5264 skip_serializing_if = "String::is_empty",
5265 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5266 )]
5267 pub field: String,
5268 #[serde(
5272 default,
5273 skip_serializing_if = "String::is_empty",
5274 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5275 )]
5276 pub value: String,
5277}
5278
5279#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5280pub struct SettingsData {
5281 #[serde(
5285 default,
5286 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5287 )]
5288 pub registrants_confirmation_email: bool,
5289}
5290
5291#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5297pub struct SettingsAllOf {
5298 #[serde(flatten)]
5302 pub meeting_settings: MeetingSettings,
5303 #[serde(flatten)]
5304 pub settings_data: SettingsData,
5305}
5306
5307#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5309pub struct SessionUpdate {
5310 #[serde(
5314 default,
5315 skip_serializing_if = "String::is_empty",
5316 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5317 )]
5318 pub agenda: String,
5319 #[serde(
5323 default,
5324 skip_serializing_if = "crate::utils::zero_i64",
5325 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
5326 )]
5327 pub duration: i64,
5328 #[serde(
5332 default,
5333 skip_serializing_if = "String::is_empty",
5334 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5335 )]
5336 pub password: String,
5337 #[serde(
5341 default,
5342 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5343 )]
5344 pub pre_schedule: bool,
5345 #[serde(default, skip_serializing_if = "Option::is_none")]
5349 pub recurrence: Option<Recurrence>,
5350 #[serde(default, skip_serializing_if = "Option::is_none")]
5354 pub settings: Option<SettingsAllOf>,
5355 #[serde(
5359 default,
5360 skip_serializing_if = "Option::is_none",
5361 deserialize_with = "crate::utils::date_time_format::deserialize"
5362 )]
5363 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
5364 #[serde(
5368 default,
5369 skip_serializing_if = "String::is_empty",
5370 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5371 )]
5372 pub template_id: String,
5373 #[serde(
5377 default,
5378 skip_serializing_if = "String::is_empty",
5379 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5380 )]
5381 pub timezone: String,
5382 #[serde(
5386 default,
5387 skip_serializing_if = "String::is_empty",
5388 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5389 )]
5390 pub topic: String,
5391 #[serde(
5395 default,
5396 skip_serializing_if = "Vec::is_empty",
5397 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
5398 )]
5399 pub tracking_fields: Vec<SessionUpdateTrackingFields>,
5400 #[serde(
5404 default,
5405 skip_serializing_if = "crate::utils::zero_i64",
5406 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
5407 rename = "type"
5408 )]
5409 pub type_: i64,
5410}
5411
5412#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5414pub struct RecurrenceWebinar {
5415 #[serde(
5419 default,
5420 skip_serializing_if = "Option::is_none",
5421 deserialize_with = "crate::utils::date_time_format::deserialize"
5422 )]
5423 pub end_date_time: Option<chrono::DateTime<chrono::Utc>>,
5424 #[serde(
5428 default,
5429 skip_serializing_if = "crate::utils::zero_i64",
5430 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
5431 )]
5432 pub end_times: i64,
5433 #[serde(
5437 default,
5438 skip_serializing_if = "crate::utils::zero_i64",
5439 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
5440 )]
5441 pub monthly_day: i64,
5442 #[serde(
5446 default,
5447 skip_serializing_if = "crate::utils::zero_i64",
5448 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
5449 )]
5450 pub monthly_week: i64,
5451 #[serde(
5455 default,
5456 skip_serializing_if = "crate::utils::zero_i64",
5457 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
5458 )]
5459 pub monthly_week_day: i64,
5460 #[serde(
5464 default,
5465 skip_serializing_if = "crate::utils::zero_i64",
5466 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
5467 )]
5468 pub repeat_interval: i64,
5469 #[serde(
5473 default,
5474 skip_serializing_if = "crate::utils::zero_i64",
5475 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
5476 rename = "type"
5477 )]
5478 pub type_: i64,
5479 #[serde(
5483 default,
5484 skip_serializing_if = "String::is_empty",
5485 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5486 )]
5487 pub weekly_days: String,
5488}
5489
5490#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
5498pub enum AnswerQuestions {
5499 #[serde(rename = "all")]
5500 All,
5501 #[serde(rename = "only")]
5502 Only,
5503 #[serde(rename = "")]
5504 #[default]
5505 Noop,
5506 #[serde(other)]
5507 FallthroughString,
5508}
5509
5510impl std::fmt::Display for AnswerQuestions {
5511 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5512 match self {
5513 AnswerQuestions::All => "all",
5514 AnswerQuestions::Only => "only",
5515 AnswerQuestions::Noop => "",
5516 AnswerQuestions::FallthroughString => "*",
5517 }
5518 .fmt(f)
5519 }
5520}
5521
5522impl AnswerQuestions {
5523 pub fn is_noop(&self) -> bool {
5524 matches!(self, AnswerQuestions::Noop)
5525 }
5526}
5527
5528#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5530pub struct QuestionAnswer {
5531 #[serde(
5535 default,
5536 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5537 )]
5538 pub allow_anonymous_questions: bool,
5539 #[serde(default, skip_serializing_if = "Option::is_none")]
5543 pub answer_questions: Option<AnswerQuestions>,
5544 #[serde(
5548 default,
5549 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5550 )]
5551 pub attendees_can_comment: bool,
5552 #[serde(
5556 default,
5557 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5558 )]
5559 pub attendees_can_upvote: bool,
5560 #[serde(
5564 default,
5565 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5566 )]
5567 pub enable: bool,
5568}
5569
5570#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5572pub struct AttendeesPanelistsReminderEmailNotification {
5573 #[serde(
5577 default,
5578 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5579 )]
5580 pub enable: bool,
5581 #[serde(
5585 default,
5586 skip_serializing_if = "crate::utils::zero_i64",
5587 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
5588 rename = "type"
5589 )]
5590 pub type_: i64,
5591}
5592
5593#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5595pub struct FollowUpAttendeesEmailNotification {
5596 #[serde(
5600 default,
5601 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5602 )]
5603 pub enable: bool,
5604 #[serde(
5608 default,
5609 skip_serializing_if = "crate::utils::zero_i64",
5610 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
5611 rename = "type"
5612 )]
5613 pub type_: i64,
5614}
5615
5616#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5618pub struct FollowUpAbsenteesEmailNotification {
5619 #[serde(
5623 default,
5624 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5625 )]
5626 pub enable: bool,
5627 #[serde(
5631 default,
5632 skip_serializing_if = "crate::utils::zero_i64",
5633 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
5634 rename = "type"
5635 )]
5636 pub type_: i64,
5637}
5638
5639#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5641pub struct WebinarSettings {
5642 #[serde(
5646 default,
5647 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5648 )]
5649 pub allow_multiple_devices: bool,
5650 #[serde(
5654 default,
5655 skip_serializing_if = "String::is_empty",
5656 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5657 )]
5658 pub alternative_hosts: String,
5659 #[serde(
5663 default,
5664 skip_serializing_if = "crate::utils::zero_i64",
5665 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
5666 )]
5667 pub approval_type: i64,
5668 #[serde(default, skip_serializing_if = "Option::is_none")]
5672 pub attendees_and_panelists_reminder_email_notification:
5673 Option<AttendeesPanelistsReminderEmailNotification>,
5674 #[serde(default, skip_serializing_if = "Option::is_none")]
5678 pub audio: Option<Audio>,
5679 #[serde(
5683 default,
5684 skip_serializing_if = "String::is_empty",
5685 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5686 )]
5687 pub authentication_domains: String,
5688 #[serde(
5692 default,
5693 skip_serializing_if = "String::is_empty",
5694 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5695 )]
5696 pub authentication_name: String,
5697 #[serde(
5701 default,
5702 skip_serializing_if = "String::is_empty",
5703 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5704 )]
5705 pub authentication_option: String,
5706 #[serde(default, skip_serializing_if = "Option::is_none")]
5710 pub auto_recording: Option<AutoRecording>,
5711 #[serde(
5715 default,
5716 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5717 )]
5718 pub close_registration: bool,
5719 #[serde(
5723 default,
5724 skip_serializing_if = "String::is_empty",
5725 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5726 )]
5727 pub contact_email: String,
5728 #[serde(
5732 default,
5733 skip_serializing_if = "String::is_empty",
5734 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5735 )]
5736 pub contact_name: String,
5737 #[serde(
5741 default,
5742 skip_serializing_if = "String::is_empty",
5743 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5744 )]
5745 pub email_language: String,
5746 #[serde(
5750 default,
5751 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5752 )]
5753 pub enforce_login: bool,
5754 #[serde(
5758 default,
5759 skip_serializing_if = "String::is_empty",
5760 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5761 )]
5762 pub enforce_login_domains: String,
5763 #[serde(default, skip_serializing_if = "Option::is_none")]
5767 pub follow_up_absentees_email_notification: Option<FollowUpAbsenteesEmailNotification>,
5768 #[serde(default, skip_serializing_if = "Option::is_none")]
5772 pub follow_up_attendees_email_notification: Option<FollowUpAttendeesEmailNotification>,
5773 #[serde(
5777 default,
5778 skip_serializing_if = "Vec::is_empty",
5779 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
5780 )]
5781 pub global_dial_in_countries: Vec<String>,
5782 #[serde(
5786 default,
5787 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5788 )]
5789 pub hd_video: bool,
5790 #[serde(
5794 default,
5795 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5796 )]
5797 pub host_video: bool,
5798 #[serde(
5802 default,
5803 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5804 )]
5805 pub meeting_authentication: bool,
5806 #[serde(
5810 default,
5811 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5812 )]
5813 pub notify_registrants: bool,
5814 #[serde(
5818 default,
5819 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5820 )]
5821 pub on_demand: bool,
5822 #[serde(
5826 default,
5827 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5828 )]
5829 pub panelists_invitation_email_notification: bool,
5830 #[serde(
5834 default,
5835 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5836 )]
5837 pub panelists_video: bool,
5838 #[serde(
5842 default,
5843 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5844 )]
5845 pub post_webinar_survey: bool,
5846 #[serde(
5850 default,
5851 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5852 )]
5853 pub practice_session: bool,
5854 #[serde(default, skip_serializing_if = "Option::is_none")]
5858 pub question_and_answer: Option<QuestionAnswer>,
5859 #[serde(
5863 default,
5864 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5865 )]
5866 pub registrants_confirmation_email: bool,
5867 #[serde(
5871 default,
5872 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5873 )]
5874 pub registrants_email_notification: bool,
5875 #[serde(
5879 default,
5880 skip_serializing_if = "crate::utils::zero_i64",
5881 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
5882 )]
5883 pub registrants_restrict_number: i64,
5884 #[serde(
5888 default,
5889 skip_serializing_if = "crate::utils::zero_i64",
5890 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
5891 )]
5892 pub registration_type: i64,
5893 #[serde(
5897 default,
5898 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
5899 )]
5900 pub show_share_button: bool,
5901 #[serde(
5905 default,
5906 skip_serializing_if = "String::is_empty",
5907 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5908 )]
5909 pub survey_url: String,
5910}
5911
5912#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
5914pub struct SessionWebinar {
5915 #[serde(
5919 default,
5920 skip_serializing_if = "String::is_empty",
5921 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5922 )]
5923 pub agenda: String,
5924 #[serde(
5928 default,
5929 skip_serializing_if = "crate::utils::zero_i64",
5930 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
5931 )]
5932 pub duration: i64,
5933 #[serde(
5937 default,
5938 skip_serializing_if = "String::is_empty",
5939 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5940 )]
5941 pub password: String,
5942 #[serde(default, skip_serializing_if = "Option::is_none")]
5946 pub recurrence: Option<RecurrenceWebinar>,
5947 #[serde(default, skip_serializing_if = "Option::is_none")]
5951 pub settings: Option<WebinarSettings>,
5952 #[serde(
5956 default,
5957 skip_serializing_if = "Option::is_none",
5958 deserialize_with = "crate::utils::date_time_format::deserialize"
5959 )]
5960 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
5961 #[serde(
5965 default,
5966 skip_serializing_if = "String::is_empty",
5967 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5968 )]
5969 pub timezone: String,
5970 #[serde(
5974 default,
5975 skip_serializing_if = "String::is_empty",
5976 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
5977 )]
5978 pub topic: String,
5979 #[serde(
5983 default,
5984 skip_serializing_if = "Vec::is_empty",
5985 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
5986 )]
5987 pub tracking_fields: Vec<SessionUpdateTrackingFields>,
5988 #[serde(
5992 default,
5993 skip_serializing_if = "crate::utils::zero_i64",
5994 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
5995 rename = "type"
5996 )]
5997 pub type_: i64,
5998}
5999
6000#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
6006pub struct SessionWebinarUpdateSettingsAllOf {
6007 #[serde(flatten)]
6008 pub settings_data: SettingsData,
6009 #[serde(flatten)]
6013 pub webinar_settings: WebinarSettings,
6014}
6015
6016#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
6018pub struct SessionWebinarUpdate {
6019 #[serde(
6023 default,
6024 skip_serializing_if = "String::is_empty",
6025 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6026 )]
6027 pub agenda: String,
6028 #[serde(
6032 default,
6033 skip_serializing_if = "crate::utils::zero_i64",
6034 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
6035 )]
6036 pub duration: i64,
6037 #[serde(
6041 default,
6042 skip_serializing_if = "String::is_empty",
6043 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6044 )]
6045 pub password: String,
6046 #[serde(default, skip_serializing_if = "Option::is_none")]
6050 pub recurrence: Option<Recurrence>,
6051 #[serde(default, skip_serializing_if = "Option::is_none")]
6055 pub settings: Option<SessionWebinarUpdateSettingsAllOf>,
6056 #[serde(
6060 default,
6061 skip_serializing_if = "Option::is_none",
6062 deserialize_with = "crate::utils::date_time_format::deserialize"
6063 )]
6064 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
6065 #[serde(
6069 default,
6070 skip_serializing_if = "String::is_empty",
6071 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6072 )]
6073 pub timezone: String,
6074 #[serde(
6078 default,
6079 skip_serializing_if = "String::is_empty",
6080 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6081 )]
6082 pub topic: String,
6083 #[serde(
6087 default,
6088 skip_serializing_if = "Vec::is_empty",
6089 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
6090 )]
6091 pub tracking_fields: Vec<SessionUpdateTrackingFields>,
6092 #[serde(
6096 default,
6097 skip_serializing_if = "crate::utils::zero_i64",
6098 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
6099 rename = "type"
6100 )]
6101 pub type_: i64,
6102}
6103
6104#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
6109pub enum TspAccountsListDialInNumbersType {
6110 #[serde(rename = "media_link")]
6111 MediaLink,
6112 #[serde(rename = "toll")]
6113 Toll,
6114 #[serde(rename = "tollfree")]
6115 Tollfree,
6116 #[serde(rename = "")]
6117 #[default]
6118 Noop,
6119 #[serde(other)]
6120 FallthroughString,
6121}
6122
6123impl std::fmt::Display for TspAccountsListDialInNumbersType {
6124 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6125 match self {
6126 TspAccountsListDialInNumbersType::MediaLink => "media_link",
6127 TspAccountsListDialInNumbersType::Toll => "toll",
6128 TspAccountsListDialInNumbersType::Tollfree => "tollfree",
6129 TspAccountsListDialInNumbersType::Noop => "",
6130 TspAccountsListDialInNumbersType::FallthroughString => "*",
6131 }
6132 .fmt(f)
6133 }
6134}
6135
6136impl TspAccountsListDialInNumbersType {
6137 pub fn is_noop(&self) -> bool {
6138 matches!(self, TspAccountsListDialInNumbersType::Noop)
6139 }
6140}
6141
6142#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
6143pub struct DialInNumbers {
6144 #[serde(
6148 default,
6149 skip_serializing_if = "String::is_empty",
6150 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6151 )]
6152 pub code: String,
6153 #[serde(
6157 default,
6158 skip_serializing_if = "String::is_empty",
6159 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6160 )]
6161 pub country_label: String,
6162 #[serde(
6166 default,
6167 skip_serializing_if = "String::is_empty",
6168 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6169 )]
6170 pub number: String,
6171 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
6176 pub type_: Option<TspAccountsListDialInNumbersType>,
6177}
6178
6179#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
6183pub enum TspBridge {
6184 #[serde(rename = "EU_TSP_TB")]
6185 EuTspTb,
6186 #[serde(rename = "US_TSP_TB")]
6187 UsTspTb,
6188 #[serde(rename = "")]
6189 #[default]
6190 Noop,
6191 #[serde(other)]
6192 FallthroughString,
6193}
6194
6195impl std::fmt::Display for TspBridge {
6196 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6197 match self {
6198 TspBridge::EuTspTb => "EU_TSP_TB",
6199 TspBridge::UsTspTb => "US_TSP_TB",
6200 TspBridge::Noop => "",
6201 TspBridge::FallthroughString => "*",
6202 }
6203 .fmt(f)
6204 }
6205}
6206
6207impl TspBridge {
6208 pub fn is_noop(&self) -> bool {
6209 matches!(self, TspBridge::Noop)
6210 }
6211}
6212
6213#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
6215pub struct TspAccountsList {
6216 #[serde(
6220 default,
6221 skip_serializing_if = "String::is_empty",
6222 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6223 )]
6224 pub conference_code: String,
6225 #[serde(
6229 default,
6230 skip_serializing_if = "Vec::is_empty",
6231 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
6232 )]
6233 pub dial_in_numbers: Vec<DialInNumbers>,
6234 #[serde(
6238 default,
6239 skip_serializing_if = "String::is_empty",
6240 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6241 )]
6242 pub leader_pin: String,
6243 #[serde(default, skip_serializing_if = "Option::is_none")]
6247 pub tsp_bridge: Option<TspBridge>,
6248}
6249
6250#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
6251pub struct DedicatedDialInNumber {
6252 #[serde(
6256 default,
6257 skip_serializing_if = "String::is_empty",
6258 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6259 )]
6260 pub country: String,
6261 #[serde(
6265 default,
6266 skip_serializing_if = "String::is_empty",
6267 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6268 )]
6269 pub number: String,
6270}
6271
6272#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
6274pub struct Pac {
6275 #[serde(
6279 default,
6280 skip_serializing_if = "crate::utils::zero_i64",
6281 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
6282 )]
6283 pub conference_id: i64,
6284 #[serde(
6288 default,
6289 skip_serializing_if = "Vec::is_empty",
6290 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
6291 )]
6292 pub dedicated_dial_in_number: Vec<DedicatedDialInNumber>,
6293 #[serde(
6297 default,
6298 skip_serializing_if = "Vec::is_empty",
6299 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
6300 )]
6301 pub global_dial_in_numbers: Vec<DedicatedDialInNumber>,
6302 #[serde(
6306 default,
6307 skip_serializing_if = "String::is_empty",
6308 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6309 )]
6310 pub listen_only_password: String,
6311 #[serde(
6315 default,
6316 skip_serializing_if = "String::is_empty",
6317 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6318 )]
6319 pub participant_password: String,
6320}
6321
6322#[derive(Serialize, Default, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
6324pub struct User {
6325 #[serde(
6329 default,
6330 skip_serializing_if = "Option::is_none",
6331 deserialize_with = "crate::utils::date_time_format::deserialize"
6332 )]
6333 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
6334 #[serde(
6338 default,
6339 skip_serializing_if = "String::is_empty",
6340 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6341 )]
6342 pub dept: String,
6343 #[serde(
6347 default,
6348 skip_serializing_if = "String::is_empty",
6349 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6350 )]
6351 pub email: String,
6352 #[serde(
6356 default,
6357 skip_serializing_if = "String::is_empty",
6358 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6359 )]
6360 pub first_name: String,
6361 #[serde(
6365 default,
6366 skip_serializing_if = "String::is_empty",
6367 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6368 )]
6369 pub last_client_version: String,
6370 #[serde(
6374 default,
6375 skip_serializing_if = "Option::is_none",
6376 deserialize_with = "crate::utils::date_time_format::deserialize"
6377 )]
6378 pub last_login_time: Option<chrono::DateTime<chrono::Utc>>,
6379 #[serde(
6383 default,
6384 skip_serializing_if = "String::is_empty",
6385 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6386 )]
6387 pub last_name: String,
6388 #[serde(
6392 default,
6393 skip_serializing_if = "crate::utils::zero_i64",
6394 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
6395 )]
6396 pub pmi: i64,
6397 #[serde(
6401 default,
6402 skip_serializing_if = "String::is_empty",
6403 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6404 )]
6405 pub role_name: String,
6406 #[serde(
6410 default,
6411 skip_serializing_if = "String::is_empty",
6412 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6413 )]
6414 pub timezone: String,
6415 #[serde(
6419 default,
6420 skip_serializing_if = "crate::utils::zero_i64",
6421 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
6422 rename = "type"
6423 )]
6424 pub type_: i64,
6425 #[serde(
6429 default,
6430 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6431 )]
6432 pub use_pmi: bool,
6433}
6434
6435#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
6437pub struct CustomAttributes {
6438 #[serde(
6442 default,
6443 skip_serializing_if = "String::is_empty",
6444 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6445 )]
6446 pub key: String,
6447 #[serde(
6451 default,
6452 skip_serializing_if = "String::is_empty",
6453 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6454 )]
6455 pub name: String,
6456 #[serde(
6460 default,
6461 skip_serializing_if = "String::is_empty",
6462 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6463 )]
6464 pub value: String,
6465}
6466
6467#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
6476pub enum Label {
6477 #[serde(rename = "Fax")]
6478 Fax,
6479 #[serde(rename = "Home")]
6480 Home,
6481 #[serde(rename = "Mobile")]
6482 Mobile,
6483 #[serde(rename = "Office")]
6484 Office,
6485 #[serde(rename = "")]
6486 #[default]
6487 Noop,
6488 #[serde(other)]
6489 FallthroughString,
6490}
6491
6492impl std::fmt::Display for Label {
6493 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6494 match self {
6495 Label::Fax => "Fax",
6496 Label::Home => "Home",
6497 Label::Mobile => "Mobile",
6498 Label::Office => "Office",
6499 Label::Noop => "",
6500 Label::FallthroughString => "*",
6501 }
6502 .fmt(f)
6503 }
6504}
6505
6506impl Label {
6507 pub fn is_noop(&self) -> bool {
6508 matches!(self, Label::Noop)
6509 }
6510}
6511
6512#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
6513pub struct PhoneNumbers {
6514 #[serde(
6518 default,
6519 skip_serializing_if = "String::is_empty",
6520 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6521 )]
6522 pub code: String,
6523 #[serde(
6527 default,
6528 skip_serializing_if = "String::is_empty",
6529 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6530 )]
6531 pub country: String,
6532 #[serde(default, skip_serializing_if = "Option::is_none")]
6541 pub label: Option<Label>,
6542 #[serde(
6546 default,
6547 skip_serializing_if = "String::is_empty",
6548 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6549 )]
6550 pub number: String,
6551}
6552
6553#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
6555pub struct UserUpdate {
6556 #[serde(
6560 default,
6561 skip_serializing_if = "String::is_empty",
6562 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6563 )]
6564 pub cms_user_id: String,
6565 #[serde(
6569 default,
6570 skip_serializing_if = "String::is_empty",
6571 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6572 )]
6573 pub company: String,
6574 #[serde(default, skip_serializing_if = "Option::is_none")]
6578 pub custom_attributes: Option<CustomAttributes>,
6579 #[serde(
6583 default,
6584 skip_serializing_if = "String::is_empty",
6585 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6586 )]
6587 pub dept: String,
6588 #[serde(
6592 default,
6593 skip_serializing_if = "String::is_empty",
6594 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6595 )]
6596 pub first_name: String,
6597 #[serde(
6601 default,
6602 skip_serializing_if = "String::is_empty",
6603 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6604 )]
6605 pub group_id: String,
6606 #[serde(
6610 default,
6611 skip_serializing_if = "String::is_empty",
6612 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6613 )]
6614 pub host_key: String,
6615 #[serde(
6619 default,
6620 skip_serializing_if = "String::is_empty",
6621 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6622 )]
6623 pub job_title: String,
6624 #[serde(
6628 default,
6629 skip_serializing_if = "String::is_empty",
6630 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6631 )]
6632 pub language: String,
6633 #[serde(
6637 default,
6638 skip_serializing_if = "String::is_empty",
6639 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6640 )]
6641 pub last_name: String,
6642 #[serde(
6646 default,
6647 skip_serializing_if = "String::is_empty",
6648 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6649 )]
6650 pub location: String,
6651 #[serde(
6655 default,
6656 skip_serializing_if = "String::is_empty",
6657 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6658 )]
6659 pub manager: String,
6660 #[serde(
6664 default,
6665 skip_serializing_if = "String::is_empty",
6666 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6667 )]
6668 pub phone_country: String,
6669 #[serde(
6673 default,
6674 skip_serializing_if = "String::is_empty",
6675 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6676 )]
6677 pub phone_number: String,
6678 #[serde(default, skip_serializing_if = "Option::is_none")]
6682 pub phone_numbers: Option<PhoneNumbers>,
6683 #[serde(
6687 default,
6688 skip_serializing_if = "crate::utils::zero_i64",
6689 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
6690 )]
6691 pub pmi: i64,
6692 #[serde(
6696 default,
6697 skip_serializing_if = "String::is_empty",
6698 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6699 )]
6700 pub timezone: String,
6701 #[serde(
6705 default,
6706 skip_serializing_if = "crate::utils::zero_i64",
6707 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
6708 rename = "type"
6709 )]
6710 pub type_: i64,
6711 #[serde(
6715 default,
6716 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6717 )]
6718 pub use_pmi: bool,
6719 #[serde(
6723 default,
6724 skip_serializing_if = "String::is_empty",
6725 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6726 )]
6727 pub vanity_name: String,
6728}
6729
6730#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
6732pub struct UserAssistantsList {
6733 #[serde(
6737 default,
6738 skip_serializing_if = "Vec::is_empty",
6739 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
6740 )]
6741 pub assistants: Vec<Assistants>,
6742}
6743
6744#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
6745pub struct Schedulers {
6746 #[serde(
6750 default,
6751 skip_serializing_if = "String::is_empty",
6752 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6753 )]
6754 pub email: String,
6755 #[serde(
6759 default,
6760 skip_serializing_if = "String::is_empty",
6761 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6762 )]
6763 pub id: String,
6764 #[serde(
6768 default,
6769 skip_serializing_if = "crate::utils::zero_i64",
6770 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
6771 )]
6772 pub pmi: i64,
6773}
6774
6775#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
6777pub struct UserSchedulersList {
6778 #[serde(
6782 default,
6783 skip_serializing_if = "Vec::is_empty",
6784 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
6785 )]
6786 pub schedulers: Vec<Schedulers>,
6787}
6788
6789#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
6791pub struct UserSettingsMeetingPasswordRequirement {
6792 #[serde(
6796 default,
6797 skip_serializing_if = "crate::utils::zero_i64",
6798 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
6799 )]
6800 pub consecutive_characters_length: i64,
6801 #[serde(
6805 default,
6806 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6807 )]
6808 pub have_letter: bool,
6809 #[serde(
6813 default,
6814 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6815 )]
6816 pub have_number: bool,
6817 #[serde(
6821 default,
6822 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6823 )]
6824 pub have_special_character: bool,
6825 #[serde(
6829 default,
6830 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6831 )]
6832 pub have_upper_and_lower_characters: bool,
6833 #[serde(
6837 default,
6838 skip_serializing_if = "crate::utils::zero_i64",
6839 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
6840 )]
6841 pub length: i64,
6842 #[serde(
6846 default,
6847 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6848 )]
6849 pub only_allow_numeric: bool,
6850 #[serde(
6854 default,
6855 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6856 )]
6857 pub weak_enhance_detection: bool,
6858}
6859
6860#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
6862pub struct UserSettingsMeeting {
6863 #[serde(default, skip_serializing_if = "Option::is_none")]
6867 pub audio_type: Option<AudioType>,
6868 #[serde(
6872 default,
6873 skip_serializing_if = "String::is_empty",
6874 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6875 )]
6876 pub default_password_for_scheduled_meetings: String,
6877 #[serde(
6881 default,
6882 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6883 )]
6884 pub embed_password_in_join_link: bool,
6885 #[serde(
6889 default,
6890 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6891 )]
6892 pub force_pmi_jbh_password: bool,
6893 #[serde(
6897 default,
6898 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6899 )]
6900 pub host_video: bool,
6901 #[serde(
6905 default,
6906 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6907 )]
6908 pub join_before_host: bool,
6909 #[serde(default, skip_serializing_if = "Option::is_none")]
6913 pub meeting_password_requirement: Option<UserSettingsMeetingPasswordRequirement>,
6914 #[serde(
6918 default,
6919 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6920 )]
6921 pub participants_video: bool,
6922 #[serde(
6926 default,
6927 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6928 )]
6929 pub personal_meeting: bool,
6930 #[serde(
6934 default,
6935 skip_serializing_if = "String::is_empty",
6936 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
6937 )]
6938 pub pmi_password: String,
6939 #[serde(
6943 default,
6944 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6945 )]
6946 pub pstn_password_protected: bool,
6947 #[serde(
6951 default,
6952 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6953 )]
6954 pub require_password_for_instant_meetings: bool,
6955 #[serde(default, skip_serializing_if = "Option::is_none")]
6959 pub require_password_for_pmi_meetings: Option<RequirePasswordPmiMeetings>,
6960 #[serde(
6964 default,
6965 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6966 )]
6967 pub require_password_for_scheduled_meetings: bool,
6968 #[serde(
6972 default,
6973 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6974 )]
6975 pub require_password_for_scheduling_new_meetings: bool,
6976 #[serde(
6980 default,
6981 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6982 )]
6983 pub use_pmi_for_instant_meetings: bool,
6984 #[serde(
6988 default,
6989 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
6990 )]
6991 pub use_pmi_for_scheduled_meetings: bool,
6992}
6993
6994#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
6996pub struct UserSettingsInMeeting {
6997 #[serde(
7001 default,
7002 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7003 )]
7004 pub allow_live_streaming: bool,
7005 #[serde(
7009 default,
7010 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7011 )]
7012 pub annotation: bool,
7013 #[serde(
7017 default,
7018 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7019 )]
7020 pub attendee_on_hold: bool,
7021 #[serde(
7025 default,
7026 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7027 )]
7028 pub auto_saving_chat: bool,
7029 #[serde(
7033 default,
7034 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7035 )]
7036 pub breakout_room: bool,
7037 #[serde(
7041 default,
7042 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7043 )]
7044 pub chat: bool,
7045 #[serde(
7049 default,
7050 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7051 )]
7052 pub closed_caption: bool,
7053 #[serde(
7057 default,
7058 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7059 )]
7060 pub co_host: bool,
7061 #[serde(
7065 default,
7066 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7067 )]
7068 pub custom_data_center_regions: bool,
7069 #[serde(
7073 default,
7074 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7075 )]
7076 pub custom_live_streaming_service: bool,
7077 #[serde(
7081 default,
7082 skip_serializing_if = "String::is_empty",
7083 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
7084 )]
7085 pub custom_service_instructions: String,
7086 #[serde(
7090 default,
7091 skip_serializing_if = "Vec::is_empty",
7092 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
7093 )]
7094 pub data_center_regions: Vec<String>,
7095 #[serde(
7099 default,
7100 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
7101 rename = "e2e_encryption"
7102 )]
7103 pub e_2e_encryption: bool,
7104 #[serde(default, skip_serializing_if = "Option::is_none")]
7108 pub entry_exit_chime: Option<EntryExitChime>,
7109 #[serde(
7113 default,
7114 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7115 )]
7116 pub far_end_camera_control: bool,
7117 #[serde(
7121 default,
7122 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7123 )]
7124 pub feedback: bool,
7125 #[serde(
7129 default,
7130 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7131 )]
7132 pub file_transfer: bool,
7133 #[serde(
7137 default,
7138 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7139 )]
7140 pub group_hd: bool,
7141 #[serde(
7145 default,
7146 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7147 )]
7148 pub join_from_desktop: bool,
7149 #[serde(
7153 default,
7154 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7155 )]
7156 pub join_from_mobile: bool,
7157 #[serde(
7161 default,
7162 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7163 )]
7164 pub non_verbal_feedback: bool,
7165 #[serde(
7169 default,
7170 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7171 )]
7172 pub polling: bool,
7173 #[serde(
7177 default,
7178 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7179 )]
7180 pub private_chat: bool,
7181 #[serde(
7185 default,
7186 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7187 )]
7188 pub record_play_voice: bool,
7189 #[serde(
7193 default,
7194 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7195 )]
7196 pub remote_control: bool,
7197 #[serde(
7201 default,
7202 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7203 )]
7204 pub remote_support: bool,
7205 #[serde(
7209 default,
7210 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7211 )]
7212 pub request_permission_to_unmute: bool,
7213 #[serde(
7217 default,
7218 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7219 )]
7220 pub screen_sharing: bool,
7221 #[serde(
7225 default,
7226 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7227 )]
7228 pub share_dual_camera: bool,
7229 #[serde(
7233 default,
7234 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7235 )]
7236 pub show_a_join_from_your_browser_link: bool,
7237 #[serde(
7241 default,
7242 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7243 )]
7244 pub show_meeting_control_toolbar: bool,
7245 #[serde(
7249 default,
7250 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7251 )]
7252 pub virtual_background: bool,
7253 #[serde(default, skip_serializing_if = "Option::is_none")]
7257 pub virtual_background_settings: Option<VirtualBackgroundSettings>,
7258 #[serde(
7262 default,
7263 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7264 )]
7265 pub waiting_room: bool,
7266 #[serde(default, skip_serializing_if = "Option::is_none")]
7270 pub who_can_share_screen: Option<WhoCanShareScreen>,
7271 #[serde(default, skip_serializing_if = "Option::is_none")]
7275 pub who_can_share_screen_when_someone_is_sharing: Option<WhoCanShareScreen>,
7276 #[serde(
7280 default,
7281 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7282 )]
7283 pub workplace_by_facebook: bool,
7284}
7285
7286#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
7288pub struct UserSettingsNotification {
7289 #[serde(
7293 default,
7294 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7295 )]
7296 pub alternative_host_reminder: bool,
7297 #[serde(
7301 default,
7302 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7303 )]
7304 pub cancel_meeting_reminder: bool,
7305 #[serde(
7309 default,
7310 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7311 )]
7312 pub jbh_reminder: bool,
7313 #[serde(
7317 default,
7318 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7319 )]
7320 pub schedule_for_reminder: bool,
7321}
7322
7323#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
7325pub struct UserSettingsRecordingPasswordRequirement {
7326 #[serde(
7330 default,
7331 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7332 )]
7333 pub have_letter: bool,
7334 #[serde(
7338 default,
7339 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7340 )]
7341 pub have_number: bool,
7342 #[serde(
7346 default,
7347 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7348 )]
7349 pub have_special_character: bool,
7350 #[serde(
7354 default,
7355 skip_serializing_if = "crate::utils::zero_i64",
7356 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
7357 )]
7358 pub length: i64,
7359 #[serde(
7363 default,
7364 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7365 )]
7366 pub only_allow_numeric: bool,
7367}
7368
7369#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
7371pub struct UserSettingsRecording {
7372 #[serde(
7376 default,
7377 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7378 )]
7379 pub ask_host_to_confirm_disclaimer: bool,
7380 #[serde(
7384 default,
7385 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7386 )]
7387 pub ask_participants_to_consent_disclaimer: bool,
7388 #[serde(
7392 default,
7393 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7394 )]
7395 pub auto_delete_cmr: bool,
7396 #[serde(
7400 default,
7401 skip_serializing_if = "crate::utils::zero_i64",
7402 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
7403 )]
7404 pub auto_delete_cmr_days: i64,
7405 #[serde(default, skip_serializing_if = "Option::is_none")]
7409 pub auto_recording: Option<AutoRecording>,
7410 #[serde(
7414 default,
7415 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7416 )]
7417 pub cloud_recording: bool,
7418 #[serde(
7422 default,
7423 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7424 )]
7425 pub host_pause_stop_recording: bool,
7426 #[serde(default, skip_serializing_if = "Option::is_none")]
7430 pub ip_address_access_control: Option<IpAddressAccessControl>,
7431 #[serde(
7435 default,
7436 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7437 )]
7438 pub local_recording: bool,
7439 #[serde(
7443 default,
7444 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7445 )]
7446 pub record_audio_file: bool,
7447 #[serde(
7451 default,
7452 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7453 )]
7454 pub record_audio_file_each_participant: bool,
7455 #[serde(
7459 default,
7460 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7461 )]
7462 pub record_gallery_view: bool,
7463 #[serde(
7467 default,
7468 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7469 )]
7470 pub record_speaker_view: bool,
7471 #[serde(
7475 default,
7476 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7477 )]
7478 pub recording_audio_transcript: bool,
7479 #[serde(
7483 default,
7484 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7485 )]
7486 pub recording_disclaimer: bool,
7487 #[serde(default, skip_serializing_if = "Option::is_none")]
7491 pub recording_password_requirement: Option<UserSettingsRecordingPasswordRequirement>,
7492 #[serde(
7496 default,
7497 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7498 )]
7499 pub save_chat_text: bool,
7500 #[serde(
7504 default,
7505 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7506 )]
7507 pub show_timestamp: bool,
7508}
7509
7510#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
7511pub struct UserSettingsTelephony {
7512 #[serde(
7513 default,
7514 skip_serializing_if = "String::is_empty",
7515 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
7516 )]
7517 pub audio_conference_info: String,
7518 #[serde(
7519 default,
7520 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7521 )]
7522 pub show_international_numbers_link: bool,
7523 #[serde(default, skip_serializing_if = "Option::is_none")]
7524 pub telephony_regions: Option<TelephonyRegions>,
7525 #[serde(
7526 default,
7527 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7528 )]
7529 pub third_party_audio: bool,
7530}
7531
7532#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
7534pub struct UserSettingsFeature {
7535 #[serde(
7539 default,
7540 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7541 )]
7542 pub cn_meeting: bool,
7543 #[serde(
7547 default,
7548 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7549 )]
7550 pub in_meeting: bool,
7551 #[serde(
7555 default,
7556 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7557 )]
7558 pub large_meeting: bool,
7559 #[serde(
7563 default,
7564 skip_serializing_if = "crate::utils::zero_i64",
7565 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
7566 )]
7567 pub large_meeting_capacity: i64,
7568 #[serde(
7572 default,
7573 skip_serializing_if = "crate::utils::zero_i64",
7574 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
7575 )]
7576 pub meeting_capacity: i64,
7577 #[serde(
7581 default,
7582 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7583 )]
7584 pub webinar: bool,
7585 #[serde(
7589 default,
7590 skip_serializing_if = "crate::utils::zero_i64",
7591 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
7592 )]
7593 pub webinar_capacity: i64,
7594 #[serde(
7598 default,
7599 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7600 )]
7601 pub zoom_events: bool,
7602 #[serde(
7606 default,
7607 skip_serializing_if = "crate::utils::zero_i64",
7608 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
7609 )]
7610 pub zoom_events_capacity: i64,
7611 #[serde(
7615 default,
7616 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7617 )]
7618 pub zoom_phone: bool,
7619}
7620
7621#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
7623pub struct UserSettingsTsp {
7624 #[serde(
7628 default,
7629 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7630 )]
7631 pub call_out: bool,
7632 #[serde(
7636 default,
7637 skip_serializing_if = "Vec::is_empty",
7638 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
7639 )]
7640 pub call_out_countries: Vec<String>,
7641 #[serde(
7645 default,
7646 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7647 )]
7648 pub show_international_numbers_link: bool,
7649}
7650
7651#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
7652pub struct UserSettings {
7653 #[serde(default, skip_serializing_if = "Option::is_none")]
7654 pub email_notification: Option<UserSettingsNotification>,
7655 #[serde(default, skip_serializing_if = "Option::is_none")]
7656 pub feature: Option<UserSettingsFeature>,
7657 #[serde(default, skip_serializing_if = "Option::is_none")]
7658 pub in_meeting: Option<UserSettingsInMeeting>,
7659 #[serde(default, skip_serializing_if = "Option::is_none")]
7660 pub profile: Option<Profile>,
7661 #[serde(default, skip_serializing_if = "Option::is_none")]
7662 pub recording: Option<UserSettingsRecording>,
7663 #[serde(default, skip_serializing_if = "Option::is_none")]
7664 pub schedule_meeting: Option<UserSettingsMeeting>,
7665 #[serde(default, skip_serializing_if = "Option::is_none")]
7666 pub telephony: Option<UserSettingsTelephony>,
7667 #[serde(default, skip_serializing_if = "Option::is_none")]
7668 pub tsp: Option<UserSettingsTsp>,
7669}
7670
7671#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
7672pub struct SettingsUpdateTelephony {
7673 #[serde(
7674 default,
7675 skip_serializing_if = "String::is_empty",
7676 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
7677 )]
7678 pub audio_conference_info: String,
7679 #[serde(
7680 default,
7681 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7682 )]
7683 pub show_international_numbers_link: bool,
7684 #[serde(default, skip_serializing_if = "Option::is_none")]
7685 pub telephony_regions: Option<UpdateAccountSettingsTelephonyRegions>,
7686 #[serde(
7687 default,
7688 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7689 )]
7690 pub third_party_audio: bool,
7691}
7692
7693#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
7695pub struct UserSettingsUpdateFeature {
7696 #[serde(
7700 default,
7701 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7702 )]
7703 pub large_meeting: bool,
7704 #[serde(
7708 default,
7709 skip_serializing_if = "crate::utils::zero_i64",
7710 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
7711 )]
7712 pub large_meeting_capacity: i64,
7713 #[serde(
7717 default,
7718 skip_serializing_if = "crate::utils::zero_i64",
7719 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
7720 )]
7721 pub meeting_capacity: i64,
7722 #[serde(
7726 default,
7727 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7728 )]
7729 pub webinar: bool,
7730 #[serde(
7734 default,
7735 skip_serializing_if = "crate::utils::zero_i64",
7736 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
7737 )]
7738 pub webinar_capacity: i64,
7739 #[serde(
7743 default,
7744 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7745 )]
7746 pub zoom_events: bool,
7747 #[serde(
7751 default,
7752 skip_serializing_if = "crate::utils::zero_i64",
7753 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
7754 )]
7755 pub zoom_events_capacity: i64,
7756 #[serde(
7760 default,
7761 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7762 )]
7763 pub zoom_phone: bool,
7764}
7765
7766#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
7767pub struct UserSettingsUpdate {
7768 #[serde(default, skip_serializing_if = "Option::is_none")]
7769 pub email_notification: Option<UserSettingsNotification>,
7770 #[serde(default, skip_serializing_if = "Option::is_none")]
7771 pub feature: Option<UserSettingsUpdateFeature>,
7772 #[serde(default, skip_serializing_if = "Option::is_none")]
7773 pub in_meeting: Option<UserSettingsInMeeting>,
7774 #[serde(default, skip_serializing_if = "Option::is_none")]
7775 pub profile: Option<Profile>,
7776 #[serde(default, skip_serializing_if = "Option::is_none")]
7777 pub recording: Option<UserSettingsRecording>,
7778 #[serde(default, skip_serializing_if = "Option::is_none")]
7779 pub schedule_meeting: Option<UserSettingsMeeting>,
7780 #[serde(default, skip_serializing_if = "Option::is_none")]
7781 pub telephony: Option<SettingsUpdateTelephony>,
7782 #[serde(default, skip_serializing_if = "Option::is_none")]
7783 pub tsp: Option<UserSettingsTsp>,
7784}
7785
7786#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
7788pub struct UserPermissions {
7789 #[serde(
7793 default,
7794 skip_serializing_if = "Vec::is_empty",
7795 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
7796 )]
7797 pub permissions: Vec<String>,
7798}
7799
7800#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
7802pub struct WebinarInfo {
7803 #[serde(
7807 default,
7808 skip_serializing_if = "String::is_empty",
7809 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
7810 )]
7811 pub agenda: String,
7812 #[serde(
7816 default,
7817 skip_serializing_if = "Option::is_none",
7818 deserialize_with = "crate::utils::date_time_format::deserialize"
7819 )]
7820 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
7821 #[serde(
7825 default,
7826 skip_serializing_if = "crate::utils::zero_i64",
7827 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
7828 )]
7829 pub duration: i64,
7830 #[serde(
7834 default,
7835 skip_serializing_if = "String::is_empty",
7836 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
7837 )]
7838 pub join_url: String,
7839 #[serde(
7843 default,
7844 skip_serializing_if = "Vec::is_empty",
7845 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
7846 )]
7847 pub occurrences: Vec<Occurrence>,
7848 #[serde(
7852 default,
7853 skip_serializing_if = "String::is_empty",
7854 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
7855 )]
7856 pub password: String,
7857 #[serde(default, skip_serializing_if = "Option::is_none")]
7861 pub recurrence: Option<RecurrenceWebinar>,
7862 #[serde(default, skip_serializing_if = "Option::is_none")]
7866 pub settings: Option<WebinarSettings>,
7867 #[serde(
7871 default,
7872 skip_serializing_if = "Option::is_none",
7873 deserialize_with = "crate::utils::date_time_format::deserialize"
7874 )]
7875 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
7876 #[serde(
7880 default,
7881 skip_serializing_if = "String::is_empty",
7882 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
7883 )]
7884 pub start_url: String,
7885 #[serde(
7889 default,
7890 skip_serializing_if = "String::is_empty",
7891 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
7892 )]
7893 pub timezone: String,
7894 #[serde(
7898 default,
7899 skip_serializing_if = "String::is_empty",
7900 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
7901 )]
7902 pub topic: String,
7903 #[serde(
7907 default,
7908 skip_serializing_if = "Vec::is_empty",
7909 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
7910 )]
7911 pub tracking_fields: Vec<SessionUpdateTrackingFields>,
7912 #[serde(
7916 default,
7917 skip_serializing_if = "crate::utils::zero_i64",
7918 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
7919 rename = "type"
7920 )]
7921 pub type_: i64,
7922}
7923
7924#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
7926pub struct Webinars {
7927 #[serde(
7931 default,
7932 skip_serializing_if = "Vec::is_empty",
7933 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
7934 )]
7935 pub custom_keys: Vec<CustomKeys>,
7936 #[serde(
7940 default,
7941 skip_serializing_if = "String::is_empty",
7942 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
7943 )]
7944 pub dept: String,
7945 #[serde(
7949 default,
7950 skip_serializing_if = "String::is_empty",
7951 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
7952 )]
7953 pub duration: String,
7954 #[serde(
7958 default,
7959 skip_serializing_if = "String::is_empty",
7960 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
7961 )]
7962 pub email: String,
7963 #[serde(
7967 default,
7968 skip_serializing_if = "Option::is_none",
7969 deserialize_with = "crate::utils::date_time_format::deserialize"
7970 )]
7971 pub end_time: Option<chrono::DateTime<chrono::Utc>>,
7972 #[serde(
7976 default,
7977 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7978 )]
7979 pub has_3rd_party_audio: bool,
7980 #[serde(
7984 default,
7985 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7986 )]
7987 pub has_pstn: bool,
7988 #[serde(
7992 default,
7993 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
7994 )]
7995 pub has_recording: bool,
7996 #[serde(
8000 default,
8001 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8002 )]
8003 pub has_screen_share: bool,
8004 #[serde(
8008 default,
8009 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8010 )]
8011 pub has_sip: bool,
8012 #[serde(
8016 default,
8017 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8018 )]
8019 pub has_video: bool,
8020 #[serde(
8024 default,
8025 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8026 )]
8027 pub has_voip: bool,
8028 #[serde(
8032 default,
8033 skip_serializing_if = "String::is_empty",
8034 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8035 )]
8036 pub host: String,
8037 #[serde(
8041 default,
8042 skip_serializing_if = "crate::utils::zero_i64",
8043 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
8044 )]
8045 pub id: i64,
8046 #[serde(
8050 default,
8051 skip_serializing_if = "crate::utils::zero_i64",
8052 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
8053 )]
8054 pub participants: i64,
8055 #[serde(
8059 default,
8060 skip_serializing_if = "Option::is_none",
8061 deserialize_with = "crate::utils::date_time_format::deserialize"
8062 )]
8063 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
8064 #[serde(
8068 default,
8069 skip_serializing_if = "String::is_empty",
8070 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8071 )]
8072 pub topic: String,
8073 #[serde(
8077 default,
8078 skip_serializing_if = "String::is_empty",
8079 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8080 )]
8081 pub user_type: String,
8082 #[serde(
8086 default,
8087 skip_serializing_if = "String::is_empty",
8088 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8089 )]
8090 pub uuid: String,
8091}
8092
8093#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
8095pub struct WebinarPanelist {
8096 #[serde(
8100 default,
8101 skip_serializing_if = "Vec::is_empty",
8102 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
8103 )]
8104 pub panelists: Vec<Panelist>,
8105}
8106
8107#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
8109pub struct ZoomRoom {
8110 #[serde(
8114 default,
8115 skip_serializing_if = "String::is_empty",
8116 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8117 )]
8118 pub account_type: String,
8119 #[serde(
8123 default,
8124 skip_serializing_if = "String::is_empty",
8125 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8126 )]
8127 pub calender_name: String,
8128 #[serde(
8132 default,
8133 skip_serializing_if = "String::is_empty",
8134 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8135 )]
8136 pub camera: String,
8137 #[serde(
8141 default,
8142 skip_serializing_if = "String::is_empty",
8143 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8144 )]
8145 pub device_ip: String,
8146 #[serde(
8150 default,
8151 skip_serializing_if = "String::is_empty",
8152 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8153 )]
8154 pub email: String,
8155 #[serde(
8159 default,
8160 skip_serializing_if = "String::is_empty",
8161 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8162 )]
8163 pub health: String,
8164 #[serde(
8168 default,
8169 skip_serializing_if = "String::is_empty",
8170 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8171 )]
8172 pub id: String,
8173 #[serde(
8177 default,
8178 skip_serializing_if = "Vec::is_empty",
8179 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
8180 )]
8181 pub issues: Vec<String>,
8182 #[serde(
8186 default,
8187 skip_serializing_if = "String::is_empty",
8188 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8189 )]
8190 pub last_start_time: String,
8191 #[serde(
8195 default,
8196 skip_serializing_if = "String::is_empty",
8197 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8198 )]
8199 pub location: String,
8200 #[serde(
8204 default,
8205 skip_serializing_if = "String::is_empty",
8206 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8207 )]
8208 pub microphone: String,
8209 #[serde(
8213 default,
8214 skip_serializing_if = "String::is_empty",
8215 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8216 )]
8217 pub room_name: String,
8218 #[serde(
8222 default,
8223 skip_serializing_if = "String::is_empty",
8224 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8225 )]
8226 pub speaker: String,
8227 #[serde(
8231 default,
8232 skip_serializing_if = "String::is_empty",
8233 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8234 )]
8235 pub status: String,
8236}
8237
8238#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
8242pub enum PollQuestionsType {
8243 #[serde(rename = "multiple")]
8244 Multiple,
8245 #[serde(rename = "single")]
8246 Single,
8247 #[serde(rename = "")]
8248 #[default]
8249 Noop,
8250 #[serde(other)]
8251 FallthroughString,
8252}
8253
8254impl std::fmt::Display for PollQuestionsType {
8255 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8256 match self {
8257 PollQuestionsType::Multiple => "multiple",
8258 PollQuestionsType::Single => "single",
8259 PollQuestionsType::Noop => "",
8260 PollQuestionsType::FallthroughString => "*",
8261 }
8262 .fmt(f)
8263 }
8264}
8265
8266impl PollQuestionsType {
8267 pub fn is_noop(&self) -> bool {
8268 matches!(self, PollQuestionsType::Noop)
8269 }
8270}
8271
8272#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
8273pub struct Questions {
8274 #[serde(
8281 default,
8282 skip_serializing_if = "Vec::is_empty",
8283 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
8284 )]
8285 pub answers: Vec<String>,
8286 #[serde(
8290 default,
8291 skip_serializing_if = "String::is_empty",
8292 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8293 )]
8294 pub name: String,
8295 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
8299 pub type_: Option<PollQuestionsType>,
8300}
8301
8302#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
8304pub struct Poll {
8305 #[serde(
8309 default,
8310 skip_serializing_if = "Vec::is_empty",
8311 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
8312 )]
8313 pub questions: Vec<Questions>,
8314 #[serde(
8318 default,
8319 skip_serializing_if = "String::is_empty",
8320 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8321 )]
8322 pub title: String,
8323}
8324
8325#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
8329pub enum FieldName {
8330 #[serde(rename = "address")]
8331 Address,
8332 #[serde(rename = "city")]
8333 City,
8334 #[serde(rename = "comments")]
8335 Comments,
8336 #[serde(rename = "country")]
8337 Country,
8338 #[serde(rename = "industry")]
8339 Industry,
8340 #[serde(rename = "job_title")]
8341 JobTitle,
8342 #[serde(rename = "no_of_employees")]
8343 NoOfEmployees,
8344 #[serde(rename = "org")]
8345 Org,
8346 #[serde(rename = "phone")]
8347 Phone,
8348 #[serde(rename = "purchasing_time_frame")]
8349 PurchasingTimeFrame,
8350 #[serde(rename = "role_in_purchase_process")]
8351 RoleInPurchaseProcess,
8352 #[serde(rename = "state")]
8353 State,
8354 #[serde(rename = "zip")]
8355 Zip,
8356 #[serde(rename = "")]
8357 #[default]
8358 Noop,
8359 #[serde(other)]
8360 FallthroughString,
8361}
8362
8363impl std::fmt::Display for FieldName {
8364 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8365 match self {
8366 FieldName::Address => "address",
8367 FieldName::City => "city",
8368 FieldName::Comments => "comments",
8369 FieldName::Country => "country",
8370 FieldName::Industry => "industry",
8371 FieldName::JobTitle => "job_title",
8372 FieldName::NoOfEmployees => "no_of_employees",
8373 FieldName::Org => "org",
8374 FieldName::Phone => "phone",
8375 FieldName::PurchasingTimeFrame => "purchasing_time_frame",
8376 FieldName::RoleInPurchaseProcess => "role_in_purchase_process",
8377 FieldName::State => "state",
8378 FieldName::Zip => "zip",
8379 FieldName::Noop => "",
8380 FieldName::FallthroughString => "*",
8381 }
8382 .fmt(f)
8383 }
8384}
8385
8386impl FieldName {
8387 pub fn is_noop(&self) -> bool {
8388 matches!(self, FieldName::Noop)
8389 }
8390}
8391
8392#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
8393pub struct MeetingRegistrantQuestions {
8394 #[serde(default, skip_serializing_if = "Option::is_none")]
8398 pub field_name: Option<FieldName>,
8399 #[serde(
8403 default,
8404 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8405 )]
8406 pub required: bool,
8407}
8408
8409#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
8413pub enum MeetingRegistrantQuestionsCustomType {
8414 #[serde(rename = "short")]
8415 Short,
8416 #[serde(rename = "single")]
8417 Single,
8418 #[serde(rename = "")]
8419 #[default]
8420 Noop,
8421 #[serde(other)]
8422 FallthroughString,
8423}
8424
8425impl std::fmt::Display for MeetingRegistrantQuestionsCustomType {
8426 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8427 match self {
8428 MeetingRegistrantQuestionsCustomType::Short => "short",
8429 MeetingRegistrantQuestionsCustomType::Single => "single",
8430 MeetingRegistrantQuestionsCustomType::Noop => "",
8431 MeetingRegistrantQuestionsCustomType::FallthroughString => "*",
8432 }
8433 .fmt(f)
8434 }
8435}
8436
8437impl MeetingRegistrantQuestionsCustomType {
8438 pub fn is_noop(&self) -> bool {
8439 matches!(self, MeetingRegistrantQuestionsCustomType::Noop)
8440 }
8441}
8442
8443#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
8444pub struct CustomQuestions {
8445 #[serde(
8452 default,
8453 skip_serializing_if = "Vec::is_empty",
8454 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
8455 )]
8456 pub answers: Vec<String>,
8457 #[serde(
8461 default,
8462 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8463 )]
8464 pub required: bool,
8465 #[serde(
8469 default,
8470 skip_serializing_if = "String::is_empty",
8471 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8472 )]
8473 pub title: String,
8474 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
8478 pub type_: Option<MeetingRegistrantQuestionsCustomType>,
8479}
8480
8481#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
8483pub struct MeetingRegistrantQuestionsData {
8484 #[serde(
8488 default,
8489 skip_serializing_if = "Vec::is_empty",
8490 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
8491 )]
8492 pub custom_questions: Vec<CustomQuestions>,
8493 #[serde(
8497 default,
8498 skip_serializing_if = "Vec::is_empty",
8499 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
8500 )]
8501 pub questions: Vec<MeetingRegistrantQuestions>,
8502}
8503
8504#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
8506pub struct WebinarRegistrantQuestions {
8507 #[serde(
8511 default,
8512 skip_serializing_if = "Vec::is_empty",
8513 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
8514 )]
8515 pub custom_questions: Vec<String>,
8516 #[serde(
8520 default,
8521 skip_serializing_if = "Vec::is_empty",
8522 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
8523 )]
8524 pub questions: Vec<String>,
8525}
8526
8527#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
8531pub enum RecordingRegistrantQuestionsFieldName {
8532 #[serde(rename = "address")]
8533 Address,
8534 #[serde(rename = "city")]
8535 City,
8536 #[serde(rename = "comments")]
8537 Comments,
8538 #[serde(rename = "country")]
8539 Country,
8540 #[serde(rename = "industry")]
8541 Industry,
8542 #[serde(rename = "job_title")]
8543 JobTitle,
8544 #[serde(rename = "last_name")]
8545 LastName,
8546 #[serde(rename = "no_of_employees")]
8547 NoOfEmployees,
8548 #[serde(rename = "org")]
8549 Org,
8550 #[serde(rename = "phone")]
8551 Phone,
8552 #[serde(rename = "purchasing_time_frame")]
8553 PurchasingTimeFrame,
8554 #[serde(rename = "role_in_purchase_process")]
8555 RoleInPurchaseProcess,
8556 #[serde(rename = "state")]
8557 State,
8558 #[serde(rename = "zip")]
8559 Zip,
8560 #[serde(rename = "")]
8561 #[default]
8562 Noop,
8563 #[serde(other)]
8564 FallthroughString,
8565}
8566
8567impl std::fmt::Display for RecordingRegistrantQuestionsFieldName {
8568 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8569 match self {
8570 RecordingRegistrantQuestionsFieldName::Address => "address",
8571 RecordingRegistrantQuestionsFieldName::City => "city",
8572 RecordingRegistrantQuestionsFieldName::Comments => "comments",
8573 RecordingRegistrantQuestionsFieldName::Country => "country",
8574 RecordingRegistrantQuestionsFieldName::Industry => "industry",
8575 RecordingRegistrantQuestionsFieldName::JobTitle => "job_title",
8576 RecordingRegistrantQuestionsFieldName::LastName => "last_name",
8577 RecordingRegistrantQuestionsFieldName::NoOfEmployees => "no_of_employees",
8578 RecordingRegistrantQuestionsFieldName::Org => "org",
8579 RecordingRegistrantQuestionsFieldName::Phone => "phone",
8580 RecordingRegistrantQuestionsFieldName::PurchasingTimeFrame => "purchasing_time_frame",
8581 RecordingRegistrantQuestionsFieldName::RoleInPurchaseProcess => {
8582 "role_in_purchase_process"
8583 }
8584 RecordingRegistrantQuestionsFieldName::State => "state",
8585 RecordingRegistrantQuestionsFieldName::Zip => "zip",
8586 RecordingRegistrantQuestionsFieldName::Noop => "",
8587 RecordingRegistrantQuestionsFieldName::FallthroughString => "*",
8588 }
8589 .fmt(f)
8590 }
8591}
8592
8593impl RecordingRegistrantQuestionsFieldName {
8594 pub fn is_noop(&self) -> bool {
8595 matches!(self, RecordingRegistrantQuestionsFieldName::Noop)
8596 }
8597}
8598
8599#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
8600pub struct RecordingRegistrantQuestions {
8601 #[serde(default, skip_serializing_if = "Option::is_none")]
8605 pub field_name: Option<RecordingRegistrantQuestionsFieldName>,
8606 #[serde(
8610 default,
8611 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8612 )]
8613 pub required: bool,
8614}
8615
8616#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
8620pub enum RecordingRegistrantQuestionsCustomType {
8621 #[serde(rename = "multiple")]
8622 Multiple,
8623 #[serde(rename = "short")]
8624 Short,
8625 #[serde(rename = "single")]
8626 Single,
8627 #[serde(rename = "")]
8628 #[default]
8629 Noop,
8630 #[serde(other)]
8631 FallthroughString,
8632}
8633
8634impl std::fmt::Display for RecordingRegistrantQuestionsCustomType {
8635 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8636 match self {
8637 RecordingRegistrantQuestionsCustomType::Multiple => "multiple",
8638 RecordingRegistrantQuestionsCustomType::Short => "short",
8639 RecordingRegistrantQuestionsCustomType::Single => "single",
8640 RecordingRegistrantQuestionsCustomType::Noop => "",
8641 RecordingRegistrantQuestionsCustomType::FallthroughString => "*",
8642 }
8643 .fmt(f)
8644 }
8645}
8646
8647impl RecordingRegistrantQuestionsCustomType {
8648 pub fn is_noop(&self) -> bool {
8649 matches!(self, RecordingRegistrantQuestionsCustomType::Noop)
8650 }
8651}
8652
8653#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
8654pub struct RecordingRegistrantQuestionsCustom {
8655 #[serde(
8662 default,
8663 skip_serializing_if = "Vec::is_empty",
8664 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
8665 )]
8666 pub answers: Vec<String>,
8667 #[serde(
8671 default,
8672 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8673 )]
8674 pub required: bool,
8675 #[serde(
8679 default,
8680 skip_serializing_if = "String::is_empty",
8681 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8682 )]
8683 pub title: String,
8684 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
8688 pub type_: Option<RecordingRegistrantQuestionsCustomType>,
8689}
8690
8691#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
8693pub struct RecordingRegistrantQuestionsData {
8694 #[serde(
8698 default,
8699 skip_serializing_if = "Vec::is_empty",
8700 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
8701 )]
8702 pub custom_questions: Vec<RecordingRegistrantQuestionsCustom>,
8703 #[serde(
8707 default,
8708 skip_serializing_if = "Vec::is_empty",
8709 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
8710 )]
8711 pub questions: Vec<RecordingRegistrantQuestions>,
8712}
8713
8714#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
8716pub struct TrackingField {
8717 #[serde(
8721 default,
8722 skip_serializing_if = "String::is_empty",
8723 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8724 )]
8725 pub field: String,
8726 #[serde(
8730 default,
8731 skip_serializing_if = "Vec::is_empty",
8732 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
8733 )]
8734 pub recommended_values: Vec<String>,
8735 #[serde(
8739 default,
8740 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8741 )]
8742 pub required: bool,
8743 #[serde(
8747 default,
8748 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8749 )]
8750 pub visible: bool,
8751}
8752
8753#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
8755pub struct CreateWebinarSettings {
8756 #[serde(
8760 default,
8761 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8762 )]
8763 pub allow_multiple_devices: bool,
8764 #[serde(
8768 default,
8769 skip_serializing_if = "String::is_empty",
8770 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8771 )]
8772 pub alternative_hosts: String,
8773 #[serde(
8777 default,
8778 skip_serializing_if = "crate::utils::zero_i64",
8779 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
8780 )]
8781 pub approval_type: i64,
8782 #[serde(default, skip_serializing_if = "Option::is_none")]
8786 pub attendees_and_panelists_reminder_email_notification:
8787 Option<AttendeesPanelistsReminderEmailNotification>,
8788 #[serde(default, skip_serializing_if = "Option::is_none")]
8792 pub audio: Option<Audio>,
8793 #[serde(
8797 default,
8798 skip_serializing_if = "String::is_empty",
8799 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8800 )]
8801 pub authentication_domains: String,
8802 #[serde(
8806 default,
8807 skip_serializing_if = "String::is_empty",
8808 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8809 )]
8810 pub authentication_option: String,
8811 #[serde(default, skip_serializing_if = "Option::is_none")]
8815 pub auto_recording: Option<AutoRecording>,
8816 #[serde(
8820 default,
8821 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8822 )]
8823 pub close_registration: bool,
8824 #[serde(
8828 default,
8829 skip_serializing_if = "String::is_empty",
8830 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8831 )]
8832 pub contact_email: String,
8833 #[serde(
8837 default,
8838 skip_serializing_if = "String::is_empty",
8839 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8840 )]
8841 pub contact_name: String,
8842 #[serde(
8846 default,
8847 skip_serializing_if = "String::is_empty",
8848 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8849 )]
8850 pub email_language: String,
8851 #[serde(
8855 default,
8856 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8857 )]
8858 pub enforce_login: bool,
8859 #[serde(
8863 default,
8864 skip_serializing_if = "String::is_empty",
8865 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8866 )]
8867 pub enforce_login_domains: String,
8868 #[serde(default, skip_serializing_if = "Option::is_none")]
8872 pub follow_up_absentees_email_notification: Option<FollowUpAbsenteesEmailNotification>,
8873 #[serde(default, skip_serializing_if = "Option::is_none")]
8877 pub follow_up_attendees_email_notification: Option<FollowUpAttendeesEmailNotification>,
8878 #[serde(
8882 default,
8883 skip_serializing_if = "Vec::is_empty",
8884 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
8885 )]
8886 pub global_dial_in_countries: Vec<String>,
8887 #[serde(
8891 default,
8892 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8893 )]
8894 pub hd_video: bool,
8895 #[serde(
8899 default,
8900 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8901 )]
8902 pub host_video: bool,
8903 #[serde(
8907 default,
8908 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8909 )]
8910 pub meeting_authentication: bool,
8911 #[serde(
8915 default,
8916 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8917 )]
8918 pub on_demand: bool,
8919 #[serde(
8923 default,
8924 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8925 )]
8926 pub panelists_invitation_email_notification: bool,
8927 #[serde(
8931 default,
8932 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8933 )]
8934 pub panelists_video: bool,
8935 #[serde(
8939 default,
8940 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8941 )]
8942 pub post_webinar_survey: bool,
8943 #[serde(
8947 default,
8948 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8949 )]
8950 pub practice_session: bool,
8951 #[serde(default, skip_serializing_if = "Option::is_none")]
8955 pub question_and_answer: Option<QuestionAnswer>,
8956 #[serde(
8960 default,
8961 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8962 )]
8963 pub registrants_email_notification: bool,
8964 #[serde(
8968 default,
8969 skip_serializing_if = "crate::utils::zero_i64",
8970 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
8971 )]
8972 pub registrants_restrict_number: i64,
8973 #[serde(
8977 default,
8978 skip_serializing_if = "crate::utils::zero_i64",
8979 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
8980 )]
8981 pub registration_type: i64,
8982 #[serde(
8986 default,
8987 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
8988 )]
8989 pub show_share_button: bool,
8990 #[serde(
8994 default,
8995 skip_serializing_if = "String::is_empty",
8996 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
8997 )]
8998 pub survey_url: String,
8999}
9000
9001#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
9002pub struct MeetingCreateTrackingFields {
9003 #[serde(
9007 default,
9008 skip_serializing_if = "String::is_empty",
9009 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9010 )]
9011 pub field: String,
9012 #[serde(
9016 default,
9017 skip_serializing_if = "String::is_empty",
9018 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9019 )]
9020 pub value: String,
9021}
9022
9023#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
9027pub struct MeetingCreateSettingsLanguageInterpretation {
9028 #[serde(
9034 default,
9035 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
9036 )]
9037 pub enable: bool,
9038 #[serde(
9044 default,
9045 skip_serializing_if = "Vec::is_empty",
9046 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
9047 )]
9048 pub interpreters: Vec<Interpreters>,
9049}
9050
9051#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
9053pub struct MeetingCreateSettings {
9054 #[serde(
9058 default,
9059 skip_serializing_if = "Vec::is_empty",
9060 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
9061 )]
9062 pub additional_data_center_regions: Vec<String>,
9063 #[serde(
9067 default,
9068 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
9069 )]
9070 pub allow_multiple_devices: bool,
9071 #[serde(
9075 default,
9076 skip_serializing_if = "String::is_empty",
9077 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9078 )]
9079 pub alternative_hosts: String,
9080 #[serde(
9084 default,
9085 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
9086 )]
9087 pub alternative_hosts_email_notification: bool,
9088 #[serde(
9092 default,
9093 skip_serializing_if = "crate::utils::zero_i64",
9094 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
9095 )]
9096 pub approval_type: i64,
9097 #[serde(default, skip_serializing_if = "Option::is_none")]
9101 pub approved_or_denied_countries_or_regions: Option<ApprovedDeniedCountriesRegions>,
9102 #[serde(default, skip_serializing_if = "Option::is_none")]
9106 pub audio: Option<Audio>,
9107 #[serde(
9111 default,
9112 skip_serializing_if = "String::is_empty",
9113 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9114 )]
9115 pub authentication_domains: String,
9116 #[serde(
9120 default,
9121 skip_serializing_if = "Vec::is_empty",
9122 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
9123 )]
9124 pub authentication_exception: Vec<AuthenticationException>,
9125 #[serde(
9129 default,
9130 skip_serializing_if = "String::is_empty",
9131 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9132 )]
9133 pub authentication_option: String,
9134 #[serde(default, skip_serializing_if = "Option::is_none")]
9138 pub auto_recording: Option<AutoRecording>,
9139 #[serde(default, skip_serializing_if = "Option::is_none")]
9143 pub breakout_room: Option<BreakoutRoom>,
9144 #[serde(
9148 default,
9149 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
9150 )]
9151 pub close_registration: bool,
9152 #[serde(
9156 default,
9157 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
9158 )]
9159 pub cn_meeting: bool,
9160 #[serde(
9164 default,
9165 skip_serializing_if = "String::is_empty",
9166 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9167 )]
9168 pub contact_email: String,
9169 #[serde(
9173 default,
9174 skip_serializing_if = "String::is_empty",
9175 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9176 )]
9177 pub contact_name: String,
9178 #[serde(default, skip_serializing_if = "Option::is_none")]
9182 pub encryption_type: Option<EncryptionType>,
9183 #[serde(
9187 default,
9188 skip_serializing_if = "Vec::is_empty",
9189 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
9190 )]
9191 pub global_dial_in_countries: Vec<String>,
9192 #[serde(
9196 default,
9197 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
9198 )]
9199 pub host_video: bool,
9200 #[serde(
9204 default,
9205 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
9206 )]
9207 pub in_meeting: bool,
9208 #[serde(
9212 default,
9213 skip_serializing_if = "crate::utils::zero_i64",
9214 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
9215 )]
9216 pub jbh_time: i64,
9217 #[serde(
9221 default,
9222 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
9223 )]
9224 pub join_before_host: bool,
9225 #[serde(default, skip_serializing_if = "Option::is_none")]
9229 pub language_interpretation: Option<MeetingCreateSettingsLanguageInterpretation>,
9230 #[serde(
9234 default,
9235 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
9236 )]
9237 pub meeting_authentication: bool,
9238 #[serde(
9242 default,
9243 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
9244 )]
9245 pub mute_upon_entry: bool,
9246 #[serde(
9250 default,
9251 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
9252 )]
9253 pub participant_video: bool,
9254 #[serde(
9258 default,
9259 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
9260 )]
9261 pub registrants_confirmation_email: bool,
9262 #[serde(
9266 default,
9267 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
9268 )]
9269 pub registrants_email_notification: bool,
9270 #[serde(
9274 default,
9275 skip_serializing_if = "crate::utils::zero_i64",
9276 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
9277 )]
9278 pub registration_type: i64,
9279 #[serde(
9283 default,
9284 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
9285 )]
9286 pub show_share_button: bool,
9287 #[serde(
9291 default,
9292 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
9293 )]
9294 pub use_pmi: bool,
9295 #[serde(
9299 default,
9300 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
9301 )]
9302 pub waiting_room: bool,
9303 #[serde(
9307 default,
9308 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
9309 )]
9310 pub watermark: bool,
9311}
9312
9313#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
9315pub struct MeetingCreate {
9316 #[serde(
9320 default,
9321 skip_serializing_if = "String::is_empty",
9322 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9323 )]
9324 pub agenda: String,
9325 #[serde(
9329 default,
9330 skip_serializing_if = "crate::utils::zero_i64",
9331 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
9332 )]
9333 pub duration: i64,
9334 #[serde(
9338 default,
9339 skip_serializing_if = "String::is_empty",
9340 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9341 )]
9342 pub password: String,
9343 #[serde(
9347 default,
9348 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
9349 )]
9350 pub pre_schedule: bool,
9351 #[serde(default, skip_serializing_if = "Option::is_none")]
9355 pub recurrence: Option<Recurrence>,
9356 #[serde(
9360 default,
9361 skip_serializing_if = "String::is_empty",
9362 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9363 )]
9364 pub schedule_for: String,
9365 #[serde(default, skip_serializing_if = "Option::is_none")]
9369 pub settings: Option<MeetingCreateSettings>,
9370 #[serde(
9374 default,
9375 skip_serializing_if = "Option::is_none",
9376 deserialize_with = "crate::utils::date_time_format::deserialize"
9377 )]
9378 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
9379 #[serde(
9383 default,
9384 skip_serializing_if = "String::is_empty",
9385 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9386 )]
9387 pub template_id: String,
9388 #[serde(
9392 default,
9393 skip_serializing_if = "String::is_empty",
9394 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9395 )]
9396 pub timezone: String,
9397 #[serde(
9401 default,
9402 skip_serializing_if = "String::is_empty",
9403 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9404 )]
9405 pub topic: String,
9406 #[serde(
9410 default,
9411 skip_serializing_if = "Vec::is_empty",
9412 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
9413 )]
9414 pub tracking_fields: Vec<MeetingCreateTrackingFields>,
9415 #[serde(
9419 default,
9420 skip_serializing_if = "crate::utils::zero_i64",
9421 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
9422 rename = "type"
9423 )]
9424 pub type_: i64,
9425}
9426
9427#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
9429pub struct CreateWebinar {
9430 #[serde(
9434 default,
9435 skip_serializing_if = "String::is_empty",
9436 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9437 )]
9438 pub agenda: String,
9439 #[serde(
9443 default,
9444 skip_serializing_if = "crate::utils::zero_i64",
9445 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
9446 )]
9447 pub duration: i64,
9448 #[serde(
9452 default,
9453 skip_serializing_if = "String::is_empty",
9454 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9455 )]
9456 pub password: String,
9457 #[serde(default, skip_serializing_if = "Option::is_none")]
9461 pub recurrence: Option<RecurrenceWebinar>,
9462 #[serde(default, skip_serializing_if = "Option::is_none")]
9466 pub settings: Option<CreateWebinarSettings>,
9467 #[serde(
9471 default,
9472 skip_serializing_if = "Option::is_none",
9473 deserialize_with = "crate::utils::date_time_format::deserialize"
9474 )]
9475 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
9476 #[serde(
9480 default,
9481 skip_serializing_if = "String::is_empty",
9482 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9483 )]
9484 pub timezone: String,
9485 #[serde(
9489 default,
9490 skip_serializing_if = "String::is_empty",
9491 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9492 )]
9493 pub topic: String,
9494 #[serde(
9498 default,
9499 skip_serializing_if = "Vec::is_empty",
9500 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
9501 )]
9502 pub tracking_fields: Vec<MeetingCreateTrackingFields>,
9503 #[serde(
9507 default,
9508 skip_serializing_if = "crate::utils::zero_i64",
9509 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
9510 rename = "type"
9511 )]
9512 pub type_: i64,
9513}
9514
9515#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
9516pub struct TspGlobalDialIn {
9517 #[serde(
9518 default,
9519 skip_serializing_if = "String::is_empty",
9520 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9521 )]
9522 pub audio_url: String,
9523}
9524
9525#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
9526pub struct ChannelSettings {
9527 #[serde(
9531 default,
9532 skip_serializing_if = "crate::utils::zero_i64",
9533 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
9534 )]
9535 pub allow_to_add_external_users: i64,
9536 #[serde(
9540 default,
9541 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
9542 )]
9543 pub new_members_can_see_previous_messages_files: bool,
9544 #[serde(
9548 default,
9549 skip_serializing_if = "crate::utils::zero_i64",
9550 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
9551 )]
9552 pub posting_permissions: i64,
9553}
9554
9555#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
9556pub struct Properties {
9557 #[serde(default, skip_serializing_if = "Option::is_none")]
9558 pub channel_settings: Option<ChannelSettings>,
9559 #[serde(
9563 default,
9564 skip_serializing_if = "String::is_empty",
9565 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9566 )]
9567 pub id: String,
9568 #[serde(
9572 default,
9573 skip_serializing_if = "String::is_empty",
9574 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9575 )]
9576 pub jid: String,
9577 #[serde(
9581 default,
9582 skip_serializing_if = "String::is_empty",
9583 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9584 )]
9585 pub name: String,
9586 #[serde(
9590 default,
9591 skip_serializing_if = "crate::utils::zero_i64",
9592 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
9593 rename = "type"
9594 )]
9595 pub type_: i64,
9596}
9597
9598#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
9600pub struct Channel {
9601 #[serde(default, skip_serializing_if = "Option::is_none")]
9605 pub properties: Option<Properties>,
9606}
9607
9608#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
9609pub struct CpuUsage {
9610 #[serde(
9614 default,
9615 skip_serializing_if = "String::is_empty",
9616 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9617 )]
9618 pub system_max_cpu_usage: String,
9619 #[serde(
9623 default,
9624 skip_serializing_if = "String::is_empty",
9625 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9626 )]
9627 pub zoom_avg_cpu_usage: String,
9628 #[serde(
9632 default,
9633 skip_serializing_if = "String::is_empty",
9634 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9635 )]
9636 pub zoom_max_cpu_usage: String,
9637 #[serde(
9641 default,
9642 skip_serializing_if = "String::is_empty",
9643 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9644 )]
9645 pub zoom_min_cpu_usage: String,
9646}
9647
9648#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
9650pub struct AudioDeviceFromCrc {
9651 #[serde(
9655 default,
9656 skip_serializing_if = "String::is_empty",
9657 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9658 )]
9659 pub avg_loss: String,
9660 #[serde(
9664 default,
9665 skip_serializing_if = "String::is_empty",
9666 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9667 )]
9668 pub bitrate: String,
9669 #[serde(
9673 default,
9674 skip_serializing_if = "String::is_empty",
9675 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9676 )]
9677 pub jitter: String,
9678 #[serde(
9682 default,
9683 skip_serializing_if = "String::is_empty",
9684 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9685 )]
9686 pub latency: String,
9687 #[serde(
9691 default,
9692 skip_serializing_if = "String::is_empty",
9693 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9694 )]
9695 pub max_loss: String,
9696}
9697
9698#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
9700pub struct AudioDeviceCrc {
9701 #[serde(
9705 default,
9706 skip_serializing_if = "String::is_empty",
9707 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9708 )]
9709 pub avg_loss: String,
9710 #[serde(
9714 default,
9715 skip_serializing_if = "String::is_empty",
9716 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9717 )]
9718 pub bitrate: String,
9719 #[serde(
9723 default,
9724 skip_serializing_if = "String::is_empty",
9725 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9726 )]
9727 pub jitter: String,
9728 #[serde(
9732 default,
9733 skip_serializing_if = "String::is_empty",
9734 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9735 )]
9736 pub latency: String,
9737 #[serde(
9741 default,
9742 skip_serializing_if = "String::is_empty",
9743 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9744 )]
9745 pub max_loss: String,
9746}
9747
9748#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
9750pub struct VideoDeviceFromCrc {
9751 #[serde(
9755 default,
9756 skip_serializing_if = "String::is_empty",
9757 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9758 )]
9759 pub avg_loss: String,
9760 #[serde(
9764 default,
9765 skip_serializing_if = "String::is_empty",
9766 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9767 )]
9768 pub bitrate: String,
9769 #[serde(
9773 default,
9774 skip_serializing_if = "String::is_empty",
9775 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9776 )]
9777 pub jitter: String,
9778 #[serde(
9782 default,
9783 skip_serializing_if = "String::is_empty",
9784 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9785 )]
9786 pub latency: String,
9787 #[serde(
9791 default,
9792 skip_serializing_if = "String::is_empty",
9793 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9794 )]
9795 pub max_loss: String,
9796}
9797
9798#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
9800pub struct VideoDeviceCrc {
9801 #[serde(
9805 default,
9806 skip_serializing_if = "String::is_empty",
9807 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9808 )]
9809 pub avg_loss: String,
9810 #[serde(
9814 default,
9815 skip_serializing_if = "String::is_empty",
9816 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9817 )]
9818 pub bitrate: String,
9819 #[serde(
9823 default,
9824 skip_serializing_if = "String::is_empty",
9825 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9826 )]
9827 pub jitter: String,
9828 #[serde(
9832 default,
9833 skip_serializing_if = "String::is_empty",
9834 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9835 )]
9836 pub latency: String,
9837 #[serde(
9841 default,
9842 skip_serializing_if = "String::is_empty",
9843 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9844 )]
9845 pub max_loss: String,
9846}
9847
9848#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
9850pub struct AsDeviceFromCrc {
9851 #[serde(
9855 default,
9856 skip_serializing_if = "String::is_empty",
9857 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9858 )]
9859 pub avg_loss: String,
9860 #[serde(
9864 default,
9865 skip_serializing_if = "String::is_empty",
9866 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9867 )]
9868 pub bitrate: String,
9869 #[serde(
9873 default,
9874 skip_serializing_if = "String::is_empty",
9875 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9876 )]
9877 pub jitter: String,
9878 #[serde(
9882 default,
9883 skip_serializing_if = "String::is_empty",
9884 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9885 )]
9886 pub latency: String,
9887 #[serde(
9891 default,
9892 skip_serializing_if = "String::is_empty",
9893 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9894 )]
9895 pub max_loss: String,
9896}
9897
9898#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
9900pub struct AsDeviceCrc {
9901 #[serde(
9905 default,
9906 skip_serializing_if = "String::is_empty",
9907 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9908 )]
9909 pub avg_loss: String,
9910 #[serde(
9914 default,
9915 skip_serializing_if = "String::is_empty",
9916 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9917 )]
9918 pub bitrate: String,
9919 #[serde(
9923 default,
9924 skip_serializing_if = "String::is_empty",
9925 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9926 )]
9927 pub jitter: String,
9928 #[serde(
9932 default,
9933 skip_serializing_if = "String::is_empty",
9934 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9935 )]
9936 pub latency: String,
9937 #[serde(
9941 default,
9942 skip_serializing_if = "String::is_empty",
9943 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
9944 )]
9945 pub max_loss: String,
9946}
9947
9948#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
9949pub struct UserQos {
9950 #[serde(default, skip_serializing_if = "Option::is_none")]
9954 pub as_device_from_crc: Option<AsDeviceFromCrc>,
9955 #[serde(default, skip_serializing_if = "Option::is_none")]
9959 pub as_device_to_crc: Option<AsDeviceCrc>,
9960 #[serde(default, skip_serializing_if = "Option::is_none")]
9961 pub as_input: Option<Domains>,
9962 #[serde(default, skip_serializing_if = "Option::is_none")]
9963 pub as_output: Option<Domains>,
9964 #[serde(default, skip_serializing_if = "Option::is_none")]
9968 pub audio_device_from_crc: Option<AudioDeviceFromCrc>,
9969 #[serde(default, skip_serializing_if = "Option::is_none")]
9973 pub audio_device_to_crc: Option<AudioDeviceCrc>,
9974 #[serde(default, skip_serializing_if = "Option::is_none")]
9978 pub audio_input: Option<QosAudio>,
9979 #[serde(default, skip_serializing_if = "Option::is_none")]
9983 pub audio_output: Option<QosAudio>,
9984 #[serde(default, skip_serializing_if = "Option::is_none")]
9985 pub cpu_usage: Option<CpuUsage>,
9986 #[serde(
9990 default,
9991 skip_serializing_if = "Option::is_none",
9992 deserialize_with = "crate::utils::date_time_format::deserialize"
9993 )]
9994 pub date_time: Option<chrono::DateTime<chrono::Utc>>,
9995 #[serde(default, skip_serializing_if = "Option::is_none")]
9999 pub video_device_from_crc: Option<VideoDeviceFromCrc>,
10000 #[serde(default, skip_serializing_if = "Option::is_none")]
10004 pub video_device_to_crc: Option<VideoDeviceCrc>,
10005 #[serde(default, skip_serializing_if = "Option::is_none")]
10006 pub video_input: Option<Domains>,
10007 #[serde(default, skip_serializing_if = "Option::is_none")]
10008 pub video_output: Option<Domains>,
10009}
10010
10011#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
10013pub struct ParticipantQos {
10014 #[serde(
10018 default,
10019 skip_serializing_if = "String::is_empty",
10020 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10021 )]
10022 pub device: String,
10023 #[serde(
10027 default,
10028 skip_serializing_if = "String::is_empty",
10029 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10030 )]
10031 pub domain: String,
10032 #[serde(
10036 default,
10037 skip_serializing_if = "String::is_empty",
10038 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10039 )]
10040 pub harddisk_id: String,
10041 #[serde(
10045 default,
10046 skip_serializing_if = "String::is_empty",
10047 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10048 )]
10049 pub ip_address: String,
10050 #[serde(
10054 default,
10055 skip_serializing_if = "Option::is_none",
10056 deserialize_with = "crate::utils::date_time_format::deserialize"
10057 )]
10058 pub join_time: Option<chrono::DateTime<chrono::Utc>>,
10059 #[serde(
10063 default,
10064 skip_serializing_if = "Option::is_none",
10065 deserialize_with = "crate::utils::date_time_format::deserialize"
10066 )]
10067 pub leave_time: Option<chrono::DateTime<chrono::Utc>>,
10068 #[serde(
10072 default,
10073 skip_serializing_if = "String::is_empty",
10074 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10075 )]
10076 pub location: String,
10077 #[serde(
10081 default,
10082 skip_serializing_if = "String::is_empty",
10083 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10084 )]
10085 pub mac_addr: String,
10086 #[serde(
10090 default,
10091 skip_serializing_if = "String::is_empty",
10092 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10093 )]
10094 pub pc_name: String,
10095 #[serde(
10099 default,
10100 skip_serializing_if = "String::is_empty",
10101 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10102 )]
10103 pub user_id: String,
10104 #[serde(
10108 default,
10109 skip_serializing_if = "String::is_empty",
10110 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10111 )]
10112 pub user_name: String,
10113 #[serde(
10117 default,
10118 skip_serializing_if = "Vec::is_empty",
10119 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
10120 )]
10121 pub user_qos: Vec<UserQos>,
10122 #[serde(
10126 default,
10127 skip_serializing_if = "String::is_empty",
10128 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10129 )]
10130 pub version: String,
10131}
10132
10133#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
10134pub enum AccountSettingsRecordingAuthenticationUpdateOptionType {
10135 #[serde(rename = "enforce_login")]
10136 EnforceLogin,
10137 #[serde(rename = "enforce_login_with_domains")]
10138 EnforceLoginWithDomains,
10139 #[serde(rename = "internally")]
10140 Internally,
10141 #[serde(rename = "")]
10142 #[default]
10143 Noop,
10144 #[serde(other)]
10145 FallthroughString,
10146}
10147
10148impl std::fmt::Display for AccountSettingsRecordingAuthenticationUpdateOptionType {
10149 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10150 match self {
10151 AccountSettingsRecordingAuthenticationUpdateOptionType::EnforceLogin => "enforce_login",
10152 AccountSettingsRecordingAuthenticationUpdateOptionType::EnforceLoginWithDomains => {
10153 "enforce_login_with_domains"
10154 }
10155 AccountSettingsRecordingAuthenticationUpdateOptionType::Internally => "internally",
10156 AccountSettingsRecordingAuthenticationUpdateOptionType::Noop => "",
10157 AccountSettingsRecordingAuthenticationUpdateOptionType::FallthroughString => "*",
10158 }
10159 .fmt(f)
10160 }
10161}
10162
10163impl AccountSettingsRecordingAuthenticationUpdateOptionType {
10164 pub fn is_noop(&self) -> bool {
10165 matches!(
10166 self,
10167 AccountSettingsRecordingAuthenticationUpdateOptionType::Noop
10168 )
10169 }
10170}
10171
10172#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
10173pub enum AccountSettingsRecordingAuthenticationUpdateOptionAction {
10174 #[serde(rename = "add")]
10175 Add,
10176 #[serde(rename = "delete")]
10177 Delete,
10178 #[serde(rename = "update")]
10179 Update,
10180 #[serde(rename = "")]
10181 #[default]
10182 Noop,
10183 #[serde(other)]
10184 FallthroughString,
10185}
10186
10187impl std::fmt::Display for AccountSettingsRecordingAuthenticationUpdateOptionAction {
10188 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10189 match self {
10190 AccountSettingsRecordingAuthenticationUpdateOptionAction::Add => "add",
10191 AccountSettingsRecordingAuthenticationUpdateOptionAction::Delete => "delete",
10192 AccountSettingsRecordingAuthenticationUpdateOptionAction::Update => "update",
10193 AccountSettingsRecordingAuthenticationUpdateOptionAction::Noop => "",
10194 AccountSettingsRecordingAuthenticationUpdateOptionAction::FallthroughString => "*",
10195 }
10196 .fmt(f)
10197 }
10198}
10199
10200impl AccountSettingsRecordingAuthenticationUpdateOptionAction {
10201 pub fn is_noop(&self) -> bool {
10202 matches!(
10203 self,
10204 AccountSettingsRecordingAuthenticationUpdateOptionAction::Noop
10205 )
10206 }
10207}
10208
10209#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
10210pub struct AuthenticationOption {
10211 #[serde(default, skip_serializing_if = "Option::is_none")]
10212 pub action: Option<AccountSettingsRecordingAuthenticationUpdateOptionAction>,
10213 #[serde(
10217 default,
10218 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10219 )]
10220 pub default_option: bool,
10221 #[serde(
10225 default,
10226 skip_serializing_if = "String::is_empty",
10227 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10228 )]
10229 pub domains: String,
10230 #[serde(
10234 default,
10235 skip_serializing_if = "String::is_empty",
10236 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10237 )]
10238 pub id: String,
10239 #[serde(
10243 default,
10244 skip_serializing_if = "String::is_empty",
10245 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10246 )]
10247 pub name: String,
10248 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
10249 pub type_: Option<AccountSettingsRecordingAuthenticationUpdateOptionType>,
10250}
10251
10252#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
10255pub struct AccountSettingsRecordingAuthenticationUpdate {
10256 #[serde(default, skip_serializing_if = "Option::is_none")]
10261 pub authentication_option: Option<AuthenticationOption>,
10262 #[serde(
10267 default,
10268 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10269 )]
10270 pub recording_authentication: bool,
10271}
10272
10273#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
10275pub struct QoSPhone {
10276 #[serde(
10280 default,
10281 skip_serializing_if = "String::is_empty",
10282 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10283 )]
10284 pub avg_loss: String,
10285 #[serde(
10289 default,
10290 skip_serializing_if = "String::is_empty",
10291 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10292 )]
10293 pub bitrate: String,
10294 #[serde(
10298 default,
10299 skip_serializing_if = "String::is_empty",
10300 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10301 )]
10302 pub jitter: String,
10303 #[serde(
10307 default,
10308 skip_serializing_if = "String::is_empty",
10309 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10310 )]
10311 pub max_loss: String,
10312 #[serde(
10316 default,
10317 skip_serializing_if = "String::is_empty",
10318 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10319 )]
10320 pub mos: String,
10321 #[serde(
10325 default,
10326 skip_serializing_if = "String::is_empty",
10327 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10328 )]
10329 pub network_delay: String,
10330}
10331
10332#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
10334pub struct MeetingSecuritySettingsPasswordRequirement {
10335 #[serde(
10339 default,
10340 skip_serializing_if = "crate::utils::zero_i64",
10341 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
10342 )]
10343 pub consecutive_characters_length: i64,
10344 #[serde(
10348 default,
10349 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10350 )]
10351 pub have_letter: bool,
10352 #[serde(
10356 default,
10357 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10358 )]
10359 pub have_number: bool,
10360 #[serde(
10364 default,
10365 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10366 )]
10367 pub have_special_character: bool,
10368 #[serde(
10372 default,
10373 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10374 )]
10375 pub have_upper_and_lower_characters: bool,
10376 #[serde(
10380 default,
10381 skip_serializing_if = "crate::utils::zero_i64",
10382 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
10383 )]
10384 pub length: i64,
10385 #[serde(
10389 default,
10390 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10391 )]
10392 pub only_allow_numeric: bool,
10393 #[serde(
10397 default,
10398 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10399 )]
10400 pub weak_enhance_detection: bool,
10401}
10402
10403#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
10405pub struct WaitingRoomSettings {
10406 #[serde(
10410 default,
10411 skip_serializing_if = "crate::utils::zero_i64",
10412 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
10413 )]
10414 pub participants_to_place_in_waiting_room: i64,
10415 #[serde(
10419 default,
10420 skip_serializing_if = "crate::utils::zero_i64",
10421 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
10422 )]
10423 pub users_who_can_admit_participants_from_waiting_room: i64,
10424 #[serde(
10428 default,
10429 skip_serializing_if = "String::is_empty",
10430 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10431 )]
10432 pub whitelisted_domains_for_waiting_room: String,
10433}
10434
10435#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
10436pub struct MeetingSecurity {
10437 #[serde(
10441 default,
10442 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10443 )]
10444 pub auto_security: bool,
10445 #[serde(
10449 default,
10450 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10451 )]
10452 pub block_user_domain: bool,
10453 #[serde(
10460 default,
10461 skip_serializing_if = "Vec::is_empty",
10462 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
10463 )]
10464 pub block_user_domain_list: Vec<String>,
10465 #[serde(
10469 default,
10470 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10471 )]
10472 pub embed_password_in_join_link: bool,
10473 #[serde(default, skip_serializing_if = "Option::is_none")]
10480 pub encryption_type: Option<EncryptionType>,
10481 #[serde(
10485 default,
10486 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10487 )]
10488 pub end_to_end_encrypted_meetings: bool,
10489 #[serde(
10493 default,
10494 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10495 )]
10496 pub meeting_password: bool,
10497 #[serde(default, skip_serializing_if = "Option::is_none")]
10501 pub meeting_password_requirement: Option<MeetingSecuritySettingsPasswordRequirement>,
10502 #[serde(
10506 default,
10507 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10508 )]
10509 pub phone_password: bool,
10510 #[serde(
10514 default,
10515 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10516 )]
10517 pub pmi_password: bool,
10518 #[serde(
10522 default,
10523 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10524 )]
10525 pub require_password_for_scheduled_meeting: bool,
10526 #[serde(
10530 default,
10531 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10532 )]
10533 pub require_password_for_scheduled_webinar: bool,
10534 #[serde(
10538 default,
10539 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10540 )]
10541 pub waiting_room: bool,
10542 #[serde(default, skip_serializing_if = "Option::is_none")]
10546 pub waiting_room_settings: Option<WaitingRoomSettings>,
10547 #[serde(
10551 default,
10552 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10553 )]
10554 pub webinar_password: bool,
10555}
10556
10557#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
10558pub struct MeetingSecuritySettings {
10559 #[serde(default, skip_serializing_if = "Option::is_none")]
10560 pub meeting_security: Option<MeetingSecurity>,
10561}
10562
10563#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
10565pub struct Metrics {
10566 #[serde(
10570 default,
10571 skip_serializing_if = "Vec::is_empty",
10572 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
10573 )]
10574 pub custom_keys: Vec<CustomKeys>,
10575 #[serde(
10579 default,
10580 skip_serializing_if = "String::is_empty",
10581 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10582 )]
10583 pub dept: String,
10584 #[serde(
10588 default,
10589 skip_serializing_if = "String::is_empty",
10590 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10591 )]
10592 pub duration: String,
10593 #[serde(
10597 default,
10598 skip_serializing_if = "String::is_empty",
10599 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10600 )]
10601 pub email: String,
10602 #[serde(
10606 default,
10607 skip_serializing_if = "Option::is_none",
10608 deserialize_with = "crate::utils::date_time_format::deserialize"
10609 )]
10610 pub end_time: Option<chrono::DateTime<chrono::Utc>>,
10611 #[serde(
10615 default,
10616 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10617 )]
10618 pub has_3rd_party_audio: bool,
10619 #[serde(
10623 default,
10624 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10625 )]
10626 pub has_pstn: bool,
10627 #[serde(
10631 default,
10632 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10633 )]
10634 pub has_recording: bool,
10635 #[serde(
10639 default,
10640 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10641 )]
10642 pub has_screen_share: bool,
10643 #[serde(
10647 default,
10648 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10649 )]
10650 pub has_sip: bool,
10651 #[serde(
10655 default,
10656 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10657 )]
10658 pub has_video: bool,
10659 #[serde(
10663 default,
10664 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
10665 )]
10666 pub has_voip: bool,
10667 #[serde(
10671 default,
10672 skip_serializing_if = "String::is_empty",
10673 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10674 )]
10675 pub host: String,
10676 #[serde(
10680 default,
10681 skip_serializing_if = "crate::utils::zero_i64",
10682 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
10683 )]
10684 pub id: i64,
10685 #[serde(
10689 default,
10690 skip_serializing_if = "crate::utils::zero_i64",
10691 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
10692 )]
10693 pub in_room_participants: i64,
10694 #[serde(
10698 default,
10699 skip_serializing_if = "crate::utils::zero_i64",
10700 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
10701 )]
10702 pub participants: i64,
10703 #[serde(
10707 default,
10708 skip_serializing_if = "Option::is_none",
10709 deserialize_with = "crate::utils::date_time_format::deserialize"
10710 )]
10711 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
10712 #[serde(
10716 default,
10717 skip_serializing_if = "String::is_empty",
10718 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10719 )]
10720 pub topic: String,
10721 #[serde(
10725 default,
10726 skip_serializing_if = "Vec::is_empty",
10727 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
10728 )]
10729 pub tracking_fields: Vec<SessionUpdateTrackingFields>,
10730 #[serde(
10734 default,
10735 skip_serializing_if = "String::is_empty",
10736 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10737 )]
10738 pub user_type: String,
10739 #[serde(
10743 default,
10744 skip_serializing_if = "String::is_empty",
10745 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10746 )]
10747 pub uuid: String,
10748}
10749
10750#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
10762pub enum FileType {
10763 #[serde(rename = "CC")]
10764 Cc,
10765 #[serde(rename = "CHAT")]
10766 Chat,
10767 #[serde(rename = "CSV")]
10768 Csv,
10769 #[serde(rename = "M4A")]
10770 M4A,
10771 #[serde(rename = "MP4")]
10772 Mp4,
10773 #[serde(rename = "TRANSCRIPT")]
10774 Transcript,
10775 #[serde(rename = "")]
10776 #[default]
10777 Noop,
10778 #[serde(other)]
10779 FallthroughString,
10780}
10781
10782impl std::fmt::Display for FileType {
10783 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10784 match self {
10785 FileType::Cc => "CC",
10786 FileType::Chat => "CHAT",
10787 FileType::Csv => "CSV",
10788 FileType::M4A => "M4A",
10789 FileType::Mp4 => "MP4",
10790 FileType::Transcript => "TRANSCRIPT",
10791 FileType::Noop => "",
10792 FileType::FallthroughString => "*",
10793 }
10794 .fmt(f)
10795 }
10796}
10797
10798impl FileType {
10799 pub fn is_noop(&self) -> bool {
10800 matches!(self, FileType::Noop)
10801 }
10802}
10803
10804#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
10821pub enum RecordingType {
10822 #[serde(rename = "active_speaker")]
10823 ActiveSpeaker,
10824 #[serde(rename = "audio_only")]
10825 AudioOnly,
10826 #[serde(rename = "audio_transcript")]
10827 AudioTranscript,
10828 #[serde(rename = "chat_file")]
10829 ChatFile,
10830 #[serde(rename = "gallery_view")]
10831 GalleryView,
10832 #[serde(rename = "host_video")]
10833 HostVideo,
10834 #[serde(rename = "shared_screen")]
10835 SharedScreen,
10836 #[serde(rename = "shared_screen_with_gallery_view")]
10837 SharedScreenWithGalleryView,
10838 #[serde(rename = "shared_screen_with_speaker_view")]
10839 SharedScreenWithSpeakerView,
10840 #[serde(rename = "shared_screen_with_speaker_view(CC)")]
10841 SharedScreenWithSpeakerViewCc,
10842 #[serde(rename = "speaker_view")]
10843 SpeakerView,
10844 #[serde(rename = "")]
10845 #[default]
10846 Noop,
10847 #[serde(other)]
10848 FallthroughString,
10849}
10850
10851impl std::fmt::Display for RecordingType {
10852 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10853 match self {
10854 RecordingType::ActiveSpeaker => "active_speaker",
10855 RecordingType::AudioOnly => "audio_only",
10856 RecordingType::AudioTranscript => "audio_transcript",
10857 RecordingType::ChatFile => "chat_file",
10858 RecordingType::GalleryView => "gallery_view",
10859 RecordingType::HostVideo => "host_video",
10860 RecordingType::SharedScreen => "shared_screen",
10861 RecordingType::SharedScreenWithGalleryView => "shared_screen_with_gallery_view",
10862 RecordingType::SharedScreenWithSpeakerView => "shared_screen_with_speaker_view",
10863 RecordingType::SharedScreenWithSpeakerViewCc => "shared_screen_with_speaker_view(CC)",
10864 RecordingType::SpeakerView => "speaker_view",
10865 RecordingType::Noop => "",
10866 RecordingType::FallthroughString => "*",
10867 }
10868 .fmt(f)
10869 }
10870}
10871
10872impl RecordingType {
10873 pub fn is_noop(&self) -> bool {
10874 matches!(self, RecordingType::Noop)
10875 }
10876}
10877
10878#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
10879pub struct ArchiveFiles {
10880 #[serde(
10884 default,
10885 skip_serializing_if = "String::is_empty",
10886 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10887 )]
10888 pub download_url: String,
10889 #[serde(
10893 default,
10894 skip_serializing_if = "String::is_empty",
10895 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10896 )]
10897 pub file_extension: String,
10898 #[serde(
10902 default,
10903 skip_serializing_if = "crate::utils::zero_i64",
10904 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
10905 )]
10906 pub file_size: i64,
10907 #[serde(default, skip_serializing_if = "FileType::is_noop")]
10919 pub file_type: FileType,
10920 #[serde(
10924 default,
10925 skip_serializing_if = "String::is_empty",
10926 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10927 )]
10928 pub id: String,
10929 #[serde(default, skip_serializing_if = "RecordingType::is_noop")]
10946 pub recording_type: RecordingType,
10947 #[serde(
10951 default,
10952 skip_serializing_if = "String::is_empty",
10953 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10954 )]
10955 pub status: String,
10956}
10957
10958#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
10959pub struct CloudArchivedFiles {
10960 #[serde(
10964 default,
10965 skip_serializing_if = "Vec::is_empty",
10966 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
10967 )]
10968 pub archive_files: Vec<ArchiveFiles>,
10969 #[serde(
10973 default,
10974 skip_serializing_if = "crate::utils::zero_i64",
10975 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
10976 )]
10977 pub duration: i64,
10978 #[serde(
10982 default,
10983 skip_serializing_if = "String::is_empty",
10984 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
10985 )]
10986 pub host_id: String,
10987 #[serde(
10991 default,
10992 skip_serializing_if = "crate::utils::zero_i64",
10993 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
10994 )]
10995 pub id: i64,
10996 #[serde(
11000 default,
11001 skip_serializing_if = "crate::utils::zero_i64",
11002 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
11003 )]
11004 pub recording_count: i64,
11005 #[serde(
11009 default,
11010 skip_serializing_if = "Option::is_none",
11011 deserialize_with = "crate::utils::date_time_format::deserialize"
11012 )]
11013 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
11014 #[serde(
11018 default,
11019 skip_serializing_if = "String::is_empty",
11020 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11021 )]
11022 pub timezone: String,
11023 #[serde(
11027 default,
11028 skip_serializing_if = "String::is_empty",
11029 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11030 )]
11031 pub topic: String,
11032 #[serde(
11036 default,
11037 skip_serializing_if = "crate::utils::zero_i64",
11038 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
11039 )]
11040 pub total_size: i64,
11041 #[serde(
11045 default,
11046 skip_serializing_if = "crate::utils::zero_i64",
11047 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
11048 rename = "type"
11049 )]
11050 pub type_: i64,
11051 #[serde(
11055 default,
11056 skip_serializing_if = "String::is_empty",
11057 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11058 )]
11059 pub uuid: String,
11060}
11061
11062#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
11063pub struct Attendees {
11064 #[serde(
11068 default,
11069 skip_serializing_if = "String::is_empty",
11070 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11071 )]
11072 pub name: String,
11073}
11074
11075#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
11077pub struct InviteLink {
11078 #[serde(
11082 default,
11083 skip_serializing_if = "Vec::is_empty",
11084 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
11085 )]
11086 pub attendees: Vec<Attendees>,
11087 #[serde(
11091 default,
11092 skip_serializing_if = "crate::utils::zero_i64",
11093 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
11094 )]
11095 pub ttl: i64,
11096}
11097
11098#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
11099pub struct InviteLinksAttendees {
11100 #[serde(
11104 default,
11105 skip_serializing_if = "String::is_empty",
11106 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11107 )]
11108 pub join_url: String,
11109 #[serde(
11113 default,
11114 skip_serializing_if = "String::is_empty",
11115 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11116 )]
11117 pub name: String,
11118}
11119
11120#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
11122pub struct InviteLinks {
11123 #[serde(
11127 default,
11128 skip_serializing_if = "Vec::is_empty",
11129 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
11130 )]
11131 pub attendees: Vec<InviteLinksAttendees>,
11132}
11133
11134#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
11135pub enum RecordingStatusUpdateBodyRequestAction {
11136 #[serde(rename = "recover")]
11137 Recover,
11138 #[serde(rename = "")]
11139 #[default]
11140 Noop,
11141 #[serde(other)]
11142 FallthroughString,
11143}
11144
11145impl std::fmt::Display for RecordingStatusUpdateBodyRequestAction {
11146 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11147 match self {
11148 RecordingStatusUpdateBodyRequestAction::Recover => "recover",
11149 RecordingStatusUpdateBodyRequestAction::Noop => "",
11150 RecordingStatusUpdateBodyRequestAction::FallthroughString => "*",
11151 }
11152 .fmt(f)
11153 }
11154}
11155
11156impl RecordingStatusUpdateBodyRequestAction {
11157 pub fn is_noop(&self) -> bool {
11158 matches!(self, RecordingStatusUpdateBodyRequestAction::Noop)
11159 }
11160}
11161
11162#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
11163pub struct RecordingStatusUpdateBodyRequest {
11164 #[serde(default, skip_serializing_if = "Option::is_none")]
11165 pub action: Option<RecordingStatusUpdateBodyRequestAction>,
11166}
11167
11168#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
11169pub struct UploadVbRequest {
11170 #[serde(
11174 default,
11175 skip_serializing_if = "String::is_empty",
11176 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11177 )]
11178 pub file: String,
11179}
11180
11181#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
11183pub struct EmergencyAddress {
11184 #[serde(
11188 default,
11189 skip_serializing_if = "String::is_empty",
11190 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
11191 rename = "address_line1"
11192 )]
11193 pub address_line_1: String,
11194 #[serde(
11198 default,
11199 skip_serializing_if = "String::is_empty",
11200 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
11201 rename = "address_line2"
11202 )]
11203 pub address_line_2: String,
11204 #[serde(
11208 default,
11209 skip_serializing_if = "String::is_empty",
11210 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11211 )]
11212 pub city: String,
11213 #[serde(
11217 default,
11218 skip_serializing_if = "String::is_empty",
11219 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11220 )]
11221 pub country: String,
11222 #[serde(
11226 default,
11227 skip_serializing_if = "String::is_empty",
11228 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11229 )]
11230 pub state_code: String,
11231 #[serde(
11235 default,
11236 skip_serializing_if = "String::is_empty",
11237 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11238 )]
11239 pub zip: String,
11240}
11241
11242#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
11243pub struct SetUpAccountRequest {
11244 pub emergency_address: EmergencyAddress,
11248 #[serde(
11252 default,
11253 skip_serializing_if = "String::is_empty",
11254 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11255 )]
11256 pub extension_number: String,
11257}
11258
11259#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
11267pub enum ListAccountPhoneNumbersType {
11268 #[serde(rename = "all")]
11269 All,
11270 #[serde(rename = "assigned")]
11271 Assigned,
11272 #[serde(rename = "unassigned")]
11273 Unassigned,
11274 #[serde(rename = "")]
11275 #[default]
11276 Noop,
11277 #[serde(other)]
11278 FallthroughString,
11279}
11280
11281impl std::fmt::Display for ListAccountPhoneNumbersType {
11282 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11283 match self {
11284 ListAccountPhoneNumbersType::All => "all",
11285 ListAccountPhoneNumbersType::Assigned => "assigned",
11286 ListAccountPhoneNumbersType::Unassigned => "unassigned",
11287 ListAccountPhoneNumbersType::Noop => "",
11288 ListAccountPhoneNumbersType::FallthroughString => "*",
11289 }
11290 .fmt(f)
11291 }
11292}
11293
11294impl ListAccountPhoneNumbersType {
11295 pub fn is_noop(&self) -> bool {
11296 matches!(self, ListAccountPhoneNumbersType::Noop)
11297 }
11298}
11299
11300#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
11306pub enum ExtensionType {
11307 #[serde(rename = "autoReceptionist")]
11308 AutoReceptionist,
11309 #[serde(rename = "callQueue")]
11310 CallQueue,
11311 #[serde(rename = "commonAreaPhone")]
11312 CommonAreaPhone,
11313 #[serde(rename = "user")]
11314 User,
11315 #[serde(rename = "")]
11316 #[default]
11317 Noop,
11318 #[serde(other)]
11319 FallthroughString,
11320}
11321
11322impl std::fmt::Display for ExtensionType {
11323 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11324 match self {
11325 ExtensionType::AutoReceptionist => "autoReceptionist",
11326 ExtensionType::CallQueue => "callQueue",
11327 ExtensionType::CommonAreaPhone => "commonAreaPhone",
11328 ExtensionType::User => "user",
11329 ExtensionType::Noop => "",
11330 ExtensionType::FallthroughString => "*",
11331 }
11332 .fmt(f)
11333 }
11334}
11335
11336impl ExtensionType {
11337 pub fn is_noop(&self) -> bool {
11338 matches!(self, ExtensionType::Noop)
11339 }
11340}
11341
11342#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
11346pub enum Source {
11347 #[serde(rename = "external")]
11348 External,
11349 #[serde(rename = "internal")]
11350 Internal,
11351 #[serde(rename = "")]
11352 #[default]
11353 Noop,
11354 #[serde(other)]
11355 FallthroughString,
11356}
11357
11358impl std::fmt::Display for Source {
11359 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11360 match self {
11361 Source::External => "external",
11362 Source::Internal => "internal",
11363 Source::Noop => "",
11364 Source::FallthroughString => "*",
11365 }
11366 .fmt(f)
11367 }
11368}
11369
11370impl Source {
11371 pub fn is_noop(&self) -> bool {
11372 matches!(self, Source::Noop)
11373 }
11374}
11375
11376#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
11380pub enum ListAccountPhoneNumbersResponseStatus {
11381 #[serde(rename = "available")]
11382 Available,
11383 #[serde(rename = "pending")]
11384 Pending,
11385 #[serde(rename = "")]
11386 #[default]
11387 Noop,
11388 #[serde(other)]
11389 FallthroughString,
11390}
11391
11392impl std::fmt::Display for ListAccountPhoneNumbersResponseStatus {
11393 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11394 match self {
11395 ListAccountPhoneNumbersResponseStatus::Available => "available",
11396 ListAccountPhoneNumbersResponseStatus::Pending => "pending",
11397 ListAccountPhoneNumbersResponseStatus::Noop => "",
11398 ListAccountPhoneNumbersResponseStatus::FallthroughString => "*",
11399 }
11400 .fmt(f)
11401 }
11402}
11403
11404impl ListAccountPhoneNumbersResponseStatus {
11405 pub fn is_noop(&self) -> bool {
11406 matches!(self, ListAccountPhoneNumbersResponseStatus::Noop)
11407 }
11408}
11409
11410#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
11411pub struct Assignee {
11412 #[serde(
11416 default,
11417 skip_serializing_if = "crate::utils::zero_i64",
11418 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
11419 )]
11420 pub extension_number: i64,
11421 #[serde(
11425 default,
11426 skip_serializing_if = "String::is_empty",
11427 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11428 )]
11429 pub id: String,
11430 #[serde(
11434 default,
11435 skip_serializing_if = "String::is_empty",
11436 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11437 )]
11438 pub name: String,
11439 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
11445 pub type_: Option<ExtensionType>,
11446}
11447
11448#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
11449pub struct Site {
11450 #[serde(
11454 default,
11455 skip_serializing_if = "String::is_empty",
11456 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11457 )]
11458 pub id: String,
11459 #[serde(
11463 default,
11464 skip_serializing_if = "String::is_empty",
11465 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11466 )]
11467 pub name: String,
11468}
11469
11470#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
11472pub struct Carrier {
11473 #[serde(
11477 default,
11478 skip_serializing_if = "String::is_empty",
11479 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11480 )]
11481 pub code: String,
11482 #[serde(
11486 default,
11487 skip_serializing_if = "String::is_empty",
11488 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11489 )]
11490 pub name: String,
11491}
11492
11493#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
11495pub struct SipGroup {
11496 #[serde(
11500 default,
11501 skip_serializing_if = "String::is_empty",
11502 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11503 )]
11504 pub display_name: String,
11505 #[serde(
11509 default,
11510 skip_serializing_if = "String::is_empty",
11511 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11512 )]
11513 pub id: String,
11514}
11515
11516#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
11517pub struct ListAccountPhoneNumbersResponse {
11518 #[serde(default, skip_serializing_if = "Option::is_none")]
11519 pub assignee: Option<Assignee>,
11520 #[serde(
11527 default,
11528 skip_serializing_if = "Vec::is_empty",
11529 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
11530 )]
11531 pub capability: Vec<String>,
11532 #[serde(default, skip_serializing_if = "Option::is_none")]
11536 pub carrier: Option<Carrier>,
11537 #[serde(
11541 default,
11542 skip_serializing_if = "String::is_empty",
11543 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11544 )]
11545 pub display_name: String,
11546 #[serde(
11550 default,
11551 skip_serializing_if = "String::is_empty",
11552 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11553 )]
11554 pub id: String,
11555 #[serde(
11559 default,
11560 skip_serializing_if = "String::is_empty",
11561 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11562 )]
11563 pub location: String,
11564 #[serde(
11568 default,
11569 skip_serializing_if = "String::is_empty",
11570 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11571 )]
11572 pub number: String,
11573 #[serde(default, skip_serializing_if = "Option::is_none")]
11577 pub number_type: Option<Type>,
11578 #[serde(default, skip_serializing_if = "Option::is_none")]
11582 pub sip_group: Option<SipGroup>,
11583 #[serde(default, skip_serializing_if = "Option::is_none")]
11584 pub site: Option<Site>,
11585 #[serde(default, skip_serializing_if = "Option::is_none")]
11589 pub source: Option<Source>,
11590 #[serde(default, skip_serializing_if = "Option::is_none")]
11594 pub status: Option<ListAccountPhoneNumbersResponseStatus>,
11595}
11596
11597#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
11598pub struct ListAccountPhoneNumbersResponseData {
11599 #[serde(
11603 default,
11604 skip_serializing_if = "String::is_empty",
11605 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11606 )]
11607 pub next_page_token: String,
11608 #[serde(
11612 default,
11613 skip_serializing_if = "crate::utils::zero_i64",
11614 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
11615 )]
11616 pub page_size: i64,
11617 #[serde(
11618 default,
11619 skip_serializing_if = "Vec::is_empty",
11620 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
11621 )]
11622 pub phone_numbers: Vec<ListAccountPhoneNumbersResponse>,
11623 #[serde(
11627 default,
11628 skip_serializing_if = "crate::utils::zero_i64",
11629 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
11630 )]
11631 pub total_records: i64,
11632}
11633
11634#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
11638pub enum TransportProtocol {
11639 #[serde(rename = "AUTO")]
11640 Auto,
11641 #[serde(rename = "TCP")]
11642 Tcp,
11643 #[serde(rename = "TLS")]
11644 Tls,
11645 #[serde(rename = "UDP")]
11646 Udp,
11647 #[serde(rename = "")]
11648 #[default]
11649 Noop,
11650 #[serde(other)]
11651 FallthroughString,
11652}
11653
11654impl std::fmt::Display for TransportProtocol {
11655 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11656 match self {
11657 TransportProtocol::Auto => "AUTO",
11658 TransportProtocol::Tcp => "TCP",
11659 TransportProtocol::Tls => "TLS",
11660 TransportProtocol::Udp => "UDP",
11661 TransportProtocol::Noop => "",
11662 TransportProtocol::FallthroughString => "*",
11663 }
11664 .fmt(f)
11665 }
11666}
11667
11668impl TransportProtocol {
11669 pub fn is_noop(&self) -> bool {
11670 matches!(self, TransportProtocol::Noop)
11671 }
11672}
11673
11674#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
11675pub struct Phones {
11676 #[serde(
11680 default,
11681 skip_serializing_if = "String::is_empty",
11682 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11683 )]
11684 pub authorization_name: String,
11685 #[serde(
11689 default,
11690 skip_serializing_if = "String::is_empty",
11691 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11692 )]
11693 pub domain: String,
11694 #[serde(
11698 default,
11699 skip_serializing_if = "String::is_empty",
11700 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11701 )]
11702 pub id: String,
11703 #[serde(
11707 default,
11708 skip_serializing_if = "String::is_empty",
11709 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11710 )]
11711 pub password: String,
11712 #[serde(
11716 default,
11717 skip_serializing_if = "String::is_empty",
11718 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11719 )]
11720 pub proxy_server: String,
11721 #[serde(
11725 default,
11726 skip_serializing_if = "String::is_empty",
11727 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
11728 rename = "proxy_server2"
11729 )]
11730 pub proxy_server_2: String,
11731 #[serde(
11735 default,
11736 skip_serializing_if = "String::is_empty",
11737 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
11738 rename = "proxy_server3"
11739 )]
11740 pub proxy_server_3: String,
11741 #[serde(
11745 default,
11746 skip_serializing_if = "String::is_empty",
11747 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11748 )]
11749 pub register_server: String,
11750 #[serde(
11754 default,
11755 skip_serializing_if = "String::is_empty",
11756 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
11757 rename = "register_server2"
11758 )]
11759 pub register_server_2: String,
11760 #[serde(
11764 default,
11765 skip_serializing_if = "String::is_empty",
11766 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
11767 rename = "register_server3"
11768 )]
11769 pub register_server_3: String,
11770 #[serde(
11774 default,
11775 skip_serializing_if = "crate::utils::zero_i64",
11776 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
11777 )]
11778 pub registration_expire_time: i64,
11779 #[serde(default, skip_serializing_if = "Option::is_none")]
11783 pub transport_protocol: Option<TransportProtocol>,
11784 #[serde(
11788 default,
11789 skip_serializing_if = "Option::is_none",
11790 rename = "transport_protocol2"
11791 )]
11792 pub transport_protocol_2: Option<TransportProtocol>,
11793 #[serde(
11797 default,
11798 skip_serializing_if = "Option::is_none",
11799 rename = "transport_protocol3"
11800 )]
11801 pub transport_protocol_3: Option<TransportProtocol>,
11802 #[serde(
11806 default,
11807 skip_serializing_if = "String::is_empty",
11808 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11809 )]
11810 pub user_email: String,
11811 #[serde(
11815 default,
11816 skip_serializing_if = "String::is_empty",
11817 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11818 )]
11819 pub user_name: String,
11820 #[serde(
11824 default,
11825 skip_serializing_if = "String::is_empty",
11826 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11827 )]
11828 pub voice_mail: String,
11829}
11830
11831#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
11832pub struct ListSipPhonesResponse {
11833 #[serde(
11837 default,
11838 skip_serializing_if = "String::is_empty",
11839 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11840 )]
11841 pub next_page_token: String,
11842 #[serde(
11846 default,
11847 skip_serializing_if = "crate::utils::zero_i64",
11848 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
11849 )]
11850 pub page_count: i64,
11851 #[serde(
11855 default,
11856 skip_serializing_if = "crate::utils::zero_i64",
11857 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
11858 )]
11859 pub page_number: i64,
11860 #[serde(
11864 default,
11865 skip_serializing_if = "crate::utils::zero_i64",
11866 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
11867 )]
11868 pub page_size: i64,
11869 #[serde(
11873 default,
11874 skip_serializing_if = "Vec::is_empty",
11875 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
11876 )]
11877 pub phones: Vec<Phones>,
11878 #[serde(
11882 default,
11883 skip_serializing_if = "crate::utils::zero_i64",
11884 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
11885 )]
11886 pub total_records: i64,
11887}
11888
11889#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
11890pub struct CreateSipPhoneRequest {
11891 #[serde(
11895 default,
11896 skip_serializing_if = "String::is_empty",
11897 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11898 )]
11899 pub authorization_name: String,
11900 #[serde(
11904 default,
11905 skip_serializing_if = "String::is_empty",
11906 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11907 )]
11908 pub domain: String,
11909 #[serde(
11913 default,
11914 skip_serializing_if = "String::is_empty",
11915 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11916 )]
11917 pub password: String,
11918 #[serde(
11922 default,
11923 skip_serializing_if = "String::is_empty",
11924 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11925 )]
11926 pub proxy_server: String,
11927 #[serde(
11931 default,
11932 skip_serializing_if = "String::is_empty",
11933 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
11934 rename = "proxy_server2"
11935 )]
11936 pub proxy_server_2: String,
11937 #[serde(
11941 default,
11942 skip_serializing_if = "String::is_empty",
11943 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
11944 rename = "proxy_server3"
11945 )]
11946 pub proxy_server_3: String,
11947 #[serde(
11951 default,
11952 skip_serializing_if = "String::is_empty",
11953 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
11954 )]
11955 pub register_server: String,
11956 #[serde(
11960 default,
11961 skip_serializing_if = "String::is_empty",
11962 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
11963 rename = "register_server2"
11964 )]
11965 pub register_server_2: String,
11966 #[serde(
11970 default,
11971 skip_serializing_if = "String::is_empty",
11972 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
11973 rename = "register_server3"
11974 )]
11975 pub register_server_3: String,
11976 #[serde(
11980 default,
11981 skip_serializing_if = "crate::utils::zero_i64",
11982 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
11983 )]
11984 pub registration_expire_time: i64,
11985 #[serde(default, skip_serializing_if = "Option::is_none")]
11989 pub transport_protocol: Option<TransportProtocol>,
11990 #[serde(
11994 default,
11995 skip_serializing_if = "Option::is_none",
11996 rename = "transport_protocol2"
11997 )]
11998 pub transport_protocol_2: Option<TransportProtocol>,
11999 #[serde(
12003 default,
12004 skip_serializing_if = "Option::is_none",
12005 rename = "transport_protocol3"
12006 )]
12007 pub transport_protocol_3: Option<TransportProtocol>,
12008 #[serde(
12012 default,
12013 skip_serializing_if = "String::is_empty",
12014 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12015 )]
12016 pub user_email: String,
12017 #[serde(
12021 default,
12022 skip_serializing_if = "String::is_empty",
12023 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12024 )]
12025 pub user_name: String,
12026 #[serde(
12030 default,
12031 skip_serializing_if = "String::is_empty",
12032 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12033 )]
12034 pub voice_mail: String,
12035}
12036
12037#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
12038pub struct UpdateSipPhoneRequest {
12039 #[serde(
12043 default,
12044 skip_serializing_if = "String::is_empty",
12045 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12046 )]
12047 pub authorization_name: String,
12048 #[serde(
12052 default,
12053 skip_serializing_if = "String::is_empty",
12054 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12055 )]
12056 pub domain: String,
12057 #[serde(
12061 default,
12062 skip_serializing_if = "String::is_empty",
12063 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12064 )]
12065 pub password: String,
12066 #[serde(
12070 default,
12071 skip_serializing_if = "String::is_empty",
12072 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12073 )]
12074 pub proxy_server: String,
12075 #[serde(
12079 default,
12080 skip_serializing_if = "String::is_empty",
12081 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
12082 rename = "proxy_server2"
12083 )]
12084 pub proxy_server_2: String,
12085 #[serde(
12089 default,
12090 skip_serializing_if = "String::is_empty",
12091 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
12092 rename = "proxy_server3"
12093 )]
12094 pub proxy_server_3: String,
12095 #[serde(
12099 default,
12100 skip_serializing_if = "String::is_empty",
12101 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12102 )]
12103 pub register_server: String,
12104 #[serde(
12108 default,
12109 skip_serializing_if = "String::is_empty",
12110 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
12111 rename = "register_server2"
12112 )]
12113 pub register_server_2: String,
12114 #[serde(
12118 default,
12119 skip_serializing_if = "String::is_empty",
12120 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
12121 rename = "register_server3"
12122 )]
12123 pub register_server_3: String,
12124 #[serde(
12128 default,
12129 skip_serializing_if = "crate::utils::zero_i64",
12130 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
12131 )]
12132 pub registration_expire_time: i64,
12133 #[serde(default, skip_serializing_if = "Option::is_none")]
12137 pub transport_protocol: Option<TransportProtocol>,
12138 #[serde(
12142 default,
12143 skip_serializing_if = "Option::is_none",
12144 rename = "transport_protocol2"
12145 )]
12146 pub transport_protocol_2: Option<TransportProtocol>,
12147 #[serde(
12151 default,
12152 skip_serializing_if = "Option::is_none",
12153 rename = "transport_protocol3"
12154 )]
12155 pub transport_protocol_3: Option<TransportProtocol>,
12156 #[serde(
12160 default,
12161 skip_serializing_if = "String::is_empty",
12162 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12163 )]
12164 pub user_name: String,
12165 #[serde(
12169 default,
12170 skip_serializing_if = "String::is_empty",
12171 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12172 )]
12173 pub voice_mail: String,
12174}
12175
12176#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
12180pub enum ListZoomRoomsStatus {
12181 #[serde(rename = "Available")]
12182 Available,
12183 #[serde(rename = "InMeeting")]
12184 InMeeting,
12185 #[serde(rename = "Offline")]
12186 Offline,
12187 #[serde(rename = "UnderConstruction")]
12188 UnderConstruction,
12189 #[serde(rename = "")]
12190 #[default]
12191 Noop,
12192 #[serde(other)]
12193 FallthroughString,
12194}
12195
12196impl std::fmt::Display for ListZoomRoomsStatus {
12197 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12198 match self {
12199 ListZoomRoomsStatus::Available => "Available",
12200 ListZoomRoomsStatus::InMeeting => "InMeeting",
12201 ListZoomRoomsStatus::Offline => "Offline",
12202 ListZoomRoomsStatus::UnderConstruction => "UnderConstruction",
12203 ListZoomRoomsStatus::Noop => "",
12204 ListZoomRoomsStatus::FallthroughString => "*",
12205 }
12206 .fmt(f)
12207 }
12208}
12209
12210impl ListZoomRoomsStatus {
12211 pub fn is_noop(&self) -> bool {
12212 matches!(self, ListZoomRoomsStatus::Noop)
12213 }
12214}
12215
12216#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
12220pub enum ListZoomRoomsType {
12221 #[serde(rename = "DigitalSignageOnly")]
12222 DigitalSignageOnly,
12223 #[serde(rename = "SchedulingDisplayOnly")]
12224 SchedulingDisplayOnly,
12225 #[serde(rename = "ZoomRoom")]
12226 ZoomRoom,
12227 #[serde(rename = "")]
12228 #[default]
12229 Noop,
12230 #[serde(other)]
12231 FallthroughString,
12232}
12233
12234impl std::fmt::Display for ListZoomRoomsType {
12235 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12236 match self {
12237 ListZoomRoomsType::DigitalSignageOnly => "DigitalSignageOnly",
12238 ListZoomRoomsType::SchedulingDisplayOnly => "SchedulingDisplayOnly",
12239 ListZoomRoomsType::ZoomRoom => "ZoomRoom",
12240 ListZoomRoomsType::Noop => "",
12241 ListZoomRoomsType::FallthroughString => "*",
12242 }
12243 .fmt(f)
12244 }
12245}
12246
12247impl ListZoomRoomsType {
12248 pub fn is_noop(&self) -> bool {
12249 matches!(self, ListZoomRoomsType::Noop)
12250 }
12251}
12252
12253#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
12254pub struct ListZoomRoomsResponse {
12255 #[serde(
12259 default,
12260 skip_serializing_if = "String::is_empty",
12261 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12262 )]
12263 pub activation_code: String,
12264 #[serde(
12268 default,
12269 skip_serializing_if = "String::is_empty",
12270 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12271 )]
12272 pub id: String,
12273 #[serde(
12277 default,
12278 skip_serializing_if = "String::is_empty",
12279 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12280 )]
12281 pub location_id: String,
12282 #[serde(
12286 default,
12287 skip_serializing_if = "String::is_empty",
12288 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12289 )]
12290 pub name: String,
12291 #[serde(
12295 default,
12296 skip_serializing_if = "String::is_empty",
12297 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12298 )]
12299 pub room_id: String,
12300 #[serde(default, skip_serializing_if = "Option::is_none")]
12304 pub status: Option<ListZoomRoomsStatus>,
12305}
12306
12307#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
12308pub struct ListZoomRoomsResponseData {
12309 #[serde(
12313 default,
12314 skip_serializing_if = "String::is_empty",
12315 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12316 )]
12317 pub next_page_token: String,
12318 #[serde(
12322 default,
12323 skip_serializing_if = "crate::utils::zero_i64",
12324 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
12325 )]
12326 pub page_size: i64,
12327 #[serde(
12331 default,
12332 skip_serializing_if = "Vec::is_empty",
12333 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
12334 )]
12335 pub rooms: Vec<ListZoomRoomsResponse>,
12336}
12337
12338#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
12339pub struct AddRoomRequest {
12340 #[serde(
12344 default,
12345 skip_serializing_if = "String::is_empty",
12346 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12347 )]
12348 pub location_id: String,
12349 #[serde(
12353 default,
12354 skip_serializing_if = "String::is_empty",
12355 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12356 )]
12357 pub name: String,
12358 #[serde(
12362 default,
12363 skip_serializing_if = "ListZoomRoomsType::is_noop",
12364 rename = "type"
12365 )]
12366 pub type_: ListZoomRoomsType,
12367}
12368
12369#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
12370pub struct AddRoomResponse {
12371 #[serde(
12375 default,
12376 skip_serializing_if = "String::is_empty",
12377 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12378 )]
12379 pub id: String,
12380 #[serde(
12384 default,
12385 skip_serializing_if = "String::is_empty",
12386 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12387 )]
12388 pub location_id: String,
12389 #[serde(
12393 default,
12394 skip_serializing_if = "String::is_empty",
12395 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12396 )]
12397 pub name: String,
12398 #[serde(
12402 default,
12403 skip_serializing_if = "String::is_empty",
12404 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12405 )]
12406 pub room_id: String,
12407 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
12411 pub type_: Option<ListZoomRoomsType>,
12412}
12413
12414#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
12416pub struct MainAutoReceptionist {
12417 #[serde(
12421 default,
12422 skip_serializing_if = "String::is_empty",
12423 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12424 )]
12425 pub extension_id: String,
12426 #[serde(
12430 default,
12431 skip_serializing_if = "String::is_empty",
12432 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12433 )]
12434 pub extension_number: String,
12435 #[serde(
12439 default,
12440 skip_serializing_if = "String::is_empty",
12441 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12442 )]
12443 pub id: String,
12444 #[serde(
12448 default,
12449 skip_serializing_if = "String::is_empty",
12450 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12451 )]
12452 pub name: String,
12453}
12454
12455#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
12457pub struct Country {
12458 #[serde(
12462 default,
12463 skip_serializing_if = "String::is_empty",
12464 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12465 )]
12466 pub code: String,
12467 #[serde(
12471 default,
12472 skip_serializing_if = "String::is_empty",
12473 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12474 )]
12475 pub name: String,
12476}
12477
12478#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
12479pub struct Sites {
12480 #[serde(default, skip_serializing_if = "Option::is_none")]
12484 pub country: Option<Country>,
12485 #[serde(
12489 default,
12490 skip_serializing_if = "String::is_empty",
12491 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12492 )]
12493 pub id: String,
12494 #[serde(default, skip_serializing_if = "Option::is_none")]
12498 pub main_auto_receptionist: Option<MainAutoReceptionist>,
12499 #[serde(
12503 default,
12504 skip_serializing_if = "String::is_empty",
12505 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12506 )]
12507 pub name: String,
12508 #[serde(
12512 default,
12513 skip_serializing_if = "String::is_empty",
12514 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12515 )]
12516 pub site_code: String,
12517}
12518
12519#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
12520pub struct ListPhoneSitesResponse {
12521 #[serde(
12525 default,
12526 skip_serializing_if = "String::is_empty",
12527 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12528 )]
12529 pub next_page_token: String,
12530 #[serde(
12534 default,
12535 skip_serializing_if = "String::is_empty",
12536 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12537 )]
12538 pub page_size: String,
12539 #[serde(
12543 default,
12544 skip_serializing_if = "Vec::is_empty",
12545 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
12546 )]
12547 pub sites: Vec<Sites>,
12548 #[serde(
12552 default,
12553 skip_serializing_if = "String::is_empty",
12554 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12555 )]
12556 pub total_records: String,
12557}
12558
12559#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
12560pub struct DefaultEmergencyAddress {
12561 #[serde(
12565 default,
12566 skip_serializing_if = "String::is_empty",
12567 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
12568 rename = "address_line1"
12569 )]
12570 pub address_line_1: String,
12571 #[serde(
12575 default,
12576 skip_serializing_if = "String::is_empty",
12577 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
12578 rename = "address_line2"
12579 )]
12580 pub address_line_2: String,
12581 #[serde(
12585 default,
12586 skip_serializing_if = "String::is_empty",
12587 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12588 )]
12589 pub city: String,
12590 #[serde(
12594 default,
12595 skip_serializing_if = "String::is_empty",
12596 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12597 )]
12598 pub country: String,
12599 #[serde(
12603 default,
12604 skip_serializing_if = "String::is_empty",
12605 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12606 )]
12607 pub state_code: String,
12608 #[serde(
12612 default,
12613 skip_serializing_if = "String::is_empty",
12614 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12615 )]
12616 pub zip: String,
12617}
12618
12619#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
12621pub struct ShortExtension {
12622 #[serde(
12626 default,
12627 skip_serializing_if = "crate::utils::zero_i64",
12628 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
12629 )]
12630 pub length: i64,
12631}
12632
12633#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
12634pub struct CreatePhoneSiteRequest {
12635 #[serde(
12639 default,
12640 skip_serializing_if = "String::is_empty",
12641 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12642 )]
12643 pub auto_receptionist_name: String,
12644 #[serde(default, skip_serializing_if = "Option::is_none")]
12645 pub default_emergency_address: Option<DefaultEmergencyAddress>,
12646 #[serde(
12650 default,
12651 skip_serializing_if = "String::is_empty",
12652 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12653 )]
12654 pub name: String,
12655 #[serde(default, skip_serializing_if = "Option::is_none")]
12659 pub short_extension: Option<ShortExtension>,
12660 #[serde(
12664 default,
12665 skip_serializing_if = "crate::utils::zero_i64",
12666 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
12667 )]
12668 pub site_code: i64,
12669}
12670
12671#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
12673pub struct GetSiteResponseMainAutoReceptionist {
12674 #[serde(
12678 default,
12679 skip_serializing_if = "String::is_empty",
12680 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12681 )]
12682 pub extension_id: String,
12683 #[serde(
12687 default,
12688 skip_serializing_if = "crate::utils::zero_i64",
12689 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
12690 )]
12691 pub extension_number: i64,
12692 #[serde(
12696 default,
12697 skip_serializing_if = "String::is_empty",
12698 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12699 )]
12700 pub id: String,
12701 #[serde(
12705 default,
12706 skip_serializing_if = "String::is_empty",
12707 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12708 )]
12709 pub name: String,
12710}
12711
12712#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
12713pub struct GetSiteResponse {
12714 #[serde(default, skip_serializing_if = "Option::is_none")]
12718 pub country: Option<Country>,
12719 #[serde(
12723 default,
12724 skip_serializing_if = "String::is_empty",
12725 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12726 )]
12727 pub id: String,
12728 #[serde(default, skip_serializing_if = "Option::is_none")]
12732 pub main_auto_receptionist: Option<GetSiteResponseMainAutoReceptionist>,
12733 #[serde(
12737 default,
12738 skip_serializing_if = "String::is_empty",
12739 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12740 )]
12741 pub name: String,
12742 #[serde(default, skip_serializing_if = "Option::is_none")]
12746 pub short_extension: Option<ShortExtension>,
12747 #[serde(
12751 default,
12752 skip_serializing_if = "crate::utils::zero_i64",
12753 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
12754 )]
12755 pub site_code: i64,
12756}
12757
12758#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
12759pub struct UpdateSiteDetailsRequest {
12760 #[serde(
12764 default,
12765 skip_serializing_if = "String::is_empty",
12766 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12767 )]
12768 pub name: String,
12769 #[serde(
12773 default,
12774 skip_serializing_if = "crate::utils::zero_i64",
12775 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
12776 )]
12777 pub site_code: i64,
12778}
12779
12780#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
12785pub enum PresenceStatus {
12786 #[serde(rename = "Available")]
12787 Available,
12788 #[serde(rename = "Away")]
12789 Away,
12790 #[serde(rename = "Do_Not_Disturb")]
12791 DoNotDisturb,
12792 #[serde(rename = "Offline")]
12793 Offline,
12794 #[serde(rename = "")]
12795 #[default]
12796 Noop,
12797 #[serde(other)]
12798 FallthroughString,
12799}
12800
12801impl std::fmt::Display for PresenceStatus {
12802 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12803 match self {
12804 PresenceStatus::Available => "Available",
12805 PresenceStatus::Away => "Away",
12806 PresenceStatus::DoNotDisturb => "Do_Not_Disturb",
12807 PresenceStatus::Offline => "Offline",
12808 PresenceStatus::Noop => "",
12809 PresenceStatus::FallthroughString => "*",
12810 }
12811 .fmt(f)
12812 }
12813}
12814
12815impl PresenceStatus {
12816 pub fn is_noop(&self) -> bool {
12817 matches!(self, PresenceStatus::Noop)
12818 }
12819}
12820
12821#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
12822pub struct Contacts {
12823 #[serde(
12827 default,
12828 skip_serializing_if = "String::is_empty",
12829 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12830 )]
12831 pub dept: String,
12832 #[serde(
12839 default,
12840 skip_serializing_if = "Vec::is_empty",
12841 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
12842 )]
12843 pub direct_numbers: Vec<String>,
12844 #[serde(
12848 default,
12849 skip_serializing_if = "String::is_empty",
12850 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12851 )]
12852 pub email: String,
12853 #[serde(
12857 default,
12858 skip_serializing_if = "String::is_empty",
12859 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12860 )]
12861 pub extension_number: String,
12862 #[serde(
12866 default,
12867 skip_serializing_if = "String::is_empty",
12868 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12869 )]
12870 pub first_name: String,
12871 #[serde(
12875 default,
12876 skip_serializing_if = "String::is_empty",
12877 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12878 )]
12879 pub id: String,
12880 #[serde(
12884 default,
12885 skip_serializing_if = "String::is_empty",
12886 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12887 )]
12888 pub im_group_id: String,
12889 #[serde(
12893 default,
12894 skip_serializing_if = "String::is_empty",
12895 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12896 )]
12897 pub im_group_name: String,
12898 #[serde(
12902 default,
12903 skip_serializing_if = "String::is_empty",
12904 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12905 )]
12906 pub job_title: String,
12907 #[serde(
12911 default,
12912 skip_serializing_if = "String::is_empty",
12913 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12914 )]
12915 pub last_name: String,
12916 #[serde(
12920 default,
12921 skip_serializing_if = "String::is_empty",
12922 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12923 )]
12924 pub location: String,
12925 #[serde(
12929 default,
12930 skip_serializing_if = "String::is_empty",
12931 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12932 )]
12933 pub phone_number: String,
12934 #[serde(default, skip_serializing_if = "Option::is_none")]
12939 pub presence_status: Option<PresenceStatus>,
12940 #[serde(
12944 default,
12945 skip_serializing_if = "String::is_empty",
12946 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12947 )]
12948 pub sip_phone_number: String,
12949}
12950
12951#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
12952pub struct SearchCompanyContactsResponse {
12953 #[serde(
12954 default,
12955 skip_serializing_if = "Vec::is_empty",
12956 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
12957 )]
12958 pub contacts: Vec<Contacts>,
12959 #[serde(
12963 default,
12964 skip_serializing_if = "String::is_empty",
12965 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
12966 )]
12967 pub next_page_token: String,
12968 #[serde(
12972 default,
12973 skip_serializing_if = "crate::utils::zero_i64",
12974 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
12975 )]
12976 pub page_size: i64,
12977}
12978
12979#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
12985pub enum GetChatMessagesResponseStatus {
12986 #[serde(rename = "Deleted")]
12987 Deleted,
12988 #[serde(rename = "Edited")]
12989 Edited,
12990 #[serde(rename = "Normal")]
12991 Normal,
12992 #[serde(rename = "")]
12993 #[default]
12994 Noop,
12995 #[serde(other)]
12996 FallthroughString,
12997}
12998
12999impl std::fmt::Display for GetChatMessagesResponseStatus {
13000 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13001 match self {
13002 GetChatMessagesResponseStatus::Deleted => "Deleted",
13003 GetChatMessagesResponseStatus::Edited => "Edited",
13004 GetChatMessagesResponseStatus::Normal => "Normal",
13005 GetChatMessagesResponseStatus::Noop => "",
13006 GetChatMessagesResponseStatus::FallthroughString => "*",
13007 }
13008 .fmt(f)
13009 }
13010}
13011
13012impl GetChatMessagesResponseStatus {
13013 pub fn is_noop(&self) -> bool {
13014 matches!(self, GetChatMessagesResponseStatus::Noop)
13015 }
13016}
13017
13018#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13019pub struct Messages {
13020 #[serde(default, skip_serializing_if = "Option::is_none")]
13021 pub bot_message: Option<Domains>,
13022 #[serde(
13026 default,
13027 skip_serializing_if = "Option::is_none",
13028 deserialize_with = "crate::utils::date_format::deserialize"
13029 )]
13030 pub date_time: Option<chrono::NaiveDate>,
13031 #[serde(
13035 default,
13036 skip_serializing_if = "String::is_empty",
13037 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13038 )]
13039 pub download_url: String,
13040 #[serde(
13044 default,
13045 skip_serializing_if = "String::is_empty",
13046 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13047 )]
13048 pub file_id: String,
13049 #[serde(
13053 default,
13054 skip_serializing_if = "String::is_empty",
13055 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13056 )]
13057 pub file_name: String,
13058 #[serde(
13062 default,
13063 skip_serializing_if = "crate::utils::zero_i64",
13064 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
13065 )]
13066 pub file_size: i64,
13067 #[serde(
13071 default,
13072 skip_serializing_if = "String::is_empty",
13073 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13074 )]
13075 pub id: String,
13076 #[serde(
13080 default,
13081 skip_serializing_if = "String::is_empty",
13082 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13083 )]
13084 pub message: String,
13085 #[serde(
13089 default,
13090 skip_serializing_if = "String::is_empty",
13091 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13092 )]
13093 pub reply_main_message_id: String,
13094 #[serde(
13098 default,
13099 skip_serializing_if = "crate::utils::zero_i64",
13100 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
13101 )]
13102 pub reply_main_message_timestamp: i64,
13103 #[serde(
13107 default,
13108 skip_serializing_if = "String::is_empty",
13109 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13110 )]
13111 pub sender: String,
13112 #[serde(default, skip_serializing_if = "Option::is_none")]
13118 pub status: Option<GetChatMessagesResponseStatus>,
13119 #[serde(
13123 default,
13124 skip_serializing_if = "crate::utils::zero_i64",
13125 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
13126 )]
13127 pub timestamp: i64,
13128}
13129
13130#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13132pub struct GetChatMessagesResponse {
13133 #[serde(
13137 default,
13138 skip_serializing_if = "Option::is_none",
13139 deserialize_with = "crate::utils::date_format::deserialize"
13140 )]
13141 pub date: Option<chrono::NaiveDate>,
13142 #[serde(
13146 default,
13147 skip_serializing_if = "Vec::is_empty",
13148 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
13149 )]
13150 pub messages: Vec<Messages>,
13151 #[serde(
13155 default,
13156 skip_serializing_if = "String::is_empty",
13157 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13158 )]
13159 pub next_page_token: String,
13160 #[serde(
13164 default,
13165 skip_serializing_if = "crate::utils::zero_i64",
13166 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
13167 )]
13168 pub page_size: i64,
13169}
13170
13171#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13172pub struct AtItems {
13173 #[serde(
13177 default,
13178 skip_serializing_if = "String::is_empty",
13179 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13180 )]
13181 pub at_contact: String,
13182 #[serde(
13186 default,
13187 skip_serializing_if = "crate::utils::zero_i64",
13188 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
13189 )]
13190 pub at_type: i64,
13191 #[serde(
13195 default,
13196 skip_serializing_if = "crate::utils::zero_i64",
13197 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
13198 )]
13199 pub end_position: i64,
13200 #[serde(
13204 default,
13205 skip_serializing_if = "crate::utils::zero_i64",
13206 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
13207 )]
13208 pub start_position: i64,
13209}
13210
13211#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13212pub struct SendaChatMessageRequest {
13213 #[serde(
13217 default,
13218 skip_serializing_if = "Vec::is_empty",
13219 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
13220 )]
13221 pub at_items: Vec<AtItems>,
13222 #[serde(
13226 default,
13227 skip_serializing_if = "String::is_empty",
13228 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13229 )]
13230 pub message: String,
13231 #[serde(
13235 default,
13236 skip_serializing_if = "String::is_empty",
13237 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13238 )]
13239 pub to_channel: String,
13240 #[serde(
13244 default,
13245 skip_serializing_if = "String::is_empty",
13246 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13247 )]
13248 pub to_contact: String,
13249}
13250
13251#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13252pub struct MarkMessageRequest {
13253 #[serde(
13257 default,
13258 skip_serializing_if = "String::is_empty",
13259 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13260 )]
13261 pub action: String,
13262 #[serde(
13266 default,
13267 skip_serializing_if = "crate::utils::zero_i64",
13268 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
13269 )]
13270 pub timestamp: i64,
13271 #[serde(
13275 default,
13276 skip_serializing_if = "String::is_empty",
13277 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13278 )]
13279 pub to_channel: String,
13280 #[serde(
13284 default,
13285 skip_serializing_if = "String::is_empty",
13286 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13287 )]
13288 pub to_contact: String,
13289}
13290
13291#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
13297pub enum ReactMessageRequestAction {
13298 #[serde(rename = "add")]
13299 Add,
13300 #[serde(rename = "remove")]
13301 Remove,
13302 #[serde(rename = "")]
13303 #[default]
13304 Noop,
13305 #[serde(other)]
13306 FallthroughString,
13307}
13308
13309impl std::fmt::Display for ReactMessageRequestAction {
13310 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13311 match self {
13312 ReactMessageRequestAction::Add => "add",
13313 ReactMessageRequestAction::Remove => "remove",
13314 ReactMessageRequestAction::Noop => "",
13315 ReactMessageRequestAction::FallthroughString => "*",
13316 }
13317 .fmt(f)
13318 }
13319}
13320
13321impl ReactMessageRequestAction {
13322 pub fn is_noop(&self) -> bool {
13323 matches!(self, ReactMessageRequestAction::Noop)
13324 }
13325}
13326
13327#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13328pub struct ReactMessageRequest {
13329 #[serde(default, skip_serializing_if = "Option::is_none")]
13335 pub action: Option<ReactMessageRequestAction>,
13336 #[serde(
13340 default,
13341 skip_serializing_if = "String::is_empty",
13342 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13343 )]
13344 pub emoji: String,
13345 #[serde(
13349 default,
13350 skip_serializing_if = "String::is_empty",
13351 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13352 )]
13353 pub to_channel: String,
13354 #[serde(
13358 default,
13359 skip_serializing_if = "String::is_empty",
13360 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13361 )]
13362 pub to_contact: String,
13363}
13364
13365#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13366pub struct Reactions {
13367 #[serde(
13371 default,
13372 skip_serializing_if = "String::is_empty",
13373 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13374 )]
13375 pub emoji: String,
13376 #[serde(
13380 default,
13381 skip_serializing_if = "crate::utils::zero_i64",
13382 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
13383 )]
13384 pub total_count: i64,
13385}
13386
13387#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13389pub struct GetChatMessageResponse {
13390 #[serde(default, skip_serializing_if = "Option::is_none")]
13394 pub bot_message: Option<Domains>,
13395 #[serde(
13399 default,
13400 skip_serializing_if = "Option::is_none",
13401 deserialize_with = "crate::utils::date_format::deserialize"
13402 )]
13403 pub date_time: Option<chrono::NaiveDate>,
13404 #[serde(
13408 default,
13409 skip_serializing_if = "String::is_empty",
13410 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13411 )]
13412 pub download_url: String,
13413 #[serde(
13417 default,
13418 skip_serializing_if = "String::is_empty",
13419 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13420 )]
13421 pub file_id: String,
13422 #[serde(
13426 default,
13427 skip_serializing_if = "String::is_empty",
13428 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13429 )]
13430 pub file_name: String,
13431 #[serde(
13435 default,
13436 skip_serializing_if = "crate::utils::zero_i64",
13437 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
13438 )]
13439 pub file_size: i64,
13440 #[serde(
13444 default,
13445 skip_serializing_if = "String::is_empty",
13446 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13447 )]
13448 pub id: String,
13449 #[serde(
13453 default,
13454 skip_serializing_if = "String::is_empty",
13455 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13456 )]
13457 pub message: String,
13458 #[serde(
13462 default,
13463 skip_serializing_if = "Vec::is_empty",
13464 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
13465 )]
13466 pub reactions: Vec<Reactions>,
13467 #[serde(
13471 default,
13472 skip_serializing_if = "String::is_empty",
13473 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13474 )]
13475 pub reply_main_message_id: String,
13476 #[serde(
13480 default,
13481 skip_serializing_if = "crate::utils::zero_i64",
13482 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
13483 )]
13484 pub reply_main_message_timestamp: i64,
13485 #[serde(
13489 default,
13490 skip_serializing_if = "String::is_empty",
13491 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13492 )]
13493 pub sender: String,
13494 #[serde(
13498 default,
13499 skip_serializing_if = "crate::utils::zero_i64",
13500 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
13501 )]
13502 pub timestamp: i64,
13503}
13504
13505#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13506pub struct EditMessageRequest {
13507 #[serde(
13511 default,
13512 skip_serializing_if = "String::is_empty",
13513 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13514 )]
13515 pub message: String,
13516 #[serde(
13520 default,
13521 skip_serializing_if = "String::is_empty",
13522 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13523 )]
13524 pub to_channel: String,
13525 #[serde(
13529 default,
13530 skip_serializing_if = "String::is_empty",
13531 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13532 )]
13533 pub to_contact: String,
13534}
13535
13536#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13537pub struct Channels {
13538 #[serde(default, skip_serializing_if = "Option::is_none")]
13539 pub channels_settings: Option<ChannelSettings>,
13540 #[serde(
13544 default,
13545 skip_serializing_if = "String::is_empty",
13546 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13547 )]
13548 pub id: String,
13549 #[serde(
13553 default,
13554 skip_serializing_if = "String::is_empty",
13555 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13556 )]
13557 pub name: String,
13558 #[serde(
13562 default,
13563 skip_serializing_if = "crate::utils::zero_i64",
13564 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
13565 rename = "type"
13566 )]
13567 pub type_: i64,
13568}
13569
13570#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13571pub struct GetChannelsResponse {
13572 #[serde(
13576 default,
13577 skip_serializing_if = "Vec::is_empty",
13578 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
13579 )]
13580 pub channels: Vec<Channels>,
13581 #[serde(
13585 default,
13586 skip_serializing_if = "String::is_empty",
13587 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13588 )]
13589 pub next_page_token: String,
13590 #[serde(
13594 default,
13595 skip_serializing_if = "crate::utils::zero_i64",
13596 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
13597 )]
13598 pub page_size: i64,
13599 #[serde(
13603 default,
13604 skip_serializing_if = "crate::utils::zero_i64",
13605 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
13606 )]
13607 pub total_records: i64,
13608}
13609
13610#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13611pub struct Members {
13612 #[serde(
13616 default,
13617 skip_serializing_if = "String::is_empty",
13618 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13619 )]
13620 pub email: String,
13621}
13622
13623#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13624pub struct CreateChannelRequest {
13625 #[serde(
13629 default,
13630 skip_serializing_if = "Vec::is_empty",
13631 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
13632 )]
13633 pub members: Vec<Members>,
13634 #[serde(
13638 default,
13639 skip_serializing_if = "String::is_empty",
13640 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13641 )]
13642 pub name: String,
13643 #[serde(
13647 default,
13648 skip_serializing_if = "crate::utils::zero_i64",
13649 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
13650 rename = "type"
13651 )]
13652 pub type_: i64,
13653}
13654
13655#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13656pub struct CreateChannelResponse {
13657 #[serde(
13661 default,
13662 skip_serializing_if = "String::is_empty",
13663 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13664 )]
13665 pub id: String,
13666 #[serde(
13670 default,
13671 skip_serializing_if = "String::is_empty",
13672 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13673 )]
13674 pub jid: String,
13675 #[serde(
13679 default,
13680 skip_serializing_if = "String::is_empty",
13681 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13682 )]
13683 pub name: String,
13684 #[serde(
13688 default,
13689 skip_serializing_if = "crate::utils::zero_i64",
13690 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
13691 rename = "type"
13692 )]
13693 pub type_: i64,
13694}
13695
13696#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13697pub struct GetUserContactsResponse {
13698 #[serde(
13702 default,
13703 skip_serializing_if = "String::is_empty",
13704 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13705 )]
13706 pub email: String,
13707 #[serde(
13711 default,
13712 skip_serializing_if = "String::is_empty",
13713 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13714 )]
13715 pub first_name: String,
13716 #[serde(
13720 default,
13721 skip_serializing_if = "String::is_empty",
13722 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13723 )]
13724 pub id: String,
13725 #[serde(
13729 default,
13730 skip_serializing_if = "String::is_empty",
13731 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13732 )]
13733 pub last_name: String,
13734}
13735
13736#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13737pub struct GetUserContactsResponseData {
13738 #[serde(
13742 default,
13743 skip_serializing_if = "Vec::is_empty",
13744 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
13745 )]
13746 pub contacts: Vec<GetUserContactsResponse>,
13747 #[serde(
13751 default,
13752 skip_serializing_if = "String::is_empty",
13753 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13754 )]
13755 pub next_page_token: String,
13756 #[serde(
13760 default,
13761 skip_serializing_if = "crate::utils::zero_i64",
13762 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
13763 )]
13764 pub page_size: i64,
13765}
13766
13767#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13768pub struct GetUserContactResponse {
13769 #[serde(
13776 default,
13777 skip_serializing_if = "Vec::is_empty",
13778 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
13779 )]
13780 pub direct_numbers: Vec<String>,
13781 #[serde(
13785 default,
13786 skip_serializing_if = "String::is_empty",
13787 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13788 )]
13789 pub email: String,
13790 #[serde(
13794 default,
13795 skip_serializing_if = "String::is_empty",
13796 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13797 )]
13798 pub extension_number: String,
13799 #[serde(
13803 default,
13804 skip_serializing_if = "String::is_empty",
13805 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13806 )]
13807 pub first_name: String,
13808 #[serde(
13812 default,
13813 skip_serializing_if = "String::is_empty",
13814 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13815 )]
13816 pub id: String,
13817 #[serde(
13821 default,
13822 skip_serializing_if = "String::is_empty",
13823 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13824 )]
13825 pub last_name: String,
13826 #[serde(
13830 default,
13831 skip_serializing_if = "String::is_empty",
13832 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13833 )]
13834 pub phone_number: String,
13835 #[serde(default, skip_serializing_if = "Option::is_none")]
13840 pub presence_status: Option<PresenceStatus>,
13841}
13842
13843#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
13847pub enum Role {
13848 #[serde(rename = "admin")]
13849 Admin,
13850 #[serde(rename = "member")]
13851 Member,
13852 #[serde(rename = "owner")]
13853 Owner,
13854 #[serde(rename = "")]
13855 #[default]
13856 Noop,
13857 #[serde(other)]
13858 FallthroughString,
13859}
13860
13861impl std::fmt::Display for Role {
13862 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13863 match self {
13864 Role::Admin => "admin",
13865 Role::Member => "member",
13866 Role::Owner => "owner",
13867 Role::Noop => "",
13868 Role::FallthroughString => "*",
13869 }
13870 .fmt(f)
13871 }
13872}
13873
13874impl Role {
13875 pub fn is_noop(&self) -> bool {
13876 matches!(self, Role::Noop)
13877 }
13878}
13879
13880#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13881pub struct ListChannelMembersResponse {
13882 #[serde(
13886 default,
13887 skip_serializing_if = "String::is_empty",
13888 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13889 )]
13890 pub email: String,
13891 #[serde(
13895 default,
13896 skip_serializing_if = "String::is_empty",
13897 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13898 )]
13899 pub first_name: String,
13900 #[serde(
13904 default,
13905 skip_serializing_if = "String::is_empty",
13906 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13907 )]
13908 pub id: String,
13909 #[serde(
13913 default,
13914 skip_serializing_if = "String::is_empty",
13915 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13916 )]
13917 pub last_name: String,
13918 #[serde(
13922 default,
13923 skip_serializing_if = "String::is_empty",
13924 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13925 )]
13926 pub name: String,
13927 #[serde(default, skip_serializing_if = "Option::is_none")]
13931 pub role: Option<Role>,
13932}
13933
13934#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13935pub struct ListChannelMembersResponseData {
13936 #[serde(
13940 default,
13941 skip_serializing_if = "Vec::is_empty",
13942 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
13943 )]
13944 pub members: Vec<ListChannelMembersResponse>,
13945 #[serde(
13949 default,
13950 skip_serializing_if = "String::is_empty",
13951 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
13952 )]
13953 pub next_page_token: String,
13954 #[serde(
13958 default,
13959 skip_serializing_if = "crate::utils::zero_i64",
13960 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
13961 )]
13962 pub page_size: i64,
13963 #[serde(
13967 default,
13968 skip_serializing_if = "crate::utils::zero_i64",
13969 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
13970 )]
13971 pub total_records: i64,
13972}
13973
13974#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13975pub struct InviteChannelMembersRequest {
13976 #[serde(
13980 default,
13981 skip_serializing_if = "Vec::is_empty",
13982 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
13983 )]
13984 pub members: Vec<Members>,
13985}
13986
13987#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
13988pub struct InviteChannelMembersResponse {
13989 #[serde(
13993 default,
13994 skip_serializing_if = "Option::is_none",
13995 deserialize_with = "crate::utils::date_time_format::deserialize"
13996 )]
13997 pub added_at: Option<chrono::DateTime<chrono::Utc>>,
13998 #[serde(
14005 default,
14006 skip_serializing_if = "Vec::is_empty",
14007 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
14008 )]
14009 pub ids: Vec<String>,
14010}
14011
14012#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14013pub struct JoinChannelResponse {
14014 #[serde(
14018 default,
14019 skip_serializing_if = "Option::is_none",
14020 deserialize_with = "crate::utils::date_time_format::deserialize"
14021 )]
14022 pub added_at: Option<chrono::DateTime<chrono::Utc>>,
14023 #[serde(
14027 default,
14028 skip_serializing_if = "String::is_empty",
14029 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14030 )]
14031 pub id: String,
14032}
14033
14034#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14036pub struct AccountCreateRequest {
14037 #[serde(
14041 default,
14042 skip_serializing_if = "String::is_empty",
14043 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14044 )]
14045 pub account_name: String,
14046 #[serde(
14050 default,
14051 skip_serializing_if = "String::is_empty",
14052 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14053 )]
14054 pub email: String,
14055 #[serde(
14059 default,
14060 skip_serializing_if = "String::is_empty",
14061 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14062 )]
14063 pub first_name: String,
14064 #[serde(
14068 default,
14069 skip_serializing_if = "String::is_empty",
14070 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14071 )]
14072 pub last_name: String,
14073 #[serde(default, skip_serializing_if = "Option::is_none")]
14077 pub options: Option<Options>,
14078 #[serde(
14082 default,
14083 skip_serializing_if = "String::is_empty",
14084 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14085 )]
14086 pub password: String,
14087}
14088
14089#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14090pub struct AccountCreateResponse {
14091 #[serde(
14095 default,
14096 skip_serializing_if = "String::is_empty",
14097 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14098 )]
14099 pub created_at: String,
14100 #[serde(
14104 default,
14105 skip_serializing_if = "String::is_empty",
14106 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14107 )]
14108 pub id: String,
14109 #[serde(
14113 default,
14114 skip_serializing_if = "String::is_empty",
14115 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14116 )]
14117 pub owner_email: String,
14118 #[serde(
14122 default,
14123 skip_serializing_if = "String::is_empty",
14124 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14125 )]
14126 pub owner_id: String,
14127}
14128
14129#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14130pub struct AccountResponse {
14131 #[serde(
14135 default,
14136 skip_serializing_if = "Option::is_none",
14137 deserialize_with = "crate::utils::date_time_format::deserialize"
14138 )]
14139 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
14140 #[serde(
14144 default,
14145 skip_serializing_if = "String::is_empty",
14146 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14147 )]
14148 pub id: String,
14149 #[serde(default, skip_serializing_if = "Option::is_none")]
14153 pub options: Option<Options>,
14154 #[serde(
14158 default,
14159 skip_serializing_if = "String::is_empty",
14160 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14161 )]
14162 pub owner_email: String,
14163 #[serde(
14167 default,
14168 skip_serializing_if = "String::is_empty",
14169 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14170 )]
14171 pub owner_id: String,
14172 #[serde(
14176 default,
14177 skip_serializing_if = "String::is_empty",
14178 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14179 )]
14180 pub vanity_url: String,
14181}
14182
14183#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
14191pub enum OptionData {
14192 #[serde(rename = "meeting_authentication")]
14193 MeetingAuthentication,
14194 #[serde(rename = "recording_authentication")]
14195 RecordingAuthentication,
14196 #[serde(rename = "")]
14197 #[default]
14198 Noop,
14199 #[serde(other)]
14200 FallthroughString,
14201}
14202
14203impl std::fmt::Display for OptionData {
14204 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14205 match self {
14206 OptionData::MeetingAuthentication => "meeting_authentication",
14207 OptionData::RecordingAuthentication => "recording_authentication",
14208 OptionData::Noop => "",
14209 OptionData::FallthroughString => "*",
14210 }
14211 .fmt(f)
14212 }
14213}
14214
14215impl OptionData {
14216 pub fn is_noop(&self) -> bool {
14217 matches!(self, OptionData::Noop)
14218 }
14219}
14220
14221#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14231#[serde(untagged)]
14232pub enum AccountSettingsResponseOneOf {
14233 Domains(Domains),
14234 Security(Security),
14238 AccountSettings(AccountSettings),
14239 MeetingSecuritySettings(MeetingSecuritySettings),
14240}
14241
14242impl AccountSettingsResponseOneOf {
14243 pub fn account_settings(&self) -> Option<&AccountSettings> {
14244 if let AccountSettingsResponseOneOf::AccountSettings(ref_) = self {
14245 return Some(ref_);
14246 }
14247 None
14248 }
14249
14250 pub fn domains(&self) -> Option<&Domains> {
14251 if let AccountSettingsResponseOneOf::Domains(ref_) = self {
14252 return Some(ref_);
14253 }
14254 None
14255 }
14256
14257 pub fn meeting_security_settings(&self) -> Option<&MeetingSecuritySettings> {
14258 if let AccountSettingsResponseOneOf::MeetingSecuritySettings(ref_) = self {
14259 return Some(ref_);
14260 }
14261 None
14262 }
14263
14264 pub fn security(&self) -> Option<&Security> {
14265 if let AccountSettingsResponseOneOf::Security(ref_) = self {
14266 return Some(ref_);
14267 }
14268 None
14269 }
14270}
14271
14272#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14281#[serde(untagged)]
14282pub enum AccountSettingsUpdateRequestOneOf {
14283 Domains(Domains),
14284 UpdateAccountSettings(UpdateAccountSettings),
14285 MeetingSecuritySettings(MeetingSecuritySettings),
14286}
14287
14288impl AccountSettingsUpdateRequestOneOf {
14289 pub fn domains(&self) -> Option<&Domains> {
14290 if let AccountSettingsUpdateRequestOneOf::Domains(ref_) = self {
14291 return Some(ref_);
14292 }
14293 None
14294 }
14295
14296 pub fn meeting_security_settings(&self) -> Option<&MeetingSecuritySettings> {
14297 if let AccountSettingsUpdateRequestOneOf::MeetingSecuritySettings(ref_) = self {
14298 return Some(ref_);
14299 }
14300 None
14301 }
14302
14303 pub fn update_account_settings(&self) -> Option<&UpdateAccountSettings> {
14304 if let AccountSettingsUpdateRequestOneOf::UpdateAccountSettings(ref_) = self {
14305 return Some(ref_);
14306 }
14307 None
14308 }
14309}
14310
14311#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
14312pub enum AccountSettingsUpdateOption {
14313 #[serde(rename = "meeting_authentication")]
14314 MeetingAuthentication,
14315 #[serde(rename = "meeting_security")]
14316 MeetingSecurity,
14317 #[serde(rename = "recording_authentication")]
14318 RecordingAuthentication,
14319 #[serde(rename = "security")]
14320 Security,
14321 #[serde(rename = "")]
14322 #[default]
14323 Noop,
14324 #[serde(other)]
14325 FallthroughString,
14326}
14327
14328impl std::fmt::Display for AccountSettingsUpdateOption {
14329 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14330 match self {
14331 AccountSettingsUpdateOption::MeetingAuthentication => "meeting_authentication",
14332 AccountSettingsUpdateOption::MeetingSecurity => "meeting_security",
14333 AccountSettingsUpdateOption::RecordingAuthentication => "recording_authentication",
14334 AccountSettingsUpdateOption::Security => "security",
14335 AccountSettingsUpdateOption::Noop => "",
14336 AccountSettingsUpdateOption::FallthroughString => "*",
14337 }
14338 .fmt(f)
14339 }
14340}
14341
14342impl AccountSettingsUpdateOption {
14343 pub fn is_noop(&self) -> bool {
14344 matches!(self, AccountSettingsUpdateOption::Noop)
14345 }
14346}
14347
14348#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14349pub struct AccountTrustedDomainResponse {
14350 #[serde(
14357 default,
14358 skip_serializing_if = "Vec::is_empty",
14359 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
14360 )]
14361 pub trusted_domains: Vec<String>,
14362}
14363
14364#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
14368pub enum AccountPlansResponsePlanBaseStatus {
14369 #[serde(rename = "active")]
14370 Active,
14371 #[serde(rename = "cancel")]
14372 Cancel,
14373 #[serde(rename = "expired")]
14374 Expired,
14375 #[serde(rename = "")]
14376 #[default]
14377 Noop,
14378 #[serde(other)]
14379 FallthroughString,
14380}
14381
14382impl std::fmt::Display for AccountPlansResponsePlanBaseStatus {
14383 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14384 match self {
14385 AccountPlansResponsePlanBaseStatus::Active => "active",
14386 AccountPlansResponsePlanBaseStatus::Cancel => "cancel",
14387 AccountPlansResponsePlanBaseStatus::Expired => "expired",
14388 AccountPlansResponsePlanBaseStatus::Noop => "",
14389 AccountPlansResponsePlanBaseStatus::FallthroughString => "*",
14390 }
14391 .fmt(f)
14392 }
14393}
14394
14395impl AccountPlansResponsePlanBaseStatus {
14396 pub fn is_noop(&self) -> bool {
14397 matches!(self, AccountPlansResponsePlanBaseStatus::Noop)
14398 }
14399}
14400
14401#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14402pub struct PlanZoomRooms {
14403 #[serde(
14407 default,
14408 skip_serializing_if = "crate::utils::zero_i64",
14409 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
14410 )]
14411 pub hosts: i64,
14412 #[serde(
14416 default,
14417 skip_serializing_if = "Option::is_none",
14418 deserialize_with = "crate::utils::date_format::deserialize"
14419 )]
14420 pub next_invoice_date: Option<chrono::NaiveDate>,
14421 #[serde(
14425 default,
14426 skip_serializing_if = "Option::is_none",
14427 deserialize_with = "crate::utils::date_format::deserialize"
14428 )]
14429 pub service_effective_date: Option<chrono::NaiveDate>,
14430 #[serde(default, skip_serializing_if = "Option::is_none")]
14434 pub status: Option<AccountPlansResponsePlanBaseStatus>,
14435 #[serde(
14439 default,
14440 skip_serializing_if = "String::is_empty",
14441 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
14442 rename = "type"
14443 )]
14444 pub type_: String,
14445}
14446
14447#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14449pub struct PlanWebinar {
14450 #[serde(
14454 default,
14455 skip_serializing_if = "crate::utils::zero_i64",
14456 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
14457 )]
14458 pub hosts: i64,
14459 #[serde(
14463 default,
14464 skip_serializing_if = "Option::is_none",
14465 deserialize_with = "crate::utils::date_format::deserialize"
14466 )]
14467 pub next_invoice_date: Option<chrono::NaiveDate>,
14468 #[serde(
14472 default,
14473 skip_serializing_if = "Option::is_none",
14474 deserialize_with = "crate::utils::date_format::deserialize"
14475 )]
14476 pub service_effective_date: Option<chrono::NaiveDate>,
14477 #[serde(default, skip_serializing_if = "Option::is_none")]
14481 pub status: Option<AccountPlansResponsePlanBaseStatus>,
14482 #[serde(
14486 default,
14487 skip_serializing_if = "String::is_empty",
14488 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
14489 rename = "type"
14490 )]
14491 pub type_: String,
14492}
14493
14494#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
14498pub enum PlanRecordingStatus {
14499 #[serde(rename = "Active")]
14500 Active,
14501 #[serde(rename = "Cancelled")]
14502 Cancelled,
14503 #[serde(rename = "")]
14504 #[default]
14505 Noop,
14506 #[serde(other)]
14507 FallthroughString,
14508}
14509
14510impl std::fmt::Display for PlanRecordingStatus {
14511 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14512 match self {
14513 PlanRecordingStatus::Active => "Active",
14514 PlanRecordingStatus::Cancelled => "Cancelled",
14515 PlanRecordingStatus::Noop => "",
14516 PlanRecordingStatus::FallthroughString => "*",
14517 }
14518 .fmt(f)
14519 }
14520}
14521
14522impl PlanRecordingStatus {
14523 pub fn is_noop(&self) -> bool {
14524 matches!(self, PlanRecordingStatus::Noop)
14525 }
14526}
14527
14528#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14530pub struct AccountPlansResponsePlanAudio {
14531 #[serde(
14535 default,
14536 skip_serializing_if = "String::is_empty",
14537 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14538 )]
14539 pub callout_countries: String,
14540 #[serde(
14544 default,
14545 skip_serializing_if = "crate::utils::zero_i64",
14546 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
14547 )]
14548 pub ddi_numbers: i64,
14549 #[serde(
14553 default,
14554 skip_serializing_if = "Option::is_none",
14555 deserialize_with = "crate::utils::date_format::deserialize"
14556 )]
14557 pub next_invoice_date: Option<chrono::NaiveDate>,
14558 #[serde(
14562 default,
14563 skip_serializing_if = "String::is_empty",
14564 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14565 )]
14566 pub premium_countries: String,
14567 #[serde(
14571 default,
14572 skip_serializing_if = "Option::is_none",
14573 deserialize_with = "crate::utils::date_format::deserialize"
14574 )]
14575 pub service_effective_date: Option<chrono::NaiveDate>,
14576 #[serde(default, skip_serializing_if = "Option::is_none")]
14580 pub status: Option<AccountPlansResponsePlanBaseStatus>,
14581 #[serde(
14585 default,
14586 skip_serializing_if = "String::is_empty",
14587 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14588 )]
14589 pub tollfree_countries: String,
14590 #[serde(
14594 default,
14595 skip_serializing_if = "String::is_empty",
14596 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
14597 rename = "type"
14598 )]
14599 pub type_: String,
14600}
14601
14602#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14604pub struct AccountPlansResponsePlanPhoneBase {
14605 #[serde(
14609 default,
14610 skip_serializing_if = "String::is_empty",
14611 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14612 )]
14613 pub callout_countries: String,
14614 #[serde(
14618 default,
14619 skip_serializing_if = "Option::is_none",
14620 deserialize_with = "crate::utils::date_format::deserialize"
14621 )]
14622 pub next_invoice_date: Option<chrono::NaiveDate>,
14623 #[serde(
14627 default,
14628 skip_serializing_if = "Option::is_none",
14629 deserialize_with = "crate::utils::date_format::deserialize"
14630 )]
14631 pub service_effective_date: Option<chrono::NaiveDate>,
14632 #[serde(default, skip_serializing_if = "Option::is_none")]
14636 pub status: Option<AccountPlansResponsePlanBaseStatus>,
14637 #[serde(
14641 default,
14642 skip_serializing_if = "String::is_empty",
14643 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
14644 rename = "type"
14645 )]
14646 pub type_: String,
14647}
14648
14649#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14651pub struct PlanPhone {
14652 #[serde(default, skip_serializing_if = "Option::is_none")]
14656 pub plan_base: Option<AccountPlansResponsePlanPhoneBase>,
14657 #[serde(
14661 default,
14662 skip_serializing_if = "Vec::is_empty",
14663 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
14664 )]
14665 pub plan_calling: Vec<PlanZoomRooms>,
14666 #[serde(
14670 default,
14671 skip_serializing_if = "Vec::is_empty",
14672 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
14673 )]
14674 pub plan_number: Vec<PlanZoomRooms>,
14675}
14676
14677#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14678pub struct AccountPlansResponse {
14679 #[serde(default, skip_serializing_if = "Option::is_none")]
14683 pub plan_audio: Option<AccountPlansResponsePlanAudio>,
14684 #[serde(default, skip_serializing_if = "Option::is_none")]
14685 pub plan_base: Option<PlanZoomRooms>,
14686 #[serde(
14687 default,
14688 skip_serializing_if = "Vec::is_empty",
14689 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
14690 )]
14691 pub plan_large_meeting: Vec<PlanWebinar>,
14692 #[serde(default, skip_serializing_if = "Option::is_none")]
14696 pub plan_phone: Option<PlanPhone>,
14697 #[serde(
14701 default,
14702 skip_serializing_if = "String::is_empty",
14703 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14704 )]
14705 pub plan_recording: String,
14706 #[serde(
14710 default,
14711 skip_serializing_if = "Option::is_none",
14712 deserialize_with = "crate::utils::date_format::deserialize"
14713 )]
14714 pub plan_recording_next_invoice_date: Option<chrono::NaiveDate>,
14715 #[serde(
14719 default,
14720 skip_serializing_if = "Option::is_none",
14721 deserialize_with = "crate::utils::date_format::deserialize"
14722 )]
14723 pub plan_recording_service_effective_date: Option<chrono::NaiveDate>,
14724 #[serde(default, skip_serializing_if = "Option::is_none")]
14728 pub plan_recording_status: Option<PlanRecordingStatus>,
14729 #[serde(default, skip_serializing_if = "Option::is_none")]
14730 pub plan_room_connector: Option<PlanZoomRooms>,
14731 #[serde(
14732 default,
14733 skip_serializing_if = "Vec::is_empty",
14734 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
14735 )]
14736 pub plan_webinar: Vec<PlanWebinar>,
14737 #[serde(default, skip_serializing_if = "Option::is_none")]
14738 pub plan_zoom_rooms: Option<PlanZoomRooms>,
14739}
14740
14741#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14742pub struct AccountPlanCreateRequest {
14743 #[serde(default, skip_serializing_if = "Option::is_none")]
14747 pub contact: Option<Contact>,
14748}
14749
14750#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14756pub struct AccountPlanCreateRequestAllOf {
14757 #[serde(flatten)]
14761 pub account_plans: AccountPlans,
14762 #[serde(flatten)]
14763 pub account_plan_create_request: AccountPlanCreateRequest,
14764}
14765
14766#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14768pub struct AccountPlanAddonCreateRequest {
14769 pub plan_details: PhonePlan,
14773 #[serde(
14777 default,
14778 skip_serializing_if = "String::is_empty",
14779 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
14780 rename = "type"
14781 )]
14782 pub type_: String,
14783}
14784
14785#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14793#[serde(untagged)]
14794pub enum AccountPlanAddonCreateRequestOneOf {
14795 PlanBase(PlanBase),
14799 AccountPlanAddonCreateRequest(AccountPlanAddonCreateRequest),
14803}
14804
14805impl AccountPlanAddonCreateRequestOneOf {
14806 pub fn account_plan_addon_create_request(&self) -> Option<&AccountPlanAddonCreateRequest> {
14807 if let AccountPlanAddonCreateRequestOneOf::AccountPlanAddonCreateRequest(ref_) = self {
14808 return Some(ref_);
14809 }
14810 None
14811 }
14812
14813 pub fn plan_base(&self) -> Option<&PlanBase> {
14814 if let AccountPlanAddonCreateRequestOneOf::PlanBase(ref_) = self {
14815 return Some(ref_);
14816 }
14817 None
14818 }
14819}
14820
14821#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14822pub struct GroupCreateRequest {
14823 #[serde(
14827 default,
14828 skip_serializing_if = "String::is_empty",
14829 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14830 )]
14831 pub name: String,
14832}
14833
14834#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14835pub struct GroupResponse {
14836 #[serde(
14840 default,
14841 skip_serializing_if = "String::is_empty",
14842 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14843 )]
14844 pub id: String,
14845 #[serde(
14849 default,
14850 skip_serializing_if = "String::is_empty",
14851 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14852 )]
14853 pub name: String,
14854 #[serde(
14858 default,
14859 skip_serializing_if = "crate::utils::zero_i64",
14860 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
14861 )]
14862 pub total_members: i64,
14863}
14864
14865#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14866pub struct UserCreateResponse {
14867 #[serde(
14871 default,
14872 skip_serializing_if = "String::is_empty",
14873 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14874 )]
14875 pub email: String,
14876 #[serde(
14880 default,
14881 skip_serializing_if = "String::is_empty",
14882 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14883 )]
14884 pub first_name: String,
14885 #[serde(
14889 default,
14890 skip_serializing_if = "String::is_empty",
14891 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14892 )]
14893 pub id: String,
14894 #[serde(
14898 default,
14899 skip_serializing_if = "String::is_empty",
14900 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14901 )]
14902 pub last_name: String,
14903 #[serde(
14907 default,
14908 skip_serializing_if = "crate::utils::zero_i64",
14909 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
14910 rename = "type"
14911 )]
14912 pub type_: i64,
14913}
14914
14915#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14916pub struct GroupMembersResponseData {
14917 #[serde(
14918 default,
14919 skip_serializing_if = "Vec::is_empty",
14920 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
14921 )]
14922 pub members: Vec<UserCreateResponse>,
14923 #[serde(
14927 default,
14928 skip_serializing_if = "String::is_empty",
14929 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
14930 )]
14931 pub next_page_token: String,
14932 #[serde(
14936 default,
14937 skip_serializing_if = "crate::utils::zero_i64",
14938 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
14939 )]
14940 pub page_count: i64,
14941 #[serde(
14945 default,
14946 skip_serializing_if = "crate::utils::zero_i64",
14947 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
14948 )]
14949 pub page_number: i64,
14950 #[serde(
14954 default,
14955 skip_serializing_if = "crate::utils::zero_i64",
14956 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
14957 )]
14958 pub page_size: i64,
14959 #[serde(
14963 default,
14964 skip_serializing_if = "crate::utils::zero_i64",
14965 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
14966 )]
14967 pub total_records: i64,
14968}
14969
14970#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14971pub struct AddRoleMembersRequest {
14972 #[serde(
14976 default,
14977 skip_serializing_if = "Vec::is_empty",
14978 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
14979 )]
14980 pub members: Vec<Assistants>,
14981}
14982
14983#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
14984pub struct GroupMembersCreateResponse {
14985 #[serde(
14989 default,
14990 skip_serializing_if = "Option::is_none",
14991 deserialize_with = "crate::utils::date_time_format::deserialize"
14992 )]
14993 pub added_at: Option<chrono::DateTime<chrono::Utc>>,
14994 #[serde(
14998 default,
14999 skip_serializing_if = "String::is_empty",
15000 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15001 )]
15002 pub ids: String,
15003}
15004
15005#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
15011pub enum UpdateGroupMemberRequestAction {
15012 #[serde(rename = "move")]
15013 Move,
15014 #[serde(rename = "set_primary")]
15015 SetPrimary,
15016 #[serde(rename = "")]
15017 #[default]
15018 Noop,
15019 #[serde(other)]
15020 FallthroughString,
15021}
15022
15023impl std::fmt::Display for UpdateGroupMemberRequestAction {
15024 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15025 match self {
15026 UpdateGroupMemberRequestAction::Move => "move",
15027 UpdateGroupMemberRequestAction::SetPrimary => "set_primary",
15028 UpdateGroupMemberRequestAction::Noop => "",
15029 UpdateGroupMemberRequestAction::FallthroughString => "*",
15030 }
15031 .fmt(f)
15032 }
15033}
15034
15035impl UpdateGroupMemberRequestAction {
15036 pub fn is_noop(&self) -> bool {
15037 matches!(self, UpdateGroupMemberRequestAction::Noop)
15038 }
15039}
15040
15041#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15042pub struct UpdateGroupMemberRequest {
15043 #[serde(
15049 default,
15050 skip_serializing_if = "UpdateGroupMemberRequestAction::is_noop"
15051 )]
15052 pub action: UpdateGroupMemberRequestAction,
15053 #[serde(
15057 default,
15058 skip_serializing_if = "String::is_empty",
15059 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15060 )]
15061 pub target_group_id: String,
15062}
15063
15064#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15070pub struct DeviceCreateResponseAllOf {
15071 #[serde(flatten)]
15075 pub device: Device,
15076 #[serde(flatten)]
15077 pub groups: Groups,
15078}
15079
15080#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15086pub struct TrackingfieldGetResponseAllOf {
15087 #[serde(flatten)]
15088 pub groups: Groups,
15089 #[serde(flatten)]
15093 pub tracking_field: TrackingField,
15094}
15095
15096#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
15100pub enum ImGroupCreateRequestType {
15101 #[serde(rename = "normal")]
15102 #[default]
15103 Normal,
15104 #[serde(rename = "restricted")]
15105 Restricted,
15106 #[serde(rename = "shared")]
15107 Shared,
15108 #[serde(other)]
15109 FallthroughString,
15110}
15111
15112impl std::fmt::Display for ImGroupCreateRequestType {
15113 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15114 match self {
15115 ImGroupCreateRequestType::Normal => "normal",
15116 ImGroupCreateRequestType::Restricted => "restricted",
15117 ImGroupCreateRequestType::Shared => "shared",
15118 ImGroupCreateRequestType::FallthroughString => "*",
15119 }
15120 .fmt(f)
15121 }
15122}
15123
15124#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15125pub struct ImGroupCreateRequest {
15126 #[serde(
15130 default,
15131 skip_serializing_if = "String::is_empty",
15132 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15133 )]
15134 pub name: String,
15135 #[serde(default, skip_serializing_if = "Option::is_none")]
15139 pub search_by_account: Option<bool>,
15140 #[serde(default, skip_serializing_if = "Option::is_none")]
15144 pub search_by_domain: Option<bool>,
15145 #[serde(default, skip_serializing_if = "Option::is_none")]
15149 pub search_by_ma_account: Option<bool>,
15150 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
15154 pub type_: Option<ImGroupCreateRequestType>,
15155}
15156
15157#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15158pub struct ImGroupCreateResponse {
15159 #[serde(
15163 default,
15164 skip_serializing_if = "String::is_empty",
15165 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15166 )]
15167 pub id: String,
15168 #[serde(
15172 default,
15173 skip_serializing_if = "String::is_empty",
15174 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15175 )]
15176 pub name: String,
15177 #[serde(
15181 default,
15182 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
15183 )]
15184 pub search_by_account: bool,
15185 #[serde(
15189 default,
15190 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
15191 )]
15192 pub search_by_domain: bool,
15193 #[serde(
15197 default,
15198 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
15199 )]
15200 pub search_by_ma_account: bool,
15201 #[serde(
15205 default,
15206 skip_serializing_if = "crate::utils::zero_i64",
15207 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
15208 )]
15209 pub total_members: i64,
15210}
15211
15212#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15218pub struct ImGroupResponseAllOf {
15219 #[serde(flatten)]
15220 pub domains: Domains,
15221 #[serde(flatten)]
15222 pub groups: Groups,
15223}
15224
15225#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15226pub struct DashboardImResponse {
15227 #[serde(
15231 default,
15232 skip_serializing_if = "Option::is_none",
15233 deserialize_with = "crate::utils::date_format::deserialize"
15234 )]
15235 pub from: Option<chrono::NaiveDate>,
15236 #[serde(
15240 default,
15241 skip_serializing_if = "Option::is_none",
15242 deserialize_with = "crate::utils::date_format::deserialize"
15243 )]
15244 pub to: Option<chrono::NaiveDate>,
15245}
15246
15247#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
15251pub enum ImChatSessionsResponseType {
15252 #[serde(rename = "1:1")]
15253 One,
15254 #[serde(rename = "Group")]
15255 Group,
15256 #[serde(rename = "")]
15257 #[default]
15258 Noop,
15259 #[serde(other)]
15260 FallthroughString,
15261}
15262
15263impl std::fmt::Display for ImChatSessionsResponseType {
15264 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15265 match self {
15266 ImChatSessionsResponseType::One => "1:1",
15267 ImChatSessionsResponseType::Group => "Group",
15268 ImChatSessionsResponseType::Noop => "",
15269 ImChatSessionsResponseType::FallthroughString => "*",
15270 }
15271 .fmt(f)
15272 }
15273}
15274
15275impl ImChatSessionsResponseType {
15276 pub fn is_noop(&self) -> bool {
15277 matches!(self, ImChatSessionsResponseType::Noop)
15278 }
15279}
15280
15281#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15282pub struct Sessions {
15283 #[serde(
15287 default,
15288 skip_serializing_if = "Option::is_none",
15289 deserialize_with = "crate::utils::date_time_format::deserialize"
15290 )]
15291 pub last_message_sent_time: Option<chrono::DateTime<chrono::Utc>>,
15292 #[serde(
15296 default,
15297 skip_serializing_if = "String::is_empty",
15298 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15299 )]
15300 pub name: String,
15301 #[serde(
15305 default,
15306 skip_serializing_if = "String::is_empty",
15307 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15308 )]
15309 pub session_id: String,
15310 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
15314 pub type_: Option<ImChatSessionsResponseType>,
15315}
15316
15317#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15318pub struct ImChatSessionsResponseData {
15319 #[serde(
15323 default,
15324 skip_serializing_if = "Vec::is_empty",
15325 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
15326 )]
15327 pub sessions: Vec<Sessions>,
15328}
15329
15330#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15337pub struct ImChatSessionsResponseAllOf {
15338 #[serde(flatten)]
15342 pub pagination_token_4_im_chat: PaginationToken4ImChat,
15343 #[serde(flatten)]
15344 pub dashboard_im_response: DashboardImResponse,
15345 #[serde(flatten)]
15346 pub im_chat_sessions_response_data: ImChatSessionsResponseData,
15347}
15348
15349#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15350pub struct ImChatMessagesResponse {
15351 #[serde(
15355 default,
15356 skip_serializing_if = "Option::is_none",
15357 deserialize_with = "crate::utils::date_format::deserialize"
15358 )]
15359 pub from: Option<chrono::NaiveDate>,
15360 #[serde(
15364 default,
15365 skip_serializing_if = "String::is_empty",
15366 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15367 )]
15368 pub session_id: String,
15369 #[serde(
15373 default,
15374 skip_serializing_if = "Option::is_none",
15375 deserialize_with = "crate::utils::date_format::deserialize"
15376 )]
15377 pub to: Option<chrono::NaiveDate>,
15378}
15379
15380#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15381pub struct ImChatMessagesResponseData {
15382 #[serde(
15386 default,
15387 skip_serializing_if = "String::is_empty",
15388 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15389 )]
15390 pub action: String,
15391 #[serde(
15395 default,
15396 skip_serializing_if = "Option::is_none",
15397 deserialize_with = "crate::utils::date_time_format::deserialize"
15398 )]
15399 pub action_time: Option<chrono::DateTime<chrono::Utc>>,
15400 #[serde(
15404 default,
15405 skip_serializing_if = "Option::is_none",
15406 deserialize_with = "crate::utils::date_time_format::deserialize"
15407 )]
15408 pub date_time: Option<chrono::DateTime<chrono::Utc>>,
15409 #[serde(
15413 default,
15414 skip_serializing_if = "String::is_empty",
15415 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15416 )]
15417 pub message: String,
15418 #[serde(
15422 default,
15423 skip_serializing_if = "String::is_empty",
15424 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15425 )]
15426 pub sender: String,
15427}
15428
15429#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15430pub struct ImChatMessagesResponseDataType {
15431 #[serde(
15435 default,
15436 skip_serializing_if = "Vec::is_empty",
15437 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
15438 )]
15439 pub messages: Vec<ImChatMessagesResponseData>,
15440}
15441
15442#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15449pub struct ImChatMessagesResponseAllOf {
15450 #[serde(flatten)]
15454 pub pagination_token_4_im_chat: PaginationToken4ImChat,
15455 #[serde(flatten)]
15456 pub im_chat_messages_response: ImChatMessagesResponse,
15457 #[serde(flatten)]
15458 pub im_chat_messages_response_data_type: ImChatMessagesResponseDataType,
15459}
15460
15461#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
15465pub enum MeetingsType {
15466 #[serde(rename = "live")]
15467 #[default]
15468 Live,
15469 #[serde(rename = "scheduled")]
15470 Scheduled,
15471 #[serde(rename = "upcoming")]
15472 Upcoming,
15473 #[serde(other)]
15474 FallthroughString,
15475}
15476
15477impl std::fmt::Display for MeetingsType {
15478 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15479 match self {
15480 MeetingsType::Live => "live",
15481 MeetingsType::Scheduled => "scheduled",
15482 MeetingsType::Upcoming => "upcoming",
15483 MeetingsType::FallthroughString => "*",
15484 }
15485 .fmt(f)
15486 }
15487}
15488
15489#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15490pub struct MeetingCreateResponse {
15491 #[serde(
15495 default,
15496 skip_serializing_if = "String::is_empty",
15497 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15498 )]
15499 pub assistant_id: String,
15500 #[serde(
15504 default,
15505 skip_serializing_if = "String::is_empty",
15506 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15507 )]
15508 pub host_email: String,
15509 #[serde(
15513 default,
15514 skip_serializing_if = "crate::utils::zero_i64",
15515 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
15516 )]
15517 pub id: i64,
15518 #[serde(
15522 default,
15523 skip_serializing_if = "String::is_empty",
15524 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15525 )]
15526 pub registration_url: String,
15527}
15528
15529#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15535pub struct MeetingCreateResponseAllOf {
15536 #[serde(flatten)]
15540 pub meeting_info: MeetingInfo,
15541 #[serde(flatten)]
15542 pub meeting_create_response: MeetingCreateResponse,
15543}
15544
15545#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15546pub struct MeetingResponse {
15547 #[serde(
15551 default,
15552 skip_serializing_if = "String::is_empty",
15553 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15554 )]
15555 pub assistant_id: String,
15556 #[serde(
15560 default,
15561 skip_serializing_if = "String::is_empty",
15562 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15563 )]
15564 pub host_email: String,
15565 #[serde(
15569 default,
15570 skip_serializing_if = "String::is_empty",
15571 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15572 )]
15573 pub host_id: String,
15574 #[serde(
15578 default,
15579 skip_serializing_if = "crate::utils::zero_i64",
15580 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
15581 )]
15582 pub id: i64,
15583 #[serde(
15587 default,
15588 skip_serializing_if = "String::is_empty",
15589 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15590 )]
15591 pub uuid: String,
15592}
15593
15594#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15600pub struct MeetingResponseAllOf {
15601 #[serde(flatten)]
15605 pub meeting_info_get: MeetingInfoGet,
15606 #[serde(flatten)]
15607 pub meeting_response: MeetingResponse,
15608}
15609
15610#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15611pub struct MeetingUpdateRequest {
15612 #[serde(
15616 default,
15617 skip_serializing_if = "String::is_empty",
15618 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15619 )]
15620 pub schedule_for: String,
15621}
15622
15623#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15629pub struct MeetingUpdateRequestAllOf {
15630 #[serde(flatten)]
15631 pub domains: Domains,
15632 #[serde(flatten)]
15633 pub meeting_update_request: MeetingUpdateRequest,
15634}
15635
15636#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
15642pub enum MeetingStatusRequestAction {
15643 #[serde(rename = "end")]
15644 End,
15645 #[serde(rename = "recover")]
15646 Recover,
15647 #[serde(rename = "")]
15648 #[default]
15649 Noop,
15650 #[serde(other)]
15651 FallthroughString,
15652}
15653
15654impl std::fmt::Display for MeetingStatusRequestAction {
15655 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15656 match self {
15657 MeetingStatusRequestAction::End => "end",
15658 MeetingStatusRequestAction::Recover => "recover",
15659 MeetingStatusRequestAction::Noop => "",
15660 MeetingStatusRequestAction::FallthroughString => "*",
15661 }
15662 .fmt(f)
15663 }
15664}
15665
15666impl MeetingStatusRequestAction {
15667 pub fn is_noop(&self) -> bool {
15668 matches!(self, MeetingStatusRequestAction::Noop)
15669 }
15670}
15671
15672#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15673pub struct MeetingStatusRequest {
15674 #[serde(default, skip_serializing_if = "Option::is_none")]
15680 pub action: Option<MeetingStatusRequestAction>,
15681}
15682
15683#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
15687pub enum MeetingRegistrantsStatus {
15688 #[serde(rename = "approved")]
15689 #[default]
15690 Approved,
15691 #[serde(rename = "denied")]
15692 Denied,
15693 #[serde(rename = "pending")]
15694 Pending,
15695 #[serde(other)]
15696 FallthroughString,
15697}
15698
15699impl std::fmt::Display for MeetingRegistrantsStatus {
15700 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15701 match self {
15702 MeetingRegistrantsStatus::Approved => "approved",
15703 MeetingRegistrantsStatus::Denied => "denied",
15704 MeetingRegistrantsStatus::Pending => "pending",
15705 MeetingRegistrantsStatus::FallthroughString => "*",
15706 }
15707 .fmt(f)
15708 }
15709}
15710
15711#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15712pub struct MeetingRegistrantCreateResponse {
15713 #[serde(
15717 default,
15718 skip_serializing_if = "crate::utils::zero_i64",
15719 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
15720 )]
15721 pub id: i64,
15722 #[serde(
15726 default,
15727 skip_serializing_if = "String::is_empty",
15728 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15729 )]
15730 pub join_url: String,
15731 #[serde(
15735 default,
15736 skip_serializing_if = "String::is_empty",
15737 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15738 )]
15739 pub registrant_id: String,
15740 #[serde(
15744 default,
15745 skip_serializing_if = "String::is_empty",
15746 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15747 )]
15748 pub start_time: String,
15749 #[serde(
15753 default,
15754 skip_serializing_if = "String::is_empty",
15755 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15756 )]
15757 pub topic: String,
15758}
15759
15760#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15761pub struct PastMeetingDetailsResponse {
15762 #[serde(
15766 default,
15767 skip_serializing_if = "crate::utils::zero_i64",
15768 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
15769 )]
15770 pub duration: i64,
15771 #[serde(
15775 default,
15776 skip_serializing_if = "Option::is_none",
15777 deserialize_with = "crate::utils::date_time_format::deserialize"
15778 )]
15779 pub end_time: Option<chrono::DateTime<chrono::Utc>>,
15780 #[serde(
15784 default,
15785 skip_serializing_if = "String::is_empty",
15786 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15787 )]
15788 pub host_id: String,
15789 #[serde(
15793 default,
15794 skip_serializing_if = "crate::utils::zero_i64",
15795 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
15796 )]
15797 pub id: i64,
15798 #[serde(
15802 default,
15803 skip_serializing_if = "crate::utils::zero_i64",
15804 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
15805 )]
15806 pub participants_count: i64,
15807 #[serde(
15811 default,
15812 skip_serializing_if = "Option::is_none",
15813 deserialize_with = "crate::utils::date_time_format::deserialize"
15814 )]
15815 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
15816 #[serde(
15820 default,
15821 skip_serializing_if = "String::is_empty",
15822 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15823 )]
15824 pub topic: String,
15825 #[serde(
15829 default,
15830 skip_serializing_if = "crate::utils::zero_i64",
15831 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
15832 )]
15833 pub total_minutes: i64,
15834 #[serde(
15838 default,
15839 skip_serializing_if = "crate::utils::zero_i64",
15840 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
15841 rename = "type"
15842 )]
15843 pub type_: i64,
15844 #[serde(
15848 default,
15849 skip_serializing_if = "String::is_empty",
15850 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15851 )]
15852 pub user_email: String,
15853 #[serde(
15857 default,
15858 skip_serializing_if = "String::is_empty",
15859 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15860 )]
15861 pub user_name: String,
15862 #[serde(
15866 default,
15867 skip_serializing_if = "String::is_empty",
15868 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15869 )]
15870 pub uuid: String,
15871}
15872
15873#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15874pub struct Participants {
15875 #[serde(
15879 default,
15880 skip_serializing_if = "String::is_empty",
15881 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15882 )]
15883 pub id: String,
15884 #[serde(
15888 default,
15889 skip_serializing_if = "String::is_empty",
15890 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15891 )]
15892 pub name: String,
15893 #[serde(
15897 default,
15898 skip_serializing_if = "String::is_empty",
15899 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15900 )]
15901 pub user_email: String,
15902}
15903
15904#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15905pub struct PastMeetingParticipantsResponse {
15906 #[serde(
15910 default,
15911 skip_serializing_if = "Vec::is_empty",
15912 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
15913 )]
15914 pub participants: Vec<Participants>,
15915}
15916
15917#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15923pub struct PastMeetingParticipantsResponseAllOf {
15924 #[serde(flatten)]
15928 pub pagination_token: PaginationToken,
15929 #[serde(flatten)]
15930 pub past_meeting_participants_response: PastMeetingParticipantsResponse,
15931}
15932
15933#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
15937pub enum MeetingPollCreateResponseStatus {
15938 #[serde(rename = "ended")]
15939 Ended,
15940 #[serde(rename = "notstart")]
15941 Notstart,
15942 #[serde(rename = "sharing")]
15943 Sharing,
15944 #[serde(rename = "started")]
15945 Started,
15946 #[serde(rename = "")]
15947 #[default]
15948 Noop,
15949 #[serde(other)]
15950 FallthroughString,
15951}
15952
15953impl std::fmt::Display for MeetingPollCreateResponseStatus {
15954 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15955 match self {
15956 MeetingPollCreateResponseStatus::Ended => "ended",
15957 MeetingPollCreateResponseStatus::Notstart => "notstart",
15958 MeetingPollCreateResponseStatus::Sharing => "sharing",
15959 MeetingPollCreateResponseStatus::Started => "started",
15960 MeetingPollCreateResponseStatus::Noop => "",
15961 MeetingPollCreateResponseStatus::FallthroughString => "*",
15962 }
15963 .fmt(f)
15964 }
15965}
15966
15967impl MeetingPollCreateResponseStatus {
15968 pub fn is_noop(&self) -> bool {
15969 matches!(self, MeetingPollCreateResponseStatus::Noop)
15970 }
15971}
15972
15973#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15974pub struct MeetingPollGetResponse {
15975 #[serde(
15979 default,
15980 skip_serializing_if = "String::is_empty",
15981 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
15982 )]
15983 pub id: String,
15984 #[serde(default, skip_serializing_if = "Option::is_none")]
15988 pub status: Option<MeetingPollCreateResponseStatus>,
15989}
15990
15991#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
15997pub struct MeetingPollGetResponseAllOf {
15998 #[serde(flatten)]
16002 pub poll: Poll,
16003 #[serde(flatten)]
16004 pub meeting_poll_get_response: MeetingPollGetResponse,
16005}
16006
16007#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
16008pub struct RecordingGetResponse {
16009 #[serde(
16013 default,
16014 skip_serializing_if = "String::is_empty",
16015 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16016 )]
16017 pub download_access_token: String,
16018 #[serde(
16022 default,
16023 skip_serializing_if = "String::is_empty",
16024 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16025 )]
16026 pub password: String,
16027}
16028
16029#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
16035pub struct RecordingGetResponseAllOf {
16036 #[serde(flatten)]
16037 pub domains: Domains,
16038 #[serde(flatten)]
16039 pub recording_get_response: RecordingGetResponse,
16040}
16041
16042#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
16046pub enum RecordingDeleteAction {
16047 #[serde(rename = "delete")]
16048 Delete,
16049 #[serde(rename = "trash")]
16050 #[default]
16051 Trash,
16052 #[serde(other)]
16053 FallthroughString,
16054}
16055
16056impl std::fmt::Display for RecordingDeleteAction {
16057 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16058 match self {
16059 RecordingDeleteAction::Delete => "delete",
16060 RecordingDeleteAction::Trash => "trash",
16061 RecordingDeleteAction::FallthroughString => "*",
16062 }
16063 .fmt(f)
16064 }
16065}
16066
16067#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
16068pub struct MeetingRecordingRegistrantCreateResponse {
16069 #[serde(
16073 default,
16074 skip_serializing_if = "crate::utils::zero_i64",
16075 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
16076 )]
16077 pub id: i64,
16078 #[serde(
16082 default,
16083 skip_serializing_if = "String::is_empty",
16084 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16085 )]
16086 pub registrant_id: String,
16087 #[serde(
16091 default,
16092 skip_serializing_if = "String::is_empty",
16093 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16094 )]
16095 pub share_url: String,
16096 #[serde(
16100 default,
16101 skip_serializing_if = "String::is_empty",
16102 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16103 )]
16104 pub topic: String,
16105}
16106
16107#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
16113pub enum DashboardMeetingsType {
16114 #[serde(rename = "live")]
16115 #[default]
16116 Live,
16117 #[serde(rename = "past")]
16118 Past,
16119 #[serde(rename = "pastOne")]
16120 PastOne,
16121 #[serde(other)]
16122 FallthroughString,
16123}
16124
16125impl std::fmt::Display for DashboardMeetingsType {
16126 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16127 match self {
16128 DashboardMeetingsType::Live => "live",
16129 DashboardMeetingsType::Past => "past",
16130 DashboardMeetingsType::PastOne => "pastOne",
16131 DashboardMeetingsType::FallthroughString => "*",
16132 }
16133 .fmt(f)
16134 }
16135}
16136
16137#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
16141pub enum IncludeFields {
16142 #[serde(rename = "tracking_fields")]
16143 TrackingFields,
16144 #[serde(rename = "")]
16145 #[default]
16146 Noop,
16147 #[serde(other)]
16148 FallthroughString,
16149}
16150
16151impl std::fmt::Display for IncludeFields {
16152 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16153 match self {
16154 IncludeFields::TrackingFields => "tracking_fields",
16155 IncludeFields::Noop => "",
16156 IncludeFields::FallthroughString => "*",
16157 }
16158 .fmt(f)
16159 }
16160}
16161
16162impl IncludeFields {
16163 pub fn is_noop(&self) -> bool {
16164 matches!(self, IncludeFields::Noop)
16165 }
16166}
16167
16168#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
16169pub struct DashboardMeetingsResponse {
16170 #[serde(
16174 default,
16175 skip_serializing_if = "Vec::is_empty",
16176 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
16177 )]
16178 pub meetings: Vec<Metrics>,
16179}
16180
16181#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
16188pub struct DashboardMeetingsResponseAllOf {
16189 #[serde(flatten)]
16193 pub pagination_token: PaginationToken,
16194 #[serde(flatten)]
16195 pub dashboard_im_response: DashboardImResponse,
16196 #[serde(flatten)]
16197 pub dashboard_meetings_response: DashboardMeetingsResponse,
16198}
16199
16200#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
16204pub enum DashboardMeetingParticipantsIncludeFields {
16205 #[serde(rename = "registrant_id")]
16206 RegistrantId,
16207 #[serde(rename = "")]
16208 #[default]
16209 Noop,
16210 #[serde(other)]
16211 FallthroughString,
16212}
16213
16214impl std::fmt::Display for DashboardMeetingParticipantsIncludeFields {
16215 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16216 match self {
16217 DashboardMeetingParticipantsIncludeFields::RegistrantId => "registrant_id",
16218 DashboardMeetingParticipantsIncludeFields::Noop => "",
16219 DashboardMeetingParticipantsIncludeFields::FallthroughString => "*",
16220 }
16221 .fmt(f)
16222 }
16223}
16224
16225impl DashboardMeetingParticipantsIncludeFields {
16226 pub fn is_noop(&self) -> bool {
16227 matches!(self, DashboardMeetingParticipantsIncludeFields::Noop)
16228 }
16229}
16230
16231#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
16243pub enum DashboardMeetingParticipantsResponseDevice {
16244 #[serde(rename = "Android")]
16245 Android,
16246 #[serde(rename = "H.323/SIP")]
16247 H323Sip,
16248 #[serde(rename = "Mac")]
16249 Mac,
16250 #[serde(rename = "Phone")]
16251 Phone,
16252 #[serde(rename = "Windows")]
16253 Windows,
16254 #[serde(rename = "iOS")]
16255 IOs,
16256 #[serde(rename = "")]
16257 #[default]
16258 Noop,
16259 #[serde(other)]
16260 FallthroughString,
16261}
16262
16263impl std::fmt::Display for DashboardMeetingParticipantsResponseDevice {
16264 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16265 match self {
16266 DashboardMeetingParticipantsResponseDevice::Android => "Android",
16267 DashboardMeetingParticipantsResponseDevice::H323Sip => "H.323/SIP",
16268 DashboardMeetingParticipantsResponseDevice::Mac => "Mac",
16269 DashboardMeetingParticipantsResponseDevice::Phone => "Phone",
16270 DashboardMeetingParticipantsResponseDevice::Windows => "Windows",
16271 DashboardMeetingParticipantsResponseDevice::IOs => "iOS",
16272 DashboardMeetingParticipantsResponseDevice::Noop => "",
16273 DashboardMeetingParticipantsResponseDevice::FallthroughString => "*",
16274 }
16275 .fmt(f)
16276 }
16277}
16278
16279impl DashboardMeetingParticipantsResponseDevice {
16280 pub fn is_noop(&self) -> bool {
16281 matches!(self, DashboardMeetingParticipantsResponseDevice::Noop)
16282 }
16283}
16284
16285#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
16295pub enum NetworkType {
16296 #[serde(rename = "Cellular")]
16297 Cellular,
16298 #[serde(rename = "Others")]
16299 Others,
16300 #[serde(rename = "PPP")]
16301 Ppp,
16302 #[serde(rename = "Wifi")]
16303 Wifi,
16304 #[serde(rename = "Wired")]
16305 Wired,
16306 #[serde(rename = "")]
16307 #[default]
16308 Noop,
16309 #[serde(other)]
16310 FallthroughString,
16311}
16312
16313impl std::fmt::Display for NetworkType {
16314 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16315 match self {
16316 NetworkType::Cellular => "Cellular",
16317 NetworkType::Others => "Others",
16318 NetworkType::Ppp => "PPP",
16319 NetworkType::Wifi => "Wifi",
16320 NetworkType::Wired => "Wired",
16321 NetworkType::Noop => "",
16322 NetworkType::FallthroughString => "*",
16323 }
16324 .fmt(f)
16325 }
16326}
16327
16328impl NetworkType {
16329 pub fn is_noop(&self) -> bool {
16330 matches!(self, NetworkType::Noop)
16331 }
16332}
16333
16334#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
16338pub enum AudioQuality {
16339 #[serde(rename = "bad")]
16340 Bad,
16341 #[serde(rename = "fair")]
16342 Fair,
16343 #[serde(rename = "good")]
16344 Good,
16345 #[serde(rename = "poor")]
16346 Poor,
16347 #[serde(rename = "")]
16348 #[default]
16349 Noop,
16350 #[serde(other)]
16351 FallthroughString,
16352}
16353
16354impl std::fmt::Display for AudioQuality {
16355 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16356 match self {
16357 AudioQuality::Bad => "bad",
16358 AudioQuality::Fair => "fair",
16359 AudioQuality::Good => "good",
16360 AudioQuality::Poor => "poor",
16361 AudioQuality::Noop => "",
16362 AudioQuality::FallthroughString => "*",
16363 }
16364 .fmt(f)
16365 }
16366}
16367
16368impl AudioQuality {
16369 pub fn is_noop(&self) -> bool {
16370 matches!(self, AudioQuality::Noop)
16371 }
16372}
16373
16374#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
16380pub enum DashboardMeetingParticipantsResponseStatus {
16381 #[serde(rename = "in_meeting")]
16382 InMeeting,
16383 #[serde(rename = "in_waiting_room")]
16384 InWaitingRoom,
16385 #[serde(rename = "")]
16386 #[default]
16387 Noop,
16388 #[serde(other)]
16389 FallthroughString,
16390}
16391
16392impl std::fmt::Display for DashboardMeetingParticipantsResponseStatus {
16393 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16394 match self {
16395 DashboardMeetingParticipantsResponseStatus::InMeeting => "in_meeting",
16396 DashboardMeetingParticipantsResponseStatus::InWaitingRoom => "in_waiting_room",
16397 DashboardMeetingParticipantsResponseStatus::Noop => "",
16398 DashboardMeetingParticipantsResponseStatus::FallthroughString => "*",
16399 }
16400 .fmt(f)
16401 }
16402}
16403
16404impl DashboardMeetingParticipantsResponseStatus {
16405 pub fn is_noop(&self) -> bool {
16406 matches!(self, DashboardMeetingParticipantsResponseStatus::Noop)
16407 }
16408}
16409
16410#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
16411pub struct DashboardMeetingParticipantsResponse {
16412 #[serde(default, skip_serializing_if = "Option::is_none")]
16416 pub audio_quality: Option<AudioQuality>,
16417 #[serde(
16421 default,
16422 skip_serializing_if = "String::is_empty",
16423 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16424 )]
16425 pub camera: String,
16426 #[serde(
16430 default,
16431 skip_serializing_if = "String::is_empty",
16432 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16433 )]
16434 pub connection_type: String,
16435 #[serde(
16439 default,
16440 skip_serializing_if = "String::is_empty",
16441 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16442 )]
16443 pub customer_key: String,
16444 #[serde(
16448 default,
16449 skip_serializing_if = "String::is_empty",
16450 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16451 )]
16452 pub data_center: String,
16453 #[serde(default, skip_serializing_if = "Option::is_none")]
16465 pub device: Option<DashboardMeetingParticipantsResponseDevice>,
16466 #[serde(
16470 default,
16471 skip_serializing_if = "String::is_empty",
16472 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16473 )]
16474 pub domain: String,
16475 #[serde(
16479 default,
16480 skip_serializing_if = "String::is_empty",
16481 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16482 )]
16483 pub email: String,
16484 #[serde(
16488 default,
16489 skip_serializing_if = "String::is_empty",
16490 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16491 )]
16492 pub harddisk_id: String,
16493 #[serde(
16497 default,
16498 skip_serializing_if = "String::is_empty",
16499 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16500 )]
16501 pub id: String,
16502 #[serde(
16506 default,
16507 skip_serializing_if = "crate::utils::zero_i64",
16508 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
16509 )]
16510 pub in_room_participants: i64,
16511 #[serde(
16515 default,
16516 skip_serializing_if = "String::is_empty",
16517 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16518 )]
16519 pub ip_address: String,
16520 #[serde(
16524 default,
16525 skip_serializing_if = "Option::is_none",
16526 deserialize_with = "crate::utils::date_time_format::deserialize"
16527 )]
16528 pub join_time: Option<chrono::DateTime<chrono::Utc>>,
16529 #[serde(
16533 default,
16534 skip_serializing_if = "String::is_empty",
16535 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16536 )]
16537 pub leave_reason: String,
16538 #[serde(
16542 default,
16543 skip_serializing_if = "Option::is_none",
16544 deserialize_with = "crate::utils::date_time_format::deserialize"
16545 )]
16546 pub leave_time: Option<chrono::DateTime<chrono::Utc>>,
16547 #[serde(
16551 default,
16552 skip_serializing_if = "String::is_empty",
16553 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16554 )]
16555 pub location: String,
16556 #[serde(
16560 default,
16561 skip_serializing_if = "String::is_empty",
16562 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16563 )]
16564 pub mac_addr: String,
16565 #[serde(
16569 default,
16570 skip_serializing_if = "String::is_empty",
16571 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16572 )]
16573 pub microphone: String,
16574 #[serde(default, skip_serializing_if = "Option::is_none")]
16584 pub network_type: Option<NetworkType>,
16585 #[serde(
16589 default,
16590 skip_serializing_if = "String::is_empty",
16591 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16592 )]
16593 pub pc_name: String,
16594 #[serde(
16598 default,
16599 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
16600 )]
16601 pub recording: bool,
16602 #[serde(
16606 default,
16607 skip_serializing_if = "String::is_empty",
16608 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16609 )]
16610 pub registrant_id: String,
16611 #[serde(default, skip_serializing_if = "Option::is_none")]
16615 pub screen_share_quality: Option<AudioQuality>,
16616 #[serde(
16620 default,
16621 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
16622 )]
16623 pub share_application: bool,
16624 #[serde(
16628 default,
16629 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
16630 )]
16631 pub share_desktop: bool,
16632 #[serde(
16636 default,
16637 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
16638 )]
16639 pub share_whiteboard: bool,
16640 #[serde(
16644 default,
16645 skip_serializing_if = "String::is_empty",
16646 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16647 )]
16648 pub speaker: String,
16649 #[serde(default, skip_serializing_if = "Option::is_none")]
16655 pub status: Option<DashboardMeetingParticipantsResponseStatus>,
16656 #[serde(
16660 default,
16661 skip_serializing_if = "String::is_empty",
16662 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16663 )]
16664 pub user_id: String,
16665 #[serde(
16669 default,
16670 skip_serializing_if = "String::is_empty",
16671 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16672 )]
16673 pub user_name: String,
16674 #[serde(
16678 default,
16679 skip_serializing_if = "String::is_empty",
16680 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16681 )]
16682 pub version: String,
16683 #[serde(default, skip_serializing_if = "Option::is_none")]
16687 pub video_quality: Option<AudioQuality>,
16688}
16689
16690#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
16691pub struct DashboardMeetingParticipantsResponseData {
16692 #[serde(
16698 default,
16699 skip_serializing_if = "Vec::is_empty",
16700 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
16701 )]
16702 pub participants: Vec<DashboardMeetingParticipantsResponse>,
16703}
16704
16705#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
16711pub struct DashboardMeetingParticipantsResponseAllOf {
16712 #[serde(flatten)]
16716 pub pagination_token: PaginationToken,
16717 #[serde(flatten)]
16718 pub dashboard_meeting_participants_response_data: DashboardMeetingParticipantsResponseData,
16719}
16720
16721#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
16722pub struct Details {
16723 #[serde(
16727 default,
16728 skip_serializing_if = "String::is_empty",
16729 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16730 )]
16731 pub content: String,
16732 #[serde(
16736 default,
16737 skip_serializing_if = "String::is_empty",
16738 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16739 )]
16740 pub end_time: String,
16741 #[serde(
16745 default,
16746 skip_serializing_if = "String::is_empty",
16747 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16748 )]
16749 pub start_time: String,
16750}
16751
16752#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
16753pub struct DashboardMeetingParticipantShareResponseParticipants {
16754 #[serde(
16758 default,
16759 skip_serializing_if = "Vec::is_empty",
16760 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
16761 )]
16762 pub details: Vec<Details>,
16763 #[serde(
16767 default,
16768 skip_serializing_if = "String::is_empty",
16769 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16770 )]
16771 pub id: String,
16772 #[serde(
16776 default,
16777 skip_serializing_if = "String::is_empty",
16778 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16779 )]
16780 pub user_id: String,
16781 #[serde(
16785 default,
16786 skip_serializing_if = "String::is_empty",
16787 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16788 )]
16789 pub user_name: String,
16790}
16791
16792#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
16793pub struct DashboardMeetingParticipantShareResponse {
16794 #[serde(
16798 default,
16799 skip_serializing_if = "Vec::is_empty",
16800 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
16801 )]
16802 pub participants: Vec<DashboardMeetingParticipantShareResponseParticipants>,
16803}
16804
16805#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
16811pub struct DashboardMeetingParticipantShareResponseAllOf {
16812 #[serde(flatten)]
16816 pub pagination_token: PaginationToken,
16817 #[serde(flatten)]
16818 pub dashboard_meeting_participant_share_response: DashboardMeetingParticipantShareResponse,
16819}
16820
16821#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
16825pub enum DashboardWebinarsType {
16826 #[serde(rename = "live")]
16827 #[default]
16828 Live,
16829 #[serde(rename = "past")]
16830 Past,
16831 #[serde(other)]
16832 FallthroughString,
16833}
16834
16835impl std::fmt::Display for DashboardWebinarsType {
16836 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16837 match self {
16838 DashboardWebinarsType::Live => "live",
16839 DashboardWebinarsType::Past => "past",
16840 DashboardWebinarsType::FallthroughString => "*",
16841 }
16842 .fmt(f)
16843 }
16844}
16845
16846#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
16847pub struct DashboardWebinarsResponse {
16848 #[serde(
16852 default,
16853 skip_serializing_if = "Vec::is_empty",
16854 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
16855 )]
16856 pub webinars: Vec<Webinars>,
16857}
16858
16859#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
16866pub struct DashboardWebinarsResponseAllOf {
16867 #[serde(flatten)]
16871 pub pagination_token: PaginationToken,
16872 #[serde(flatten)]
16873 pub dashboard_im_response: DashboardImResponse,
16874 #[serde(flatten)]
16875 pub dashboard_webinars_response: DashboardWebinarsResponse,
16876}
16877
16878#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
16879pub struct DashboardWebinarParticipantsResponse {
16880 #[serde(default, skip_serializing_if = "Option::is_none")]
16884 pub audio_quality: Option<AudioQuality>,
16885 #[serde(
16889 default,
16890 skip_serializing_if = "String::is_empty",
16891 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16892 )]
16893 pub connection_type: String,
16894 #[serde(
16898 default,
16899 skip_serializing_if = "String::is_empty",
16900 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16901 )]
16902 pub customer_key: String,
16903 #[serde(
16907 default,
16908 skip_serializing_if = "String::is_empty",
16909 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16910 )]
16911 pub data_center: String,
16912 #[serde(default, skip_serializing_if = "Option::is_none")]
16924 pub device: Option<DashboardMeetingParticipantsResponseDevice>,
16925 #[serde(
16929 default,
16930 skip_serializing_if = "String::is_empty",
16931 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16932 )]
16933 pub domain: String,
16934 #[serde(
16938 default,
16939 skip_serializing_if = "String::is_empty",
16940 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16941 )]
16942 pub email: String,
16943 #[serde(
16947 default,
16948 skip_serializing_if = "String::is_empty",
16949 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16950 )]
16951 pub harddisk_id: String,
16952 #[serde(
16956 default,
16957 skip_serializing_if = "String::is_empty",
16958 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16959 )]
16960 pub id: String,
16961 #[serde(
16965 default,
16966 skip_serializing_if = "String::is_empty",
16967 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16968 )]
16969 pub ip_address: String,
16970 #[serde(
16974 default,
16975 skip_serializing_if = "Option::is_none",
16976 deserialize_with = "crate::utils::date_time_format::deserialize"
16977 )]
16978 pub join_time: Option<chrono::DateTime<chrono::Utc>>,
16979 #[serde(
16983 default,
16984 skip_serializing_if = "String::is_empty",
16985 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
16986 )]
16987 pub leave_reason: String,
16988 #[serde(
16992 default,
16993 skip_serializing_if = "Option::is_none",
16994 deserialize_with = "crate::utils::date_time_format::deserialize"
16995 )]
16996 pub leave_time: Option<chrono::DateTime<chrono::Utc>>,
16997 #[serde(
17001 default,
17002 skip_serializing_if = "String::is_empty",
17003 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17004 )]
17005 pub location: String,
17006 #[serde(
17010 default,
17011 skip_serializing_if = "String::is_empty",
17012 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17013 )]
17014 pub mac_addr: String,
17015 #[serde(
17019 default,
17020 skip_serializing_if = "String::is_empty",
17021 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17022 )]
17023 pub microphone: String,
17024 #[serde(
17028 default,
17029 skip_serializing_if = "String::is_empty",
17030 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17031 )]
17032 pub network_type: String,
17033 #[serde(
17037 default,
17038 skip_serializing_if = "String::is_empty",
17039 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17040 )]
17041 pub pc_name: String,
17042 #[serde(
17046 default,
17047 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
17048 )]
17049 pub recording: bool,
17050 #[serde(
17054 default,
17055 skip_serializing_if = "String::is_empty",
17056 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17057 )]
17058 pub registrant_id: String,
17059 #[serde(default, skip_serializing_if = "Option::is_none")]
17063 pub screen_share_quality: Option<AudioQuality>,
17064 #[serde(
17068 default,
17069 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
17070 )]
17071 pub share_application: bool,
17072 #[serde(
17076 default,
17077 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
17078 )]
17079 pub share_desktop: bool,
17080 #[serde(
17084 default,
17085 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
17086 )]
17087 pub share_whiteboard: bool,
17088 #[serde(
17092 default,
17093 skip_serializing_if = "String::is_empty",
17094 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17095 )]
17096 pub speaker: String,
17097 #[serde(
17101 default,
17102 skip_serializing_if = "String::is_empty",
17103 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17104 )]
17105 pub user_id: String,
17106 #[serde(
17110 default,
17111 skip_serializing_if = "String::is_empty",
17112 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17113 )]
17114 pub user_name: String,
17115 #[serde(
17119 default,
17120 skip_serializing_if = "String::is_empty",
17121 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17122 )]
17123 pub version: String,
17124 #[serde(default, skip_serializing_if = "Option::is_none")]
17128 pub video_quality: Option<AudioQuality>,
17129}
17130
17131#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17132pub struct DashboardWebinarParticipantsResponseData {
17133 #[serde(
17139 default,
17140 skip_serializing_if = "Vec::is_empty",
17141 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
17142 )]
17143 pub participants: Vec<DashboardWebinarParticipantsResponse>,
17144}
17145
17146#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17152pub struct DashboardWebinarParticipantsResponseAllOf {
17153 #[serde(flatten)]
17157 pub pagination_token: PaginationToken,
17158 #[serde(flatten)]
17159 pub dashboard_webinar_participants_response_data: DashboardWebinarParticipantsResponseData,
17160}
17161
17162#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17163pub struct Users {
17164 #[serde(
17168 default,
17169 skip_serializing_if = "crate::utils::zero_i64",
17170 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17171 )]
17172 pub calls_receive: i64,
17173 #[serde(
17177 default,
17178 skip_serializing_if = "crate::utils::zero_i64",
17179 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17180 )]
17181 pub calls_send: i64,
17182 #[serde(
17186 default,
17187 skip_serializing_if = "String::is_empty",
17188 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17189 )]
17190 pub email: String,
17191 #[serde(
17195 default,
17196 skip_serializing_if = "crate::utils::zero_i64",
17197 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17198 )]
17199 pub emoji_receive: i64,
17200 #[serde(
17204 default,
17205 skip_serializing_if = "crate::utils::zero_i64",
17206 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17207 )]
17208 pub emoji_send: i64,
17209 #[serde(
17213 default,
17214 skip_serializing_if = "crate::utils::zero_i64",
17215 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17216 )]
17217 pub files_receive: i64,
17218 #[serde(
17222 default,
17223 skip_serializing_if = "crate::utils::zero_i64",
17224 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17225 )]
17226 pub files_send: i64,
17227 #[serde(
17231 default,
17232 skip_serializing_if = "crate::utils::zero_i64",
17233 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17234 )]
17235 pub group_receive: i64,
17236 #[serde(
17240 default,
17241 skip_serializing_if = "crate::utils::zero_i64",
17242 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17243 )]
17244 pub group_send: i64,
17245 #[serde(
17249 default,
17250 skip_serializing_if = "crate::utils::zero_i64",
17251 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17252 )]
17253 pub images_receive: i64,
17254 #[serde(
17258 default,
17259 skip_serializing_if = "crate::utils::zero_i64",
17260 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17261 )]
17262 pub images_send: i64,
17263 #[serde(
17267 default,
17268 skip_serializing_if = "crate::utils::zero_i64",
17269 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17270 )]
17271 pub total_receive: i64,
17272 #[serde(
17276 default,
17277 skip_serializing_if = "crate::utils::zero_i64",
17278 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17279 )]
17280 pub total_send: i64,
17281 #[serde(
17285 default,
17286 skip_serializing_if = "String::is_empty",
17287 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17288 )]
17289 pub user_id: String,
17290 #[serde(
17294 default,
17295 skip_serializing_if = "String::is_empty",
17296 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17297 )]
17298 pub user_name: String,
17299 #[serde(
17303 default,
17304 skip_serializing_if = "crate::utils::zero_i64",
17305 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17306 )]
17307 pub videos_receive: i64,
17308 #[serde(
17312 default,
17313 skip_serializing_if = "crate::utils::zero_i64",
17314 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17315 )]
17316 pub videos_send: i64,
17317 #[serde(
17321 default,
17322 skip_serializing_if = "crate::utils::zero_i64",
17323 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17324 )]
17325 pub voice_receive: i64,
17326 #[serde(
17330 default,
17331 skip_serializing_if = "crate::utils::zero_i64",
17332 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17333 )]
17334 pub voice_send: i64,
17335}
17336
17337#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17338pub struct DashboardImResponseData {
17339 #[serde(
17340 default,
17341 skip_serializing_if = "Vec::is_empty",
17342 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
17343 )]
17344 pub users: Vec<Users>,
17345}
17346
17347#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17354pub struct DashboardImResponseAllOf {
17355 #[serde(flatten)]
17359 pub pagination_token: PaginationToken,
17360 #[serde(flatten)]
17361 pub dashboard_im_response: DashboardImResponse,
17362 #[serde(flatten)]
17363 pub dashboard_im_response_data: DashboardImResponseData,
17364}
17365
17366#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17367pub struct DashboardChatResponse {
17368 #[serde(
17372 default,
17373 skip_serializing_if = "Option::is_none",
17374 deserialize_with = "crate::utils::date_format::deserialize"
17375 )]
17376 pub from: Option<chrono::NaiveDate>,
17377 #[serde(
17381 default,
17382 skip_serializing_if = "String::is_empty",
17383 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17384 )]
17385 pub next_page_token: String,
17386 #[serde(
17390 default,
17391 skip_serializing_if = "crate::utils::zero_i64",
17392 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17393 )]
17394 pub page_size: i64,
17395 #[serde(
17399 default,
17400 skip_serializing_if = "Option::is_none",
17401 deserialize_with = "crate::utils::date_format::deserialize"
17402 )]
17403 pub to: Option<chrono::NaiveDate>,
17404}
17405
17406#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17407pub struct DashboardChatResponseUsers {
17408 #[serde(
17412 default,
17413 skip_serializing_if = "crate::utils::zero_i64",
17414 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17415 )]
17416 pub audio_sent: i64,
17417 #[serde(
17421 default,
17422 skip_serializing_if = "crate::utils::zero_i64",
17423 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17424 )]
17425 pub code_sippet_sent: i64,
17426 #[serde(
17430 default,
17431 skip_serializing_if = "String::is_empty",
17432 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17433 )]
17434 pub email: String,
17435 #[serde(
17439 default,
17440 skip_serializing_if = "crate::utils::zero_i64",
17441 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17442 )]
17443 pub files_sent: i64,
17444 #[serde(
17448 default,
17449 skip_serializing_if = "crate::utils::zero_i64",
17450 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17451 )]
17452 pub giphys_sent: i64,
17453 #[serde(
17457 default,
17458 skip_serializing_if = "crate::utils::zero_i64",
17459 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17460 )]
17461 pub group_sent: i64,
17462 #[serde(
17466 default,
17467 skip_serializing_if = "crate::utils::zero_i64",
17468 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17469 )]
17470 pub images_sent: i64,
17471 #[serde(
17475 default,
17476 skip_serializing_if = "crate::utils::zero_i64",
17477 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
17478 rename = "p2p_sent"
17479 )]
17480 pub p_2p_sent: i64,
17481 #[serde(
17485 default,
17486 skip_serializing_if = "crate::utils::zero_i64",
17487 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17488 )]
17489 pub text_sent: i64,
17490 #[serde(
17494 default,
17495 skip_serializing_if = "crate::utils::zero_i64",
17496 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17497 )]
17498 pub total_sent: i64,
17499 #[serde(
17503 default,
17504 skip_serializing_if = "String::is_empty",
17505 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17506 )]
17507 pub user_id: String,
17508 #[serde(
17512 default,
17513 skip_serializing_if = "String::is_empty",
17514 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17515 )]
17516 pub user_name: String,
17517 #[serde(
17521 default,
17522 skip_serializing_if = "crate::utils::zero_i64",
17523 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17524 )]
17525 pub video_sent: i64,
17526}
17527
17528#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17529pub struct DashboardChatResponseData {
17530 #[serde(
17531 default,
17532 skip_serializing_if = "Vec::is_empty",
17533 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
17534 )]
17535 pub users: Vec<DashboardChatResponseUsers>,
17536}
17537
17538#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17544pub struct DashboardChatResponseAllOf {
17545 #[serde(flatten)]
17546 pub dashboard_chat_response: DashboardChatResponse,
17547 #[serde(flatten)]
17548 pub dashboard_chat_response_data: DashboardChatResponseData,
17549}
17550
17551#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17552pub struct ClientFeedbacks {
17553 #[serde(
17557 default,
17558 skip_serializing_if = "String::is_empty",
17559 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17560 )]
17561 pub feedback_id: String,
17562 #[serde(
17566 default,
17567 skip_serializing_if = "String::is_empty",
17568 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17569 )]
17570 pub feedback_name: String,
17571 #[serde(
17575 default,
17576 skip_serializing_if = "crate::utils::zero_i64",
17577 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17578 )]
17579 pub participants_count: i64,
17580}
17581
17582#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17583pub struct DashboardClientFeedbackResponse {
17584 #[serde(
17585 default,
17586 skip_serializing_if = "Vec::is_empty",
17587 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
17588 )]
17589 pub client_feedbacks: Vec<ClientFeedbacks>,
17590 #[serde(
17594 default,
17595 skip_serializing_if = "Option::is_none",
17596 deserialize_with = "crate::utils::date_format::deserialize"
17597 )]
17598 pub from: Option<chrono::NaiveDate>,
17599 #[serde(
17603 default,
17604 skip_serializing_if = "Option::is_none",
17605 deserialize_with = "crate::utils::date_format::deserialize"
17606 )]
17607 pub to: Option<chrono::NaiveDate>,
17608 #[serde(
17612 default,
17613 skip_serializing_if = "crate::utils::zero_i64",
17614 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17615 )]
17616 pub total_records: i64,
17617}
17618
17619#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17620pub struct DashboardIssueZoomRoomResponse {
17621 #[serde(
17625 default,
17626 skip_serializing_if = "Option::is_none",
17627 deserialize_with = "crate::utils::date_format::deserialize"
17628 )]
17629 pub from: Option<chrono::NaiveDate>,
17630 #[serde(
17634 default,
17635 skip_serializing_if = "Option::is_none",
17636 deserialize_with = "crate::utils::date_format::deserialize"
17637 )]
17638 pub to: Option<chrono::NaiveDate>,
17639 #[serde(
17643 default,
17644 skip_serializing_if = "crate::utils::zero_i64",
17645 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17646 )]
17647 pub total_records: i64,
17648}
17649
17650#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17651pub struct DashboardIssueZoomRoomResponseData {
17652 #[serde(
17659 default,
17660 skip_serializing_if = "Vec::is_empty",
17661 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
17662 )]
17663 pub zoom_rooms: Vec<String>,
17664}
17665
17666#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17672pub struct DashboardIssueZoomRoomResponseAllOf {
17673 #[serde(flatten)]
17674 pub dashboard_issue_zoom_room_response: DashboardIssueZoomRoomResponse,
17675 #[serde(flatten)]
17676 pub dashboard_issue_zoom_room_response_data: DashboardIssueZoomRoomResponseData,
17677}
17678
17679#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17680pub struct IssueDetails {
17681 #[serde(
17685 default,
17686 skip_serializing_if = "String::is_empty",
17687 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17688 )]
17689 pub issue: String,
17690 #[serde(
17694 default,
17695 skip_serializing_if = "Option::is_none",
17696 deserialize_with = "crate::utils::date_time_format::deserialize"
17697 )]
17698 pub time: Option<chrono::DateTime<chrono::Utc>>,
17699}
17700
17701#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17702pub struct DashboardIssueDetailZoomRoomResponse {
17703 #[serde(
17704 default,
17705 skip_serializing_if = "Vec::is_empty",
17706 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
17707 )]
17708 pub issue_details: Vec<IssueDetails>,
17709}
17710
17711#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17718pub struct DashboardIssueDetailZoomRoomResponseAllOf {
17719 #[serde(flatten)]
17723 pub pagination_token: PaginationToken,
17724 #[serde(flatten)]
17725 pub dashboard_im_response: DashboardImResponse,
17726 #[serde(flatten)]
17727 pub dashboard_issue_detail_zoom_room_response: DashboardIssueDetailZoomRoomResponse,
17728}
17729
17730#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17731pub struct Dates {
17732 #[serde(
17736 default,
17737 skip_serializing_if = "Option::is_none",
17738 deserialize_with = "crate::utils::date_format::deserialize"
17739 )]
17740 pub date: Option<chrono::NaiveDate>,
17741 #[serde(
17745 default,
17746 skip_serializing_if = "crate::utils::zero_i64",
17747 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17748 )]
17749 pub meeting_minutes: i64,
17750 #[serde(
17754 default,
17755 skip_serializing_if = "crate::utils::zero_i64",
17756 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17757 )]
17758 pub meetings: i64,
17759 #[serde(
17763 default,
17764 skip_serializing_if = "crate::utils::zero_i64",
17765 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17766 )]
17767 pub new_users: i64,
17768 #[serde(
17772 default,
17773 skip_serializing_if = "crate::utils::zero_i64",
17774 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17775 )]
17776 pub participants: i64,
17777}
17778
17779#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17780pub struct ReportDailyResponse {
17781 #[serde(
17785 default,
17786 skip_serializing_if = "Vec::is_empty",
17787 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
17788 )]
17789 pub dates: Vec<Dates>,
17790 #[serde(
17794 default,
17795 skip_serializing_if = "crate::utils::zero_i64",
17796 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17797 )]
17798 pub month: i64,
17799 #[serde(
17803 default,
17804 skip_serializing_if = "crate::utils::zero_i64",
17805 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17806 )]
17807 pub year: i64,
17808}
17809
17810#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
17814pub enum ReportUsersType {
17815 #[serde(rename = "active")]
17816 Active,
17817 #[serde(rename = "inactive")]
17818 Inactive,
17819 #[serde(rename = "")]
17820 #[default]
17821 Noop,
17822 #[serde(other)]
17823 FallthroughString,
17824}
17825
17826impl std::fmt::Display for ReportUsersType {
17827 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17828 match self {
17829 ReportUsersType::Active => "active",
17830 ReportUsersType::Inactive => "inactive",
17831 ReportUsersType::Noop => "",
17832 ReportUsersType::FallthroughString => "*",
17833 }
17834 .fmt(f)
17835 }
17836}
17837
17838impl ReportUsersType {
17839 pub fn is_noop(&self) -> bool {
17840 matches!(self, ReportUsersType::Noop)
17841 }
17842}
17843
17844#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
17848pub enum ReportMeetingsType {
17849 #[serde(rename = "past")]
17850 #[default]
17851 Past,
17852 #[serde(rename = "pastOne")]
17853 PastOne,
17854 #[serde(other)]
17855 FallthroughString,
17856}
17857
17858impl std::fmt::Display for ReportMeetingsType {
17859 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17860 match self {
17861 ReportMeetingsType::Past => "past",
17862 ReportMeetingsType::PastOne => "pastOne",
17863 ReportMeetingsType::FallthroughString => "*",
17864 }
17865 .fmt(f)
17866 }
17867}
17868
17869#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17870pub struct Meetings {
17871 #[serde(
17875 default,
17876 skip_serializing_if = "Vec::is_empty",
17877 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
17878 )]
17879 pub custom_keys: Vec<CustomKeys>,
17880 #[serde(
17884 default,
17885 skip_serializing_if = "crate::utils::zero_i64",
17886 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17887 )]
17888 pub duration: i64,
17889 #[serde(
17893 default,
17894 skip_serializing_if = "Option::is_none",
17895 deserialize_with = "crate::utils::date_time_format::deserialize"
17896 )]
17897 pub end_time: Option<chrono::DateTime<chrono::Utc>>,
17898 #[serde(
17902 default,
17903 skip_serializing_if = "crate::utils::zero_i64",
17904 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17905 )]
17906 pub id: i64,
17907 #[serde(
17911 default,
17912 skip_serializing_if = "crate::utils::zero_i64",
17913 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17914 )]
17915 pub participants_count: i64,
17916 #[serde(
17920 default,
17921 skip_serializing_if = "String::is_empty",
17922 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17923 )]
17924 pub source: String,
17925 #[serde(
17929 default,
17930 skip_serializing_if = "Option::is_none",
17931 deserialize_with = "crate::utils::date_time_format::deserialize"
17932 )]
17933 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
17934 #[serde(
17938 default,
17939 skip_serializing_if = "String::is_empty",
17940 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17941 )]
17942 pub topic: String,
17943 #[serde(
17947 default,
17948 skip_serializing_if = "crate::utils::zero_i64",
17949 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
17950 )]
17951 pub total_minutes: i64,
17952 #[serde(
17956 default,
17957 skip_serializing_if = "crate::utils::zero_i64",
17958 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
17959 rename = "type"
17960 )]
17961 pub type_: i64,
17962 #[serde(
17966 default,
17967 skip_serializing_if = "String::is_empty",
17968 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17969 )]
17970 pub user_email: String,
17971 #[serde(
17975 default,
17976 skip_serializing_if = "String::is_empty",
17977 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17978 )]
17979 pub user_name: String,
17980 #[serde(
17984 default,
17985 skip_serializing_if = "String::is_empty",
17986 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
17987 )]
17988 pub uuid: String,
17989}
17990
17991#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
17992pub struct ReportMeetingsResponse {
17993 #[serde(
17997 default,
17998 skip_serializing_if = "Option::is_none",
17999 deserialize_with = "crate::utils::date_format::deserialize"
18000 )]
18001 pub from: Option<chrono::NaiveDate>,
18002 #[serde(
18006 default,
18007 skip_serializing_if = "Vec::is_empty",
18008 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
18009 )]
18010 pub meetings: Vec<Meetings>,
18011 #[serde(
18015 default,
18016 skip_serializing_if = "String::is_empty",
18017 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18018 )]
18019 pub next_page_token: String,
18020 #[serde(
18024 default,
18025 skip_serializing_if = "Option::is_none",
18026 deserialize_with = "crate::utils::date_format::deserialize"
18027 )]
18028 pub to: Option<chrono::NaiveDate>,
18029}
18030
18031#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18037pub struct ReportMeetingsResponseAllOf {
18038 #[serde(flatten)]
18042 pub pagination: Pagination,
18043 #[serde(flatten)]
18044 pub report_meetings_response: ReportMeetingsResponse,
18045}
18046
18047#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18048pub struct ReportMeetingDetailsResponse {
18049 #[serde(
18053 default,
18054 skip_serializing_if = "Vec::is_empty",
18055 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
18056 )]
18057 pub custom_keys: Vec<CustomKeys>,
18058 #[serde(
18062 default,
18063 skip_serializing_if = "String::is_empty",
18064 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18065 )]
18066 pub dept: String,
18067 #[serde(
18071 default,
18072 skip_serializing_if = "crate::utils::zero_i64",
18073 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
18074 )]
18075 pub duration: i64,
18076 #[serde(
18080 default,
18081 skip_serializing_if = "Option::is_none",
18082 deserialize_with = "crate::utils::date_time_format::deserialize"
18083 )]
18084 pub end_time: Option<chrono::DateTime<chrono::Utc>>,
18085 #[serde(
18089 default,
18090 skip_serializing_if = "crate::utils::zero_i64",
18091 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
18092 )]
18093 pub id: i64,
18094 #[serde(
18098 default,
18099 skip_serializing_if = "crate::utils::zero_i64",
18100 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
18101 )]
18102 pub participants_count: i64,
18103 #[serde(
18107 default,
18108 skip_serializing_if = "Option::is_none",
18109 deserialize_with = "crate::utils::date_time_format::deserialize"
18110 )]
18111 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
18112 #[serde(
18116 default,
18117 skip_serializing_if = "String::is_empty",
18118 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18119 )]
18120 pub topic: String,
18121 #[serde(
18125 default,
18126 skip_serializing_if = "crate::utils::zero_i64",
18127 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
18128 )]
18129 pub total_minutes: i64,
18130 #[serde(
18134 default,
18135 skip_serializing_if = "Vec::is_empty",
18136 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
18137 )]
18138 pub tracking_fields: Vec<SessionUpdateTrackingFields>,
18139 #[serde(
18143 default,
18144 skip_serializing_if = "crate::utils::zero_i64",
18145 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
18146 rename = "type"
18147 )]
18148 pub type_: i64,
18149 #[serde(
18153 default,
18154 skip_serializing_if = "String::is_empty",
18155 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18156 )]
18157 pub user_email: String,
18158 #[serde(
18162 default,
18163 skip_serializing_if = "String::is_empty",
18164 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18165 )]
18166 pub user_name: String,
18167 #[serde(
18171 default,
18172 skip_serializing_if = "String::is_empty",
18173 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18174 )]
18175 pub uuid: String,
18176}
18177
18178#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18179pub struct ReportMeetingParticipantsResponse {
18180 #[serde(
18184 default,
18185 skip_serializing_if = "String::is_empty",
18186 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18187 )]
18188 pub customer_key: String,
18189 #[serde(
18193 default,
18194 skip_serializing_if = "crate::utils::zero_i64",
18195 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
18196 )]
18197 pub duration: i64,
18198 #[serde(
18202 default,
18203 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
18204 )]
18205 pub failover: bool,
18206 #[serde(
18210 default,
18211 skip_serializing_if = "String::is_empty",
18212 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18213 )]
18214 pub id: String,
18215 #[serde(
18219 default,
18220 skip_serializing_if = "Option::is_none",
18221 deserialize_with = "crate::utils::date_time_format::deserialize"
18222 )]
18223 pub join_time: Option<chrono::DateTime<chrono::Utc>>,
18224 #[serde(
18228 default,
18229 skip_serializing_if = "Option::is_none",
18230 deserialize_with = "crate::utils::date_time_format::deserialize"
18231 )]
18232 pub leave_time: Option<chrono::DateTime<chrono::Utc>>,
18233 #[serde(
18237 default,
18238 skip_serializing_if = "String::is_empty",
18239 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18240 )]
18241 pub name: String,
18242 #[serde(
18246 default,
18247 skip_serializing_if = "String::is_empty",
18248 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18249 )]
18250 pub registrant_id: String,
18251 #[serde(
18255 default,
18256 skip_serializing_if = "String::is_empty",
18257 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18258 )]
18259 pub user_email: String,
18260 #[serde(
18264 default,
18265 skip_serializing_if = "String::is_empty",
18266 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18267 )]
18268 pub user_id: String,
18269}
18270
18271#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18272pub struct ReportMeetingParticipantsResponseData {
18273 #[serde(
18279 default,
18280 skip_serializing_if = "Vec::is_empty",
18281 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
18282 )]
18283 pub participants: Vec<ReportMeetingParticipantsResponse>,
18284}
18285
18286#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18292pub struct ReportMeetingParticipantsResponseAllOf {
18293 #[serde(flatten)]
18297 pub pagination_token: PaginationToken,
18298 #[serde(flatten)]
18299 pub report_meeting_participants_response_data: ReportMeetingParticipantsResponseData,
18300}
18301
18302#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18303pub struct QuestionDetails {
18304 #[serde(
18308 default,
18309 skip_serializing_if = "String::is_empty",
18310 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18311 )]
18312 pub answer: String,
18313 #[serde(
18317 default,
18318 skip_serializing_if = "Option::is_none",
18319 deserialize_with = "crate::utils::date_time_format::deserialize"
18320 )]
18321 pub date_time: Option<chrono::DateTime<chrono::Utc>>,
18322 #[serde(
18326 default,
18327 skip_serializing_if = "String::is_empty",
18328 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18329 )]
18330 pub polling_id: String,
18331 #[serde(
18335 default,
18336 skip_serializing_if = "String::is_empty",
18337 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18338 )]
18339 pub question: String,
18340}
18341
18342#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18343pub struct ReportMeetingPollsResponseQuestions {
18344 #[serde(
18348 default,
18349 skip_serializing_if = "String::is_empty",
18350 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18351 )]
18352 pub email: String,
18353 #[serde(
18357 default,
18358 skip_serializing_if = "String::is_empty",
18359 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18360 )]
18361 pub name: String,
18362 #[serde(
18366 default,
18367 skip_serializing_if = "Vec::is_empty",
18368 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
18369 )]
18370 pub question_details: Vec<QuestionDetails>,
18371}
18372
18373#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18374pub struct ReportMeetingPollsResponse {
18375 #[serde(
18379 default,
18380 skip_serializing_if = "crate::utils::zero_i64",
18381 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
18382 )]
18383 pub id: i64,
18384 #[serde(
18388 default,
18389 skip_serializing_if = "Vec::is_empty",
18390 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
18391 )]
18392 pub questions: Vec<ReportMeetingPollsResponseQuestions>,
18393 #[serde(
18397 default,
18398 skip_serializing_if = "Option::is_none",
18399 deserialize_with = "crate::utils::date_time_format::deserialize"
18400 )]
18401 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
18402 #[serde(
18406 default,
18407 skip_serializing_if = "String::is_empty",
18408 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18409 )]
18410 pub uuid: String,
18411}
18412
18413#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18414pub struct ReportWebinarParticipantsResponse {
18415 #[serde(
18419 default,
18420 skip_serializing_if = "String::is_empty",
18421 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18422 )]
18423 pub customer_key: String,
18424 #[serde(
18428 default,
18429 skip_serializing_if = "crate::utils::zero_i64",
18430 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
18431 )]
18432 pub duration: i64,
18433 #[serde(
18437 default,
18438 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
18439 )]
18440 pub failover: bool,
18441 #[serde(
18445 default,
18446 skip_serializing_if = "String::is_empty",
18447 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18448 )]
18449 pub id: String,
18450 #[serde(
18454 default,
18455 skip_serializing_if = "Option::is_none",
18456 deserialize_with = "crate::utils::date_time_format::deserialize"
18457 )]
18458 pub join_time: Option<chrono::DateTime<chrono::Utc>>,
18459 #[serde(
18463 default,
18464 skip_serializing_if = "Option::is_none",
18465 deserialize_with = "crate::utils::date_time_format::deserialize"
18466 )]
18467 pub leave_time: Option<chrono::DateTime<chrono::Utc>>,
18468 #[serde(
18472 default,
18473 skip_serializing_if = "String::is_empty",
18474 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18475 )]
18476 pub name: String,
18477 #[serde(
18481 default,
18482 skip_serializing_if = "String::is_empty",
18483 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18484 )]
18485 pub user_email: String,
18486 #[serde(
18490 default,
18491 skip_serializing_if = "String::is_empty",
18492 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18493 )]
18494 pub user_id: String,
18495}
18496
18497#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18498pub struct ReportWebinarParticipantsResponseData {
18499 #[serde(
18505 default,
18506 skip_serializing_if = "Vec::is_empty",
18507 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
18508 )]
18509 pub participants: Vec<ReportWebinarParticipantsResponse>,
18510}
18511
18512#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18518pub struct ReportWebinarParticipantsResponseAllOf {
18519 #[serde(flatten)]
18523 pub pagination_token: PaginationToken,
18524 #[serde(flatten)]
18525 pub report_webinar_participants_response_data: ReportWebinarParticipantsResponseData,
18526}
18527
18528#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18529pub struct ReportWebinarQaResponseQuestionsQuestionDetails {
18530 #[serde(
18534 default,
18535 skip_serializing_if = "String::is_empty",
18536 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18537 )]
18538 pub answer: String,
18539 #[serde(
18543 default,
18544 skip_serializing_if = "String::is_empty",
18545 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18546 )]
18547 pub question: String,
18548}
18549
18550#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18551pub struct ReportWebinarQaResponseQuestions {
18552 #[serde(
18556 default,
18557 skip_serializing_if = "String::is_empty",
18558 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18559 )]
18560 pub email: String,
18561 #[serde(
18565 default,
18566 skip_serializing_if = "String::is_empty",
18567 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18568 )]
18569 pub name: String,
18570 #[serde(
18574 default,
18575 skip_serializing_if = "Vec::is_empty",
18576 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
18577 )]
18578 pub question_details: Vec<ReportWebinarQaResponseQuestionsQuestionDetails>,
18579}
18580
18581#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18582pub struct ReportWebinarQaResponse {
18583 #[serde(
18587 default,
18588 skip_serializing_if = "crate::utils::zero_i64",
18589 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
18590 )]
18591 pub id: i64,
18592 #[serde(
18596 default,
18597 skip_serializing_if = "Vec::is_empty",
18598 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
18599 )]
18600 pub questions: Vec<ReportWebinarQaResponseQuestions>,
18601 #[serde(
18605 default,
18606 skip_serializing_if = "Option::is_none",
18607 deserialize_with = "crate::utils::date_time_format::deserialize"
18608 )]
18609 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
18610 #[serde(
18614 default,
18615 skip_serializing_if = "String::is_empty",
18616 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18617 )]
18618 pub uuid: String,
18619}
18620
18621#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
18625pub enum QueryDateType {
18626 #[serde(rename = "end_time")]
18627 EndTime,
18628 #[serde(rename = "start_time")]
18629 #[default]
18630 StartTime,
18631 #[serde(other)]
18632 FallthroughString,
18633}
18634
18635impl std::fmt::Display for QueryDateType {
18636 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18637 match self {
18638 QueryDateType::EndTime => "end_time",
18639 QueryDateType::StartTime => "start_time",
18640 QueryDateType::FallthroughString => "*",
18641 }
18642 .fmt(f)
18643 }
18644}
18645
18646#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18647pub struct ReportCloudRecordingResponse {
18648 #[serde(
18655 default,
18656 skip_serializing_if = "Vec::is_empty",
18657 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
18658 )]
18659 pub cloud_recording_storage: Vec<String>,
18660}
18661
18662#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18668pub struct ReportCloudRecordingResponseAllOf {
18669 #[serde(flatten)]
18670 pub dashboard_im_response: DashboardImResponse,
18671 #[serde(flatten)]
18672 pub report_cloud_recording_response: ReportCloudRecordingResponse,
18673}
18674
18675#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
18681pub enum CategoryType {
18682 #[serde(rename = "account")]
18683 Account,
18684 #[serde(rename = "all")]
18685 All,
18686 #[serde(rename = "billing")]
18687 Billing,
18688 #[serde(rename = "im")]
18689 Im,
18690 #[serde(rename = "phone_contacts")]
18691 PhoneContacts,
18692 #[serde(rename = "recording")]
18693 Recording,
18694 #[serde(rename = "role")]
18695 Role,
18696 #[serde(rename = "sub_account")]
18697 SubAccount,
18698 #[serde(rename = "user")]
18699 User,
18700 #[serde(rename = "user_settings")]
18701 UserSettings,
18702 #[serde(rename = "webinar")]
18703 Webinar,
18704 #[serde(rename = "zoom_rooms")]
18705 ZoomRooms,
18706 #[serde(rename = "")]
18707 #[default]
18708 Noop,
18709 #[serde(other)]
18710 FallthroughString,
18711}
18712
18713impl std::fmt::Display for CategoryType {
18714 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18715 match self {
18716 CategoryType::Account => "account",
18717 CategoryType::All => "all",
18718 CategoryType::Billing => "billing",
18719 CategoryType::Im => "im",
18720 CategoryType::PhoneContacts => "phone_contacts",
18721 CategoryType::Recording => "recording",
18722 CategoryType::Role => "role",
18723 CategoryType::SubAccount => "sub_account",
18724 CategoryType::User => "user",
18725 CategoryType::UserSettings => "user_settings",
18726 CategoryType::Webinar => "webinar",
18727 CategoryType::ZoomRooms => "zoom_rooms",
18728 CategoryType::Noop => "",
18729 CategoryType::FallthroughString => "*",
18730 }
18731 .fmt(f)
18732 }
18733}
18734
18735impl CategoryType {
18736 pub fn is_noop(&self) -> bool {
18737 matches!(self, CategoryType::Noop)
18738 }
18739}
18740
18741#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18742pub struct OperationLogs {
18743 #[serde(
18747 default,
18748 skip_serializing_if = "String::is_empty",
18749 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18750 )]
18751 pub action: String,
18752 #[serde(
18756 default,
18757 skip_serializing_if = "String::is_empty",
18758 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18759 )]
18760 pub category_type: String,
18761 #[serde(
18765 default,
18766 skip_serializing_if = "String::is_empty",
18767 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18768 )]
18769 pub operation_detail: String,
18770 #[serde(
18774 default,
18775 skip_serializing_if = "String::is_empty",
18776 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18777 )]
18778 pub operator: String,
18779 #[serde(
18783 default,
18784 skip_serializing_if = "Option::is_none",
18785 deserialize_with = "crate::utils::date_time_format::deserialize"
18786 )]
18787 pub time: Option<chrono::DateTime<chrono::Utc>>,
18788}
18789
18790#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18791pub struct ReportOperationLogsResponse {
18792 #[serde(
18796 default,
18797 skip_serializing_if = "Vec::is_empty",
18798 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
18799 )]
18800 pub operation_logs: Vec<OperationLogs>,
18801}
18802
18803#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18809pub struct ReportOperationLogsResponseAllOf {
18810 #[serde(flatten)]
18814 pub pagination_token_4_im_chat: PaginationToken4ImChat,
18815 #[serde(flatten)]
18816 pub report_operation_logs_response: ReportOperationLogsResponse,
18817}
18818
18819#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18820pub struct CreateRoleRequest {
18821 #[serde(
18825 default,
18826 skip_serializing_if = "String::is_empty",
18827 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18828 )]
18829 pub description: String,
18830 #[serde(
18834 default,
18835 skip_serializing_if = "String::is_empty",
18836 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18837 )]
18838 pub name: String,
18839 #[serde(
18846 default,
18847 skip_serializing_if = "Vec::is_empty",
18848 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
18849 )]
18850 pub privileges: Vec<String>,
18851}
18852
18853#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18854pub struct CreateRoleResponse {
18855 #[serde(
18859 default,
18860 skip_serializing_if = "String::is_empty",
18861 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18862 )]
18863 pub description: String,
18864 #[serde(
18868 default,
18869 skip_serializing_if = "String::is_empty",
18870 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18871 )]
18872 pub id: String,
18873 #[serde(
18877 default,
18878 skip_serializing_if = "String::is_empty",
18879 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18880 )]
18881 pub name: String,
18882 #[serde(
18889 default,
18890 skip_serializing_if = "Vec::is_empty",
18891 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
18892 )]
18893 pub privileges: Vec<String>,
18894 #[serde(
18898 default,
18899 skip_serializing_if = "crate::utils::zero_i64",
18900 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
18901 )]
18902 pub total_members: i64,
18903}
18904
18905#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18906pub struct AddRoleMembersResponse {
18907 #[serde(
18911 default,
18912 skip_serializing_if = "Option::is_none",
18913 deserialize_with = "crate::utils::date_time_format::deserialize"
18914 )]
18915 pub add_at: Option<chrono::DateTime<chrono::Utc>>,
18916 #[serde(
18920 default,
18921 skip_serializing_if = "String::is_empty",
18922 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18923 )]
18924 pub ids: String,
18925}
18926
18927#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18928pub struct TspResponseDialInNumbers {
18929 #[serde(
18933 default,
18934 skip_serializing_if = "String::is_empty",
18935 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18936 )]
18937 pub code: String,
18938 #[serde(
18942 default,
18943 skip_serializing_if = "String::is_empty",
18944 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
18945 )]
18946 pub number: String,
18947 #[serde(
18951 default,
18952 skip_serializing_if = "String::is_empty",
18953 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
18954 rename = "type"
18955 )]
18956 pub type_: String,
18957}
18958
18959#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
18960pub struct TspResponse {
18961 #[serde(
18965 default,
18966 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
18967 )]
18968 pub dial_in_number_unrestricted: bool,
18969 #[serde(
18970 default,
18971 skip_serializing_if = "Vec::is_empty",
18972 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
18973 )]
18974 pub dial_in_numbers: Vec<TspResponseDialInNumbers>,
18975 #[serde(
18979 default,
18980 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
18981 )]
18982 pub enable: bool,
18983 #[serde(
18987 default,
18988 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
18989 )]
18990 pub master_account_setting_extended: bool,
18991 #[serde(
18995 default,
18996 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
18997 )]
18998 pub modify_credential_forbidden: bool,
18999 #[serde(default, skip_serializing_if = "Option::is_none")]
19003 pub tsp_bridge: Option<TspBridge>,
19004 #[serde(
19008 default,
19009 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
19010 )]
19011 pub tsp_enabled: bool,
19012 #[serde(
19016 default,
19017 skip_serializing_if = "String::is_empty",
19018 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19019 )]
19020 pub tsp_provider: String,
19021}
19022
19023#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
19024pub struct TspUpdateRequest {
19025 #[serde(default, skip_serializing_if = "Option::is_none")]
19029 pub dial_in_number_unrestricted: Option<bool>,
19030 #[serde(default, skip_serializing_if = "Option::is_none")]
19034 pub enable: Option<bool>,
19035 #[serde(default, skip_serializing_if = "Option::is_none")]
19039 pub master_account_setting_extended: Option<bool>,
19040 #[serde(default, skip_serializing_if = "Option::is_none")]
19044 pub modify_credential_forbidden: Option<bool>,
19045 #[serde(default, skip_serializing_if = "Option::is_none")]
19049 pub tsp_bridge: Option<TspBridge>,
19050 #[serde(default, skip_serializing_if = "Option::is_none")]
19054 pub tsp_enabled: Option<bool>,
19055 #[serde(
19059 default,
19060 skip_serializing_if = "String::is_empty",
19061 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19062 )]
19063 pub tsp_provider: String,
19064}
19065
19066#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
19075pub enum UsersStatus {
19076 #[serde(rename = "active")]
19077 #[default]
19078 Active,
19079 #[serde(rename = "inactive")]
19080 Inactive,
19081 #[serde(rename = "pending")]
19082 Pending,
19083 #[serde(other)]
19084 FallthroughString,
19085}
19086
19087impl std::fmt::Display for UsersStatus {
19088 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19089 match self {
19090 UsersStatus::Active => "active",
19091 UsersStatus::Inactive => "inactive",
19092 UsersStatus::Pending => "pending",
19093 UsersStatus::FallthroughString => "*",
19094 }
19095 .fmt(f)
19096 }
19097}
19098
19099#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
19105pub enum UsersIncludeFields {
19106 #[serde(rename = "custom_attributes")]
19107 CustomAttributes,
19108 #[serde(rename = "host_key")]
19109 HostKey,
19110 #[serde(rename = "")]
19111 #[default]
19112 Noop,
19113 #[serde(other)]
19114 FallthroughString,
19115}
19116
19117impl std::fmt::Display for UsersIncludeFields {
19118 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19119 match self {
19120 UsersIncludeFields::CustomAttributes => "custom_attributes",
19121 UsersIncludeFields::HostKey => "host_key",
19122 UsersIncludeFields::Noop => "",
19123 UsersIncludeFields::FallthroughString => "*",
19124 }
19125 .fmt(f)
19126 }
19127}
19128
19129impl UsersIncludeFields {
19130 pub fn is_noop(&self) -> bool {
19131 matches!(self, UsersIncludeFields::Noop)
19132 }
19133}
19134
19135#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
19136pub struct UsersResponseCustomAttributes {
19137 #[serde(
19141 default,
19142 skip_serializing_if = "String::is_empty",
19143 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19144 )]
19145 pub key: String,
19146 #[serde(
19150 default,
19151 skip_serializing_if = "String::is_empty",
19152 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19153 )]
19154 pub name: String,
19155 #[serde(
19159 default,
19160 skip_serializing_if = "String::is_empty",
19161 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19162 )]
19163 pub value: String,
19164}
19165
19166#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
19167pub struct UsersResponse {
19168 #[serde(
19172 default,
19173 skip_serializing_if = "Option::is_none",
19174 deserialize_with = "crate::utils::date_time_format::deserialize"
19175 )]
19176 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
19177 #[serde(
19183 default,
19184 skip_serializing_if = "Vec::is_empty",
19185 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
19186 )]
19187 pub custom_attributes: Vec<UsersResponseCustomAttributes>,
19188 #[serde(
19192 default,
19193 skip_serializing_if = "String::is_empty",
19194 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19195 )]
19196 pub dept: String,
19197 #[serde(
19201 default,
19202 skip_serializing_if = "String::is_empty",
19203 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19204 )]
19205 pub email: String,
19206 #[serde(
19210 default,
19211 skip_serializing_if = "String::is_empty",
19212 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19213 )]
19214 pub first_name: String,
19215 #[serde(
19222 default,
19223 skip_serializing_if = "Vec::is_empty",
19224 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
19225 )]
19226 pub group_ids: Vec<String>,
19227 #[serde(
19231 default,
19232 skip_serializing_if = "String::is_empty",
19233 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19234 )]
19235 pub host_key: String,
19236 #[serde(
19240 default,
19241 skip_serializing_if = "String::is_empty",
19242 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19243 )]
19244 pub id: String,
19245 #[serde(
19252 default,
19253 skip_serializing_if = "Vec::is_empty",
19254 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
19255 )]
19256 pub im_group_ids: Vec<String>,
19257 #[serde(
19261 default,
19262 skip_serializing_if = "String::is_empty",
19263 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19264 )]
19265 pub last_client_version: String,
19266 #[serde(
19270 default,
19271 skip_serializing_if = "Option::is_none",
19272 deserialize_with = "crate::utils::date_time_format::deserialize"
19273 )]
19274 pub last_login_time: Option<chrono::DateTime<chrono::Utc>>,
19275 #[serde(
19279 default,
19280 skip_serializing_if = "String::is_empty",
19281 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19282 )]
19283 pub last_name: String,
19284 #[serde(
19288 default,
19289 skip_serializing_if = "String::is_empty",
19290 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19291 )]
19292 pub plan_united_type: String,
19293 #[serde(
19297 default,
19298 skip_serializing_if = "crate::utils::zero_i64",
19299 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
19300 )]
19301 pub pmi: i64,
19302 #[serde(
19306 default,
19307 skip_serializing_if = "String::is_empty",
19308 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19309 )]
19310 pub role_id: String,
19311 #[serde(default, skip_serializing_if = "Option::is_none")]
19320 pub status: Option<UsersStatus>,
19321 #[serde(
19325 default,
19326 skip_serializing_if = "String::is_empty",
19327 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19328 )]
19329 pub timezone: String,
19330 #[serde(
19334 default,
19335 skip_serializing_if = "crate::utils::zero_i64",
19336 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
19337 rename = "type"
19338 )]
19339 pub type_: i64,
19340 #[serde(
19344 default,
19345 skip_serializing_if = "crate::utils::zero_i64",
19346 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
19347 )]
19348 pub verified: i64,
19349}
19350
19351#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
19352pub struct UsersResponseData {
19353 #[serde(
19357 default,
19358 skip_serializing_if = "String::is_empty",
19359 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19360 )]
19361 pub next_page_token: String,
19362 #[serde(
19366 default,
19367 skip_serializing_if = "crate::utils::zero_i64",
19368 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
19369 )]
19370 pub page_count: i64,
19371 #[serde(
19375 default,
19376 skip_serializing_if = "crate::utils::zero_i64",
19377 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
19378 )]
19379 pub page_number: i64,
19380 #[serde(
19384 default,
19385 skip_serializing_if = "crate::utils::zero_i64",
19386 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
19387 )]
19388 pub page_size: i64,
19389 #[serde(
19393 default,
19394 skip_serializing_if = "crate::utils::zero_i64",
19395 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
19396 )]
19397 pub total_records: i64,
19398 #[serde(
19402 default,
19403 skip_serializing_if = "Vec::is_empty",
19404 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
19405 )]
19406 pub users: Vec<UsersResponse>,
19407}
19408
19409#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
19413pub enum UserCreateRequestAction {
19414 #[serde(rename = "autoCreate")]
19415 AutoCreate,
19416 #[serde(rename = "create")]
19417 Create,
19418 #[serde(rename = "custCreate")]
19419 CustCreate,
19420 #[serde(rename = "ssoCreate")]
19421 SsoCreate,
19422 #[serde(rename = "")]
19423 #[default]
19424 Noop,
19425 #[serde(other)]
19426 FallthroughString,
19427}
19428
19429impl std::fmt::Display for UserCreateRequestAction {
19430 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19431 match self {
19432 UserCreateRequestAction::AutoCreate => "autoCreate",
19433 UserCreateRequestAction::Create => "create",
19434 UserCreateRequestAction::CustCreate => "custCreate",
19435 UserCreateRequestAction::SsoCreate => "ssoCreate",
19436 UserCreateRequestAction::Noop => "",
19437 UserCreateRequestAction::FallthroughString => "*",
19438 }
19439 .fmt(f)
19440 }
19441}
19442
19443impl UserCreateRequestAction {
19444 pub fn is_noop(&self) -> bool {
19445 matches!(self, UserCreateRequestAction::Noop)
19446 }
19447}
19448
19449#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
19450pub struct UserInfo {
19451 #[serde(
19455 default,
19456 skip_serializing_if = "String::is_empty",
19457 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19458 )]
19459 pub email: String,
19460 #[serde(
19464 default,
19465 skip_serializing_if = "String::is_empty",
19466 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19467 )]
19468 pub first_name: String,
19469 #[serde(
19473 default,
19474 skip_serializing_if = "String::is_empty",
19475 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19476 )]
19477 pub last_name: String,
19478 #[serde(
19482 default,
19483 skip_serializing_if = "String::is_empty",
19484 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19485 )]
19486 pub password: String,
19487 #[serde(
19491 default,
19492 skip_serializing_if = "crate::utils::zero_i64",
19493 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
19494 rename = "type"
19495 )]
19496 pub type_: i64,
19497}
19498
19499#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
19500pub struct UserCreateRequest {
19501 #[serde(default, skip_serializing_if = "UserCreateRequestAction::is_noop")]
19505 pub action: UserCreateRequestAction,
19506 #[serde(default, skip_serializing_if = "Option::is_none")]
19507 pub user_info: Option<UserInfo>,
19508}
19509
19510#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
19520pub enum LoginType {
19521 #[serde(rename = "0")]
19522 Zero,
19523 #[serde(rename = "1")]
19524 One,
19525 #[serde(rename = "100")]
19526 OneHundred,
19527 #[serde(rename = "101")]
19528 OneHundredAndOne,
19529 #[serde(rename = "11")]
19530 Eleven,
19531 #[serde(rename = "21")]
19532 TwentyOne,
19533 #[serde(rename = "23")]
19534 TwentyThree,
19535 #[serde(rename = "24")]
19536 TwentyFour,
19537 #[serde(rename = "27")]
19538 TwentySeven,
19539 #[serde(rename = "97")]
19540 NinetySeven,
19541 #[serde(rename = "98")]
19542 NinetyEight,
19543 #[serde(rename = "99")]
19544 NinetyNine,
19545 #[serde(rename = "")]
19546 #[default]
19547 Noop,
19548 #[serde(other)]
19549 FallthroughString,
19550}
19551
19552impl std::fmt::Display for LoginType {
19553 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19554 match self {
19555 LoginType::Zero => "0",
19556 LoginType::One => "1",
19557 LoginType::OneHundred => "100",
19558 LoginType::OneHundredAndOne => "101",
19559 LoginType::Eleven => "11",
19560 LoginType::TwentyOne => "21",
19561 LoginType::TwentyThree => "23",
19562 LoginType::TwentyFour => "24",
19563 LoginType::TwentySeven => "27",
19564 LoginType::NinetySeven => "97",
19565 LoginType::NinetyEight => "98",
19566 LoginType::NinetyNine => "99",
19567 LoginType::Noop => "",
19568 LoginType::FallthroughString => "*",
19569 }
19570 .fmt(f)
19571 }
19572}
19573
19574impl LoginType {
19575 pub fn is_noop(&self) -> bool {
19576 matches!(self, LoginType::Noop)
19577 }
19578}
19579
19580#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
19581pub struct UserResponsePhoneNumbers {
19582 #[serde(
19586 default,
19587 skip_serializing_if = "String::is_empty",
19588 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19589 )]
19590 pub code: String,
19591 #[serde(
19595 default,
19596 skip_serializing_if = "String::is_empty",
19597 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19598 )]
19599 pub country: String,
19600 #[serde(default, skip_serializing_if = "Option::is_none")]
19609 pub label: Option<Label>,
19610 #[serde(
19614 default,
19615 skip_serializing_if = "String::is_empty",
19616 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19617 )]
19618 pub number: String,
19619 #[serde(
19623 default,
19624 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
19625 )]
19626 pub verified: bool,
19627}
19628
19629#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
19631pub struct UserResponseCustomAttributes {
19632 #[serde(
19636 default,
19637 skip_serializing_if = "String::is_empty",
19638 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19639 )]
19640 pub key: String,
19641 #[serde(
19645 default,
19646 skip_serializing_if = "String::is_empty",
19647 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19648 )]
19649 pub name: String,
19650 #[serde(
19654 default,
19655 skip_serializing_if = "String::is_empty",
19656 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19657 )]
19658 pub value: String,
19659}
19660
19661#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
19662pub struct UserResponse {
19663 #[serde(
19667 default,
19668 skip_serializing_if = "String::is_empty",
19669 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19670 )]
19671 pub account_id: String,
19672 #[serde(
19676 default,
19677 skip_serializing_if = "String::is_empty",
19678 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19679 )]
19680 pub cms_user_id: String,
19681 #[serde(
19685 default,
19686 skip_serializing_if = "String::is_empty",
19687 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19688 )]
19689 pub company: String,
19690 #[serde(
19694 default,
19695 skip_serializing_if = "Option::is_none",
19696 deserialize_with = "crate::utils::date_time_format::deserialize"
19697 )]
19698 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
19699 #[serde(default, skip_serializing_if = "Option::is_none")]
19703 pub custom_attributes: Option<UserResponseCustomAttributes>,
19704 #[serde(
19711 default,
19712 skip_serializing_if = "Vec::is_empty",
19713 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
19714 )]
19715 pub group_ids: Vec<String>,
19716 #[serde(
19720 default,
19721 skip_serializing_if = "String::is_empty",
19722 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19723 )]
19724 pub host_key: String,
19725 #[serde(
19732 default,
19733 skip_serializing_if = "Vec::is_empty",
19734 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
19735 )]
19736 pub im_group_ids: Vec<String>,
19737 #[serde(
19741 default,
19742 skip_serializing_if = "String::is_empty",
19743 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19744 )]
19745 pub jid: String,
19746 #[serde(
19750 default,
19751 skip_serializing_if = "String::is_empty",
19752 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19753 )]
19754 pub job_title: String,
19755 #[serde(
19759 default,
19760 skip_serializing_if = "String::is_empty",
19761 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19762 )]
19763 pub language: String,
19764 #[serde(
19768 default,
19769 skip_serializing_if = "String::is_empty",
19770 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19771 )]
19772 pub location: String,
19773 #[serde(
19777 default,
19778 skip_serializing_if = "crate::utils::zero_i64",
19779 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
19780 )]
19781 pub login_type: i64,
19782 #[serde(
19786 default,
19787 skip_serializing_if = "String::is_empty",
19788 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19789 )]
19790 pub manager: String,
19791 #[serde(
19795 default,
19796 skip_serializing_if = "String::is_empty",
19797 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19798 )]
19799 pub personal_meeting_url: String,
19800 #[serde(
19804 default,
19805 skip_serializing_if = "String::is_empty",
19806 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19807 )]
19808 pub phone_country: String,
19809 #[serde(
19813 default,
19814 skip_serializing_if = "String::is_empty",
19815 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19816 )]
19817 pub phone_number: String,
19818 #[serde(default, skip_serializing_if = "Option::is_none")]
19819 pub phone_numbers: Option<UserResponsePhoneNumbers>,
19820 #[serde(
19824 default,
19825 skip_serializing_if = "String::is_empty",
19826 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19827 )]
19828 pub pic_url: String,
19829 #[serde(
19833 default,
19834 skip_serializing_if = "String::is_empty",
19835 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19836 )]
19837 pub plan_united_type: String,
19838 #[serde(
19842 default,
19843 skip_serializing_if = "String::is_empty",
19844 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19845 )]
19846 pub role_id: String,
19847 #[serde(default, skip_serializing_if = "Option::is_none")]
19856 pub status: Option<UsersStatus>,
19857 #[serde(
19861 default,
19862 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
19863 )]
19864 pub use_pmi: bool,
19865 #[serde(
19869 default,
19870 skip_serializing_if = "String::is_empty",
19871 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19872 )]
19873 pub vanity_url: String,
19874 #[serde(
19878 default,
19879 skip_serializing_if = "crate::utils::zero_i64",
19880 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
19881 )]
19882 pub verified: i64,
19883}
19884
19885#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
19892pub struct UserResponseAllOf {
19893 #[serde(flatten)]
19894 pub groups: Groups,
19895 #[serde(flatten)]
19899 pub user: User,
19900 #[serde(flatten)]
19901 pub user_response: UserResponse,
19902}
19903
19904#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
19908pub enum UserDeleteAction {
19909 #[serde(rename = "delete")]
19910 Delete,
19911 #[serde(rename = "disassociate")]
19912 #[default]
19913 Disassociate,
19914 #[serde(other)]
19915 FallthroughString,
19916}
19917
19918impl std::fmt::Display for UserDeleteAction {
19919 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19920 match self {
19921 UserDeleteAction::Delete => "delete",
19922 UserDeleteAction::Disassociate => "disassociate",
19923 UserDeleteAction::FallthroughString => "*",
19924 }
19925 .fmt(f)
19926 }
19927}
19928
19929#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
19930pub struct UserZakResponse {
19931 #[serde(
19935 default,
19936 skip_serializing_if = "String::is_empty",
19937 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
19938 )]
19939 pub token: String,
19940}
19941
19942#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
19951#[serde(untagged)]
19952pub enum UserSettingsResponseOneOf {
19953 Domains(Domains),
19954 UserSettings(UserSettings),
19955 MeetingSecuritySettings(MeetingSecuritySettings),
19956}
19957
19958impl UserSettingsResponseOneOf {
19959 pub fn domains(&self) -> Option<&Domains> {
19960 if let UserSettingsResponseOneOf::Domains(ref_) = self {
19961 return Some(ref_);
19962 }
19963 None
19964 }
19965
19966 pub fn meeting_security_settings(&self) -> Option<&MeetingSecuritySettings> {
19967 if let UserSettingsResponseOneOf::MeetingSecuritySettings(ref_) = self {
19968 return Some(ref_);
19969 }
19970 None
19971 }
19972
19973 pub fn user_settings(&self) -> Option<&UserSettings> {
19974 if let UserSettingsResponseOneOf::UserSettings(ref_) = self {
19975 return Some(ref_);
19976 }
19977 None
19978 }
19979}
19980
19981#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
19990#[serde(untagged)]
19991pub enum UserSettingsUpdateRequestOneOf {
19992 Domains(Domains),
19993 UserSettingsUpdate(UserSettingsUpdate),
19994 MeetingSecuritySettings(MeetingSecuritySettings),
19995}
19996
19997impl UserSettingsUpdateRequestOneOf {
19998 pub fn domains(&self) -> Option<&Domains> {
19999 if let UserSettingsUpdateRequestOneOf::Domains(ref_) = self {
20000 return Some(ref_);
20001 }
20002 None
20003 }
20004
20005 pub fn meeting_security_settings(&self) -> Option<&MeetingSecuritySettings> {
20006 if let UserSettingsUpdateRequestOneOf::MeetingSecuritySettings(ref_) = self {
20007 return Some(ref_);
20008 }
20009 None
20010 }
20011
20012 pub fn user_settings_update(&self) -> Option<&UserSettingsUpdate> {
20013 if let UserSettingsUpdateRequestOneOf::UserSettingsUpdate(ref_) = self {
20014 return Some(ref_);
20015 }
20016 None
20017 }
20018}
20019
20020#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
20021pub enum UserSettingsUpdateOption {
20022 #[serde(rename = "meeting_authentication")]
20023 MeetingAuthentication,
20024 #[serde(rename = "meeting_secuirty")]
20025 MeetingSecuirty,
20026 #[serde(rename = "recording_authentication")]
20027 RecordingAuthentication,
20028 #[serde(rename = "")]
20029 #[default]
20030 Noop,
20031 #[serde(other)]
20032 FallthroughString,
20033}
20034
20035impl std::fmt::Display for UserSettingsUpdateOption {
20036 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20037 match self {
20038 UserSettingsUpdateOption::MeetingAuthentication => "meeting_authentication",
20039 UserSettingsUpdateOption::MeetingSecuirty => "meeting_secuirty",
20040 UserSettingsUpdateOption::RecordingAuthentication => "recording_authentication",
20041 UserSettingsUpdateOption::Noop => "",
20042 UserSettingsUpdateOption::FallthroughString => "*",
20043 }
20044 .fmt(f)
20045 }
20046}
20047
20048impl UserSettingsUpdateOption {
20049 pub fn is_noop(&self) -> bool {
20050 matches!(self, UserSettingsUpdateOption::Noop)
20051 }
20052}
20053
20054#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
20058pub enum UserStatusRequestAction {
20059 #[serde(rename = "activate")]
20060 Activate,
20061 #[serde(rename = "deactivate")]
20062 Deactivate,
20063 #[serde(rename = "")]
20064 #[default]
20065 Noop,
20066 #[serde(other)]
20067 FallthroughString,
20068}
20069
20070impl std::fmt::Display for UserStatusRequestAction {
20071 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20072 match self {
20073 UserStatusRequestAction::Activate => "activate",
20074 UserStatusRequestAction::Deactivate => "deactivate",
20075 UserStatusRequestAction::Noop => "",
20076 UserStatusRequestAction::FallthroughString => "*",
20077 }
20078 .fmt(f)
20079 }
20080}
20081
20082impl UserStatusRequestAction {
20083 pub fn is_noop(&self) -> bool {
20084 matches!(self, UserStatusRequestAction::Noop)
20085 }
20086}
20087
20088#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20090pub struct UserStatusRequest {
20091 #[serde(default, skip_serializing_if = "UserStatusRequestAction::is_noop")]
20095 pub action: UserStatusRequestAction,
20096}
20097
20098#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20099pub struct UserPasswordRequest {
20100 #[serde(
20104 default,
20105 skip_serializing_if = "String::is_empty",
20106 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20107 )]
20108 pub password: String,
20109}
20110
20111#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20112pub struct PacAccounts {
20113 #[serde(
20117 default,
20118 skip_serializing_if = "crate::utils::zero_i64",
20119 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
20120 )]
20121 pub conference_id: i64,
20122 #[serde(
20126 default,
20127 skip_serializing_if = "Vec::is_empty",
20128 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
20129 )]
20130 pub dedicated_dial_in_number: Vec<DedicatedDialInNumber>,
20131 #[serde(
20135 default,
20136 skip_serializing_if = "Vec::is_empty",
20137 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
20138 )]
20139 pub global_dial_in_numbers: Vec<DedicatedDialInNumber>,
20140 #[serde(
20144 default,
20145 skip_serializing_if = "String::is_empty",
20146 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20147 )]
20148 pub listen_only_password: String,
20149 #[serde(
20153 default,
20154 skip_serializing_if = "String::is_empty",
20155 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20156 )]
20157 pub participant_password: String,
20158}
20159
20160#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20161pub struct UserPaCsResponse {
20162 #[serde(
20163 default,
20164 skip_serializing_if = "Vec::is_empty",
20165 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
20166 )]
20167 pub pac_accounts: Vec<PacAccounts>,
20168}
20169
20170#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20172pub struct TspAccounts {
20173 #[serde(
20177 default,
20178 skip_serializing_if = "String::is_empty",
20179 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20180 )]
20181 pub conference_code: String,
20182 #[serde(
20186 default,
20187 skip_serializing_if = "Vec::is_empty",
20188 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
20189 )]
20190 pub dial_in_numbers: Vec<DialInNumbers>,
20191 #[serde(
20195 default,
20196 skip_serializing_if = "crate::utils::zero_i64",
20197 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
20198 )]
20199 pub id: i64,
20200 #[serde(
20204 default,
20205 skip_serializing_if = "String::is_empty",
20206 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20207 )]
20208 pub leader_pin: String,
20209 #[serde(default, skip_serializing_if = "Option::is_none")]
20213 pub tsp_bridge: Option<TspBridge>,
20214}
20215
20216#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20217pub struct UserTsPsResponse {
20218 #[serde(
20219 default,
20220 skip_serializing_if = "Vec::is_empty",
20221 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
20222 )]
20223 pub tsp_accounts: Vec<TspAccounts>,
20224}
20225
20226#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20228pub struct TspAccount {
20229 #[serde(
20233 default,
20234 skip_serializing_if = "String::is_empty",
20235 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20236 )]
20237 pub conference_code: String,
20238 #[serde(
20242 default,
20243 skip_serializing_if = "Vec::is_empty",
20244 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
20245 )]
20246 pub dial_in_numbers: Vec<DialInNumbers>,
20247 #[serde(
20251 default,
20252 skip_serializing_if = "crate::utils::zero_i64",
20253 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
20254 )]
20255 pub id: i64,
20256 #[serde(
20260 default,
20261 skip_serializing_if = "String::is_empty",
20262 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20263 )]
20264 pub leader_pin: String,
20265 #[serde(default, skip_serializing_if = "Option::is_none")]
20269 pub tsp_bridge: Option<TspBridge>,
20270}
20271
20272#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20274pub struct TspAccountData {
20275 #[serde(
20279 default,
20280 skip_serializing_if = "String::is_empty",
20281 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20282 )]
20283 pub conference_code: String,
20284 #[serde(
20288 default,
20289 skip_serializing_if = "Vec::is_empty",
20290 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
20291 )]
20292 pub dial_in_numbers: Vec<DialInNumbers>,
20293 #[serde(
20297 default,
20298 skip_serializing_if = "String::is_empty",
20299 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20300 )]
20301 pub leader_pin: String,
20302 #[serde(default, skip_serializing_if = "Option::is_none")]
20306 pub tsp_bridge: Option<TspBridge>,
20307}
20308
20309#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
20313pub enum UserTokenType {
20314 #[serde(rename = "token")]
20315 Token,
20316 #[serde(rename = "zak")]
20317 Zak,
20318 #[serde(rename = "")]
20319 #[default]
20320 Noop,
20321 #[serde(other)]
20322 FallthroughString,
20323}
20324
20325impl std::fmt::Display for UserTokenType {
20326 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20327 match self {
20328 UserTokenType::Token => "token",
20329 UserTokenType::Zak => "zak",
20330 UserTokenType::Noop => "",
20331 UserTokenType::FallthroughString => "*",
20332 }
20333 .fmt(f)
20334 }
20335}
20336
20337impl UserTokenType {
20338 pub fn is_noop(&self) -> bool {
20339 matches!(self, UserTokenType::Noop)
20340 }
20341}
20342
20343#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20344pub struct UserEmailResponse {
20345 #[serde(
20349 default,
20350 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
20351 )]
20352 pub existed_email: bool,
20353}
20354
20355#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20356pub struct UserVanityNameResponse {
20357 #[serde(
20361 default,
20362 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
20363 )]
20364 pub existed: bool,
20365}
20366
20367#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20368pub struct WebinarCreateResponse {
20369 #[serde(
20373 default,
20374 skip_serializing_if = "String::is_empty",
20375 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20376 )]
20377 pub host_email: String,
20378 #[serde(
20382 default,
20383 skip_serializing_if = "String::is_empty",
20384 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20385 )]
20386 pub host_id: String,
20387 #[serde(
20391 default,
20392 skip_serializing_if = "crate::utils::zero_i64",
20393 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
20394 )]
20395 pub id: i64,
20396 #[serde(
20400 default,
20401 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
20402 )]
20403 pub registrants_confirmation_email: bool,
20404 #[serde(
20408 default,
20409 skip_serializing_if = "String::is_empty",
20410 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20411 )]
20412 pub template_id: String,
20413 #[serde(
20417 default,
20418 skip_serializing_if = "String::is_empty",
20419 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20420 )]
20421 pub uuid: String,
20422}
20423
20424#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20430pub struct WebinarCreateResponseAllOf {
20431 #[serde(flatten)]
20435 pub webinar_info: WebinarInfo,
20436 #[serde(flatten)]
20437 pub webinar_create_response: WebinarCreateResponse,
20438}
20439
20440#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20441pub struct WebinarResponse {
20442 #[serde(
20446 default,
20447 skip_serializing_if = "String::is_empty",
20448 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20449 )]
20450 pub host_email: String,
20451 #[serde(
20455 default,
20456 skip_serializing_if = "String::is_empty",
20457 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20458 )]
20459 pub host_id: String,
20460 #[serde(
20464 default,
20465 skip_serializing_if = "crate::utils::zero_i64",
20466 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
20467 )]
20468 pub id: i64,
20469 #[serde(
20473 default,
20474 skip_serializing_if = "String::is_empty",
20475 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20476 )]
20477 pub uuid: String,
20478}
20479
20480#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20486pub struct WebinarResponseAllOf {
20487 #[serde(flatten)]
20491 pub webinar_info: WebinarInfo,
20492 #[serde(flatten)]
20493 pub webinar_response: WebinarResponse,
20494}
20495
20496#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20497pub struct ListWebinarParticipantsResponse {
20498 #[serde(
20502 default,
20503 skip_serializing_if = "String::is_empty",
20504 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20505 )]
20506 pub next_page_token: String,
20507 #[serde(
20511 default,
20512 skip_serializing_if = "crate::utils::zero_i64",
20513 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
20514 )]
20515 pub page_count: i64,
20516 #[serde(
20520 default,
20521 skip_serializing_if = "crate::utils::zero_i64",
20522 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
20523 )]
20524 pub page_size: i64,
20525 #[serde(
20529 default,
20530 skip_serializing_if = "Vec::is_empty",
20531 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
20532 )]
20533 pub participants: Vec<Participants>,
20534 #[serde(
20538 default,
20539 skip_serializing_if = "crate::utils::zero_i64",
20540 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
20541 )]
20542 pub total_records: i64,
20543}
20544
20545#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
20546pub enum WebinarStatusRequestAction {
20547 #[serde(rename = "end")]
20548 End,
20549 #[serde(rename = "")]
20550 #[default]
20551 Noop,
20552 #[serde(other)]
20553 FallthroughString,
20554}
20555
20556impl std::fmt::Display for WebinarStatusRequestAction {
20557 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20558 match self {
20559 WebinarStatusRequestAction::End => "end",
20560 WebinarStatusRequestAction::Noop => "",
20561 WebinarStatusRequestAction::FallthroughString => "*",
20562 }
20563 .fmt(f)
20564 }
20565}
20566
20567impl WebinarStatusRequestAction {
20568 pub fn is_noop(&self) -> bool {
20569 matches!(self, WebinarStatusRequestAction::Noop)
20570 }
20571}
20572
20573#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20574pub struct WebinarStatusRequest {
20575 #[serde(default, skip_serializing_if = "Option::is_none")]
20576 pub action: Option<WebinarStatusRequestAction>,
20577}
20578
20579#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20580pub struct WebinarPanelistCreateResponse {
20581 #[serde(
20585 default,
20586 skip_serializing_if = "String::is_empty",
20587 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20588 )]
20589 pub id: String,
20590 #[serde(
20594 default,
20595 skip_serializing_if = "Option::is_none",
20596 deserialize_with = "crate::utils::date_time_format::deserialize"
20597 )]
20598 pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
20599}
20600
20601#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20602pub struct WebinarRegistrantCreateResponse {
20603 #[serde(
20607 default,
20608 skip_serializing_if = "String::is_empty",
20609 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20610 )]
20611 pub id: String,
20612 #[serde(
20616 default,
20617 skip_serializing_if = "String::is_empty",
20618 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20619 )]
20620 pub join_url: String,
20621 #[serde(
20625 default,
20626 skip_serializing_if = "String::is_empty",
20627 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20628 )]
20629 pub registrant_id: String,
20630 #[serde(
20634 default,
20635 skip_serializing_if = "Option::is_none",
20636 deserialize_with = "crate::utils::date_time_format::deserialize"
20637 )]
20638 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
20639 #[serde(
20643 default,
20644 skip_serializing_if = "String::is_empty",
20645 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20646 )]
20647 pub topic: String,
20648}
20649
20650#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20651pub struct AddBatchWebinarRegistrantsRequest {
20652 #[serde(
20656 default,
20657 skip_serializing_if = "String::is_empty",
20658 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20659 )]
20660 pub email: String,
20661 #[serde(
20665 default,
20666 skip_serializing_if = "String::is_empty",
20667 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20668 )]
20669 pub first_name: String,
20670 #[serde(
20674 default,
20675 skip_serializing_if = "String::is_empty",
20676 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20677 )]
20678 pub last_name: String,
20679}
20680
20681#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20682pub struct AddBatchRegistrantsRequest {
20683 #[serde(default, skip_serializing_if = "Option::is_none")]
20687 pub auto_approve: Option<bool>,
20688 #[serde(
20689 default,
20690 skip_serializing_if = "Vec::is_empty",
20691 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
20692 )]
20693 pub registrants: Vec<AddBatchWebinarRegistrantsRequest>,
20694}
20695
20696#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20697pub struct AddBatchWebinarRegistrantsResponse {
20698 #[serde(
20702 default,
20703 skip_serializing_if = "String::is_empty",
20704 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20705 )]
20706 pub email: String,
20707 #[serde(
20711 default,
20712 skip_serializing_if = "String::is_empty",
20713 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20714 )]
20715 pub join_url: String,
20716 #[serde(
20720 default,
20721 skip_serializing_if = "String::is_empty",
20722 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20723 )]
20724 pub registrant_id: String,
20725}
20726
20727#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20728pub struct AddBatchRegistrantsResponse {
20729 #[serde(
20730 default,
20731 skip_serializing_if = "Vec::is_empty",
20732 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
20733 )]
20734 pub registrants: Vec<AddBatchWebinarRegistrantsResponse>,
20735}
20736
20737#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20738pub struct SendchatbotRequest {
20739 #[serde(
20743 default,
20744 skip_serializing_if = "String::is_empty",
20745 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20746 )]
20747 pub account_id: String,
20748 pub content: Domains,
20749 #[serde(default, skip_serializing_if = "Option::is_none")]
20753 pub is_markdown_support: Option<bool>,
20754 #[serde(
20758 default,
20759 skip_serializing_if = "String::is_empty",
20760 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20761 )]
20762 pub robot_jid: String,
20763 #[serde(
20767 default,
20768 skip_serializing_if = "String::is_empty",
20769 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20770 )]
20771 pub to_jid: String,
20772 #[serde(
20776 default,
20777 skip_serializing_if = "String::is_empty",
20778 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20779 )]
20780 pub user_jid: String,
20781 #[serde(
20785 default,
20786 skip_serializing_if = "String::is_empty",
20787 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20788 )]
20789 pub visible_to_user: String,
20790}
20791
20792#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20793pub struct EditChatbotMessageRequest {
20794 #[serde(
20798 default,
20799 skip_serializing_if = "String::is_empty",
20800 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20801 )]
20802 pub account_id: String,
20803 pub content: Domains,
20804 #[serde(default, skip_serializing_if = "Option::is_none")]
20808 pub is_markdown_support: Option<bool>,
20809 #[serde(
20813 default,
20814 skip_serializing_if = "String::is_empty",
20815 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20816 )]
20817 pub robot_jid: String,
20818 #[serde(
20822 default,
20823 skip_serializing_if = "String::is_empty",
20824 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20825 )]
20826 pub user_jid: String,
20827}
20828
20829#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20830pub struct EditChatbotMessageResponse {
20831 #[serde(
20835 default,
20836 skip_serializing_if = "String::is_empty",
20837 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20838 )]
20839 pub message_id: String,
20840 #[serde(
20844 default,
20845 skip_serializing_if = "String::is_empty",
20846 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20847 )]
20848 pub robot_jid: String,
20849 #[serde(
20853 default,
20854 skip_serializing_if = "Option::is_none",
20855 deserialize_with = "crate::utils::date_time_format::deserialize"
20856 )]
20857 pub sent_time: Option<chrono::DateTime<chrono::Utc>>,
20858 #[serde(
20862 default,
20863 skip_serializing_if = "String::is_empty",
20864 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20865 )]
20866 pub to_jid: String,
20867 #[serde(
20871 default,
20872 skip_serializing_if = "String::is_empty",
20873 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20874 )]
20875 pub user_jid: String,
20876}
20877
20878#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20879pub struct DeleteChatbotMessageRequest {
20880 #[serde(
20884 default,
20885 skip_serializing_if = "String::is_empty",
20886 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20887 )]
20888 pub account_id: String,
20889 #[serde(
20893 default,
20894 skip_serializing_if = "String::is_empty",
20895 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20896 )]
20897 pub robot_jid: String,
20898 #[serde(
20902 default,
20903 skip_serializing_if = "String::is_empty",
20904 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20905 )]
20906 pub user_jid: String,
20907}
20908
20909#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20910pub struct DeleteChatbotMessageResponse {
20911 #[serde(
20915 default,
20916 skip_serializing_if = "String::is_empty",
20917 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20918 )]
20919 pub message_id: String,
20920 #[serde(
20924 default,
20925 skip_serializing_if = "String::is_empty",
20926 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20927 )]
20928 pub robot_jid: String,
20929 #[serde(
20933 default,
20934 skip_serializing_if = "String::is_empty",
20935 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20936 )]
20937 pub sent_time: String,
20938 #[serde(
20942 default,
20943 skip_serializing_if = "String::is_empty",
20944 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20945 )]
20946 pub to_jid: String,
20947 #[serde(
20951 default,
20952 skip_serializing_if = "String::is_empty",
20953 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20954 )]
20955 pub user_jid: String,
20956}
20957
20958#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20959pub struct GetLiveStreamDetailsResponse {
20960 #[serde(
20964 default,
20965 skip_serializing_if = "String::is_empty",
20966 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20967 )]
20968 pub page_url: String,
20969 #[serde(
20973 default,
20974 skip_serializing_if = "String::is_empty",
20975 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20976 )]
20977 pub stream_key: String,
20978 #[serde(
20982 default,
20983 skip_serializing_if = "String::is_empty",
20984 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20985 )]
20986 pub stream_url: String,
20987}
20988
20989#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
20990pub struct ClientFeedbackDetails {
20991 #[serde(
20995 default,
20996 skip_serializing_if = "String::is_empty",
20997 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
20998 )]
20999 pub email: String,
21000 #[serde(
21004 default,
21005 skip_serializing_if = "String::is_empty",
21006 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21007 )]
21008 pub meeting_id: String,
21009 #[serde(
21013 default,
21014 skip_serializing_if = "String::is_empty",
21015 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21016 )]
21017 pub participant_name: String,
21018 #[serde(
21022 default,
21023 skip_serializing_if = "Option::is_none",
21024 deserialize_with = "crate::utils::date_time_format::deserialize"
21025 )]
21026 pub time: Option<chrono::DateTime<chrono::Utc>>,
21027}
21028
21029#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21030pub struct DashboardClientFeedbackDetailResponse {
21031 #[serde(
21032 default,
21033 skip_serializing_if = "Vec::is_empty",
21034 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
21035 )]
21036 pub client_feedback_details: Vec<ClientFeedbackDetails>,
21037}
21038
21039#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21046pub struct DashboardClientFeedbackDetailResponseAllOf {
21047 #[serde(flatten)]
21051 pub pagination_token_4_im_chat: PaginationToken4ImChat,
21052 #[serde(flatten)]
21053 pub dashboard_im_response: DashboardImResponse,
21054 #[serde(flatten)]
21055 pub dashboard_client_feedback_detail_response: DashboardClientFeedbackDetailResponse,
21056}
21057
21058#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21059pub struct ListimmessagesResponseMessages {
21060 #[serde(
21064 default,
21065 skip_serializing_if = "Option::is_none",
21066 deserialize_with = "crate::utils::date_time_format::deserialize"
21067 )]
21068 pub date_time: Option<chrono::DateTime<chrono::Utc>>,
21069 #[serde(
21073 default,
21074 skip_serializing_if = "String::is_empty",
21075 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21076 )]
21077 pub id: String,
21078 #[serde(
21082 default,
21083 skip_serializing_if = "String::is_empty",
21084 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21085 )]
21086 pub message: String,
21087 #[serde(
21091 default,
21092 skip_serializing_if = "String::is_empty",
21093 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21094 )]
21095 pub sender: String,
21096 #[serde(
21100 default,
21101 skip_serializing_if = "crate::utils::zero_i64",
21102 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
21103 )]
21104 pub timstamp: i64,
21105}
21106
21107#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21108pub struct ListimmessagesResponse {
21109 #[serde(
21113 default,
21114 skip_serializing_if = "Option::is_none",
21115 deserialize_with = "crate::utils::date_time_format::deserialize"
21116 )]
21117 pub date: Option<chrono::DateTime<chrono::Utc>>,
21118 #[serde(
21122 default,
21123 skip_serializing_if = "Vec::is_empty",
21124 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
21125 )]
21126 pub messages: Vec<ListimmessagesResponseMessages>,
21127 #[serde(
21131 default,
21132 skip_serializing_if = "String::is_empty",
21133 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21134 )]
21135 pub next_page_token: String,
21136 #[serde(
21140 default,
21141 skip_serializing_if = "crate::utils::zero_i64",
21142 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
21143 )]
21144 pub page_size: i64,
21145}
21146
21147#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21148pub struct SendimmessagesRequest {
21149 #[serde(
21153 default,
21154 skip_serializing_if = "String::is_empty",
21155 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21156 )]
21157 pub message: String,
21158}
21159
21160#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21161pub struct CallingPlan {
21162 #[serde(
21166 default,
21167 skip_serializing_if = "crate::utils::zero_i64",
21168 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
21169 rename = "type"
21170 )]
21171 pub type_: i64,
21172}
21173
21174#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21175pub struct PhoneUserResponseNumbers {
21176 #[serde(
21180 default,
21181 skip_serializing_if = "String::is_empty",
21182 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21183 )]
21184 pub id: String,
21185 #[serde(
21189 default,
21190 skip_serializing_if = "String::is_empty",
21191 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21192 )]
21193 pub number: String,
21194}
21195
21196#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21198pub struct Policy {
21199 #[serde(
21203 default,
21204 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
21205 )]
21206 pub international_calling: bool,
21207}
21208
21209#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21211pub struct PhoneUserResponse {
21212 #[serde(
21216 default,
21217 skip_serializing_if = "Vec::is_empty",
21218 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
21219 )]
21220 pub calling_plan: Vec<CallingPlan>,
21221 #[serde(
21225 default,
21226 skip_serializing_if = "String::is_empty",
21227 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21228 )]
21229 pub email: String,
21230 #[serde(
21234 default,
21235 skip_serializing_if = "crate::utils::zero_i64",
21236 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
21237 )]
21238 pub extension_number: i64,
21239 #[serde(
21243 default,
21244 skip_serializing_if = "String::is_empty",
21245 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21246 )]
21247 pub id: String,
21248 #[serde(
21252 default,
21253 skip_serializing_if = "Vec::is_empty",
21254 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
21255 )]
21256 pub phone_numbers: Vec<PhoneUserResponseNumbers>,
21257 #[serde(
21261 default,
21262 skip_serializing_if = "String::is_empty",
21263 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21264 )]
21265 pub phone_user_id: String,
21266 #[serde(default, skip_serializing_if = "Option::is_none")]
21270 pub policy: Option<Policy>,
21271 #[serde(
21275 default,
21276 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
21277 )]
21278 pub site_admin: bool,
21279 #[serde(
21283 default,
21284 skip_serializing_if = "String::is_empty",
21285 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21286 )]
21287 pub site_id: String,
21288 #[serde(default, skip_serializing_if = "Option::is_none")]
21292 pub status: Option<UserStatusRequestAction>,
21293}
21294
21295#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21297pub struct UpdateUserProfileRequestPolicy {
21298 #[serde(
21302 default,
21303 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
21304 )]
21305 pub international_calling: bool,
21306}
21307
21308#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21309pub struct UpdateUserProfileRequest {
21310 #[serde(
21314 default,
21315 skip_serializing_if = "String::is_empty",
21316 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21317 )]
21318 pub extension_number: String,
21319 #[serde(default, skip_serializing_if = "Option::is_none")]
21323 pub policy: Option<UpdateUserProfileRequestPolicy>,
21324 #[serde(
21328 default,
21329 skip_serializing_if = "String::is_empty",
21330 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21331 )]
21332 pub site_id: String,
21333}
21334
21335#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21337pub struct PhoneSettingResponseCountry {
21338 #[serde(
21342 default,
21343 skip_serializing_if = "String::is_empty",
21344 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21345 )]
21346 pub code: String,
21347 #[serde(
21351 default,
21352 skip_serializing_if = "String::is_empty",
21353 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21354 )]
21355 pub name: String,
21356}
21357
21358#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21360pub struct MultipleSites {
21361 #[serde(
21365 default,
21366 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
21367 )]
21368 pub enabled: bool,
21369 #[serde(
21373 default,
21374 skip_serializing_if = "String::is_empty",
21375 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21376 )]
21377 pub site_code: String,
21378}
21379
21380#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21382pub struct Byoc {
21383 #[serde(
21387 default,
21388 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
21389 )]
21390 pub enable: bool,
21391}
21392
21393#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21394pub struct ShowDeviceIpCallLog {
21395 #[serde(
21399 default,
21400 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
21401 )]
21402 pub enable: bool,
21403}
21404
21405#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21407pub struct PhoneSettingResponse {
21408 #[serde(default, skip_serializing_if = "Option::is_none")]
21412 pub byoc: Option<Byoc>,
21413 #[serde(default, skip_serializing_if = "Option::is_none")]
21417 pub country: Option<PhoneSettingResponseCountry>,
21418 #[serde(default, skip_serializing_if = "Option::is_none")]
21422 pub multiple_sites: Option<MultipleSites>,
21423 #[serde(default, skip_serializing_if = "Option::is_none")]
21427 pub show_device_ip_for_call_log: Option<ShowDeviceIpCallLog>,
21428}
21429
21430#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21438pub struct UpdatePhoneSettingsRequestByoc {
21439 #[serde(
21449 default,
21450 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
21451 )]
21452 pub enable: bool,
21453}
21454
21455#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21456pub struct UpdatePhoneSettingsRequest {
21457 #[serde(default, skip_serializing_if = "Option::is_none")]
21467 pub byoc: Option<UpdatePhoneSettingsRequestByoc>,
21468 #[serde(default, skip_serializing_if = "Option::is_none")]
21469 pub show_device_ip_for_call_log: Option<ShowDeviceIpCallLog>,
21470}
21471
21472#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21474pub struct OutboundCaller {
21475 #[serde(
21479 default,
21480 skip_serializing_if = "String::is_empty",
21481 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21482 )]
21483 pub number: String,
21484}
21485
21486#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21487pub struct KeysPositions {
21488 #[serde(
21492 default,
21493 skip_serializing_if = "String::is_empty",
21494 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21495 )]
21496 pub primary_number: String,
21497}
21498
21499#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21501pub struct DeskPhone {
21502 #[serde(default, skip_serializing_if = "Option::is_none")]
21506 pub keys_positions: Option<KeysPositions>,
21507}
21508
21509#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21511pub struct VoiceMail {
21512 #[serde(
21516 default,
21517 skip_serializing_if = "String::is_empty",
21518 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21519 )]
21520 pub access_user_id: String,
21521 #[serde(
21525 default,
21526 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
21527 )]
21528 pub delete: bool,
21529 #[serde(
21533 default,
21534 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
21535 )]
21536 pub download: bool,
21537 #[serde(
21541 default,
21542 skip_serializing_if = "String::is_empty",
21543 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21544 )]
21545 pub shared_id: String,
21546}
21547
21548#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21549pub struct OutboundCallerIds {
21550 #[serde(
21554 default,
21555 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
21556 )]
21557 pub is_default: bool,
21558 #[serde(
21562 default,
21563 skip_serializing_if = "String::is_empty",
21564 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21565 )]
21566 pub name: String,
21567 #[serde(
21571 default,
21572 skip_serializing_if = "String::is_empty",
21573 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21574 )]
21575 pub number: String,
21576}
21577
21578#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21580pub struct PhoneUserSettingsResponseCountry {
21581 #[serde(
21585 default,
21586 skip_serializing_if = "String::is_empty",
21587 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21588 )]
21589 pub code: String,
21590 #[serde(
21594 default,
21595 skip_serializing_if = "String::is_empty",
21596 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21597 )]
21598 pub country_code: String,
21599 #[serde(
21603 default,
21604 skip_serializing_if = "String::is_empty",
21605 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21606 )]
21607 pub name: String,
21608}
21609
21610#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21612pub struct PhoneUserSettingsResponse {
21613 #[serde(
21617 default,
21618 skip_serializing_if = "String::is_empty",
21619 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21620 )]
21621 pub area_code: String,
21622 #[serde(
21626 default,
21627 skip_serializing_if = "String::is_empty",
21628 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21629 )]
21630 pub company_number: String,
21631 #[serde(default, skip_serializing_if = "Option::is_none")]
21635 pub country: Option<PhoneUserSettingsResponseCountry>,
21636 #[serde(default, skip_serializing_if = "Option::is_none")]
21640 pub desk_phone: Option<DeskPhone>,
21641 #[serde(
21645 default,
21646 skip_serializing_if = "crate::utils::zero_i64",
21647 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
21648 )]
21649 pub extension_number: i64,
21650 #[serde(default, skip_serializing_if = "Option::is_none")]
21654 pub outbound_caller: Option<OutboundCaller>,
21655 #[serde(default, skip_serializing_if = "Option::is_none")]
21659 pub outbound_caller_ids: Option<OutboundCallerIds>,
21660 #[serde(default, skip_serializing_if = "Option::is_none")]
21664 pub voice_mail: Option<VoiceMail>,
21665}
21666
21667#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
21678pub enum ListSettingTemplatesResponseType {
21679 #[serde(rename = "autReceptionist")]
21680 AutReceptionist,
21681 #[serde(rename = "commonArea")]
21682 CommonArea,
21683 #[serde(rename = "group")]
21684 Group,
21685 #[serde(rename = "interop")]
21686 Interop,
21687 #[serde(rename = "user")]
21688 User,
21689 #[serde(rename = "zr")]
21690 Zr,
21691 #[serde(rename = "")]
21692 #[default]
21693 Noop,
21694 #[serde(other)]
21695 FallthroughString,
21696}
21697
21698impl std::fmt::Display for ListSettingTemplatesResponseType {
21699 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21700 match self {
21701 ListSettingTemplatesResponseType::AutReceptionist => "autReceptionist",
21702 ListSettingTemplatesResponseType::CommonArea => "commonArea",
21703 ListSettingTemplatesResponseType::Group => "group",
21704 ListSettingTemplatesResponseType::Interop => "interop",
21705 ListSettingTemplatesResponseType::User => "user",
21706 ListSettingTemplatesResponseType::Zr => "zr",
21707 ListSettingTemplatesResponseType::Noop => "",
21708 ListSettingTemplatesResponseType::FallthroughString => "*",
21709 }
21710 .fmt(f)
21711 }
21712}
21713
21714impl ListSettingTemplatesResponseType {
21715 pub fn is_noop(&self) -> bool {
21716 matches!(self, ListSettingTemplatesResponseType::Noop)
21717 }
21718}
21719
21720#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21721pub struct Templates {
21722 #[serde(
21726 default,
21727 skip_serializing_if = "String::is_empty",
21728 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21729 )]
21730 pub description: String,
21731 #[serde(
21735 default,
21736 skip_serializing_if = "String::is_empty",
21737 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21738 )]
21739 pub id: String,
21740 #[serde(
21744 default,
21745 skip_serializing_if = "String::is_empty",
21746 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21747 )]
21748 pub name: String,
21749 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
21760 pub type_: Option<ListSettingTemplatesResponseType>,
21761}
21762
21763#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21764pub struct ListSettingTemplatesResponse {
21765 #[serde(
21769 default,
21770 skip_serializing_if = "String::is_empty",
21771 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21772 )]
21773 pub next_page_token: String,
21774 #[serde(
21778 default,
21779 skip_serializing_if = "crate::utils::zero_i64",
21780 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
21781 )]
21782 pub page_size: i64,
21783 #[serde(
21784 default,
21785 skip_serializing_if = "Vec::is_empty",
21786 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
21787 )]
21788 pub templates: Vec<Templates>,
21789 #[serde(
21793 default,
21794 skip_serializing_if = "crate::utils::zero_i64",
21795 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
21796 )]
21797 pub total_records: i64,
21798}
21799
21800#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
21804pub enum AddSettingTemplateRequestType {
21805 #[serde(rename = "autoReceptionist")]
21806 AutoReceptionist,
21807 #[serde(rename = "commonarea")]
21808 Commonarea,
21809 #[serde(rename = "group")]
21810 Group,
21811 #[serde(rename = "interop")]
21812 Interop,
21813 #[serde(rename = "user")]
21814 User,
21815 #[serde(rename = "")]
21816 #[default]
21817 Noop,
21818 #[serde(other)]
21819 FallthroughString,
21820}
21821
21822impl std::fmt::Display for AddSettingTemplateRequestType {
21823 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21824 match self {
21825 AddSettingTemplateRequestType::AutoReceptionist => "autoReceptionist",
21826 AddSettingTemplateRequestType::Commonarea => "commonarea",
21827 AddSettingTemplateRequestType::Group => "group",
21828 AddSettingTemplateRequestType::Interop => "interop",
21829 AddSettingTemplateRequestType::User => "user",
21830 AddSettingTemplateRequestType::Noop => "",
21831 AddSettingTemplateRequestType::FallthroughString => "*",
21832 }
21833 .fmt(f)
21834 }
21835}
21836
21837impl AddSettingTemplateRequestType {
21838 pub fn is_noop(&self) -> bool {
21839 matches!(self, AddSettingTemplateRequestType::Noop)
21840 }
21841}
21842
21843#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21844pub struct AddSettingTemplateRequest {
21845 #[serde(
21849 default,
21850 skip_serializing_if = "String::is_empty",
21851 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21852 )]
21853 pub description: String,
21854 #[serde(
21858 default,
21859 skip_serializing_if = "String::is_empty",
21860 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21861 )]
21862 pub name: String,
21863 #[serde(
21867 default,
21868 skip_serializing_if = "String::is_empty",
21869 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21870 )]
21871 pub site_id: String,
21872 #[serde(
21876 default,
21877 skip_serializing_if = "AddSettingTemplateRequestType::is_noop",
21878 rename = "type"
21879 )]
21880 pub type_: AddSettingTemplateRequestType,
21881}
21882
21883#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21884pub struct AddSettingTemplateResponse {
21885 #[serde(
21889 default,
21890 skip_serializing_if = "String::is_empty",
21891 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21892 )]
21893 pub description: String,
21894 #[serde(
21898 default,
21899 skip_serializing_if = "String::is_empty",
21900 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21901 )]
21902 pub id: String,
21903 #[serde(
21907 default,
21908 skip_serializing_if = "String::is_empty",
21909 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21910 )]
21911 pub name: String,
21912 #[serde(
21916 default,
21917 skip_serializing_if = "String::is_empty",
21918 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
21919 rename = "type"
21920 )]
21921 pub type_: String,
21922}
21923
21924#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21925pub struct BatchAddLocationsRequestEmergencyAddress {
21926 #[serde(
21930 default,
21931 skip_serializing_if = "String::is_empty",
21932 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
21933 rename = "address_line1"
21934 )]
21935 pub address_line_1: String,
21936 #[serde(
21940 default,
21941 skip_serializing_if = "String::is_empty",
21942 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
21943 rename = "address_line2"
21944 )]
21945 pub address_line_2: String,
21946 #[serde(
21950 default,
21951 skip_serializing_if = "String::is_empty",
21952 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21953 )]
21954 pub city: String,
21955 #[serde(
21959 default,
21960 skip_serializing_if = "String::is_empty",
21961 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21962 )]
21963 pub country: String,
21964 #[serde(
21968 default,
21969 skip_serializing_if = "String::is_empty",
21970 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21971 )]
21972 pub state_code: String,
21973 #[serde(
21977 default,
21978 skip_serializing_if = "String::is_empty",
21979 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21980 )]
21981 pub vat_number: String,
21982 #[serde(
21986 default,
21987 skip_serializing_if = "String::is_empty",
21988 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
21989 )]
21990 pub zip: String,
21991}
21992
21993#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
21994pub struct NetworkSwitches {
21995 #[serde(
21999 default,
22000 skip_serializing_if = "String::is_empty",
22001 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22002 )]
22003 pub mac_address: String,
22004 #[serde(
22008 default,
22009 skip_serializing_if = "String::is_empty",
22010 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22011 )]
22012 pub port: String,
22013 #[serde(
22017 default,
22018 skip_serializing_if = "String::is_empty",
22019 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22020 )]
22021 pub port_prefix: String,
22022 #[serde(
22026 default,
22027 skip_serializing_if = "String::is_empty",
22028 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22029 )]
22030 pub port_range_from: String,
22031 #[serde(
22035 default,
22036 skip_serializing_if = "String::is_empty",
22037 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22038 )]
22039 pub port_range_to: String,
22040}
22041
22042#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22043pub struct Locations {
22044 #[serde(
22048 default,
22049 skip_serializing_if = "String::is_empty",
22050 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22051 )]
22052 pub bssid: String,
22053 #[serde(
22057 default,
22058 skip_serializing_if = "String::is_empty",
22059 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22060 )]
22061 pub display_name: String,
22062 #[serde(
22066 default,
22067 skip_serializing_if = "String::is_empty",
22068 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22069 )]
22070 pub elin: String,
22071 pub emergency_address: BatchAddLocationsRequestEmergencyAddress,
22072 #[serde(
22076 default,
22077 skip_serializing_if = "String::is_empty",
22078 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22079 )]
22080 pub identifier: String,
22081 #[serde(
22082 default,
22083 skip_serializing_if = "Vec::is_empty",
22084 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
22085 )]
22086 pub network_switches: Vec<NetworkSwitches>,
22087 #[serde(
22091 default,
22092 skip_serializing_if = "String::is_empty",
22093 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22094 )]
22095 pub parent_identifier: String,
22096 #[serde(
22100 default,
22101 skip_serializing_if = "String::is_empty",
22102 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22103 )]
22104 pub private_ip: String,
22105 #[serde(
22109 default,
22110 skip_serializing_if = "String::is_empty",
22111 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22112 )]
22113 pub public_ip: String,
22114 #[serde(
22118 default,
22119 skip_serializing_if = "String::is_empty",
22120 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22121 )]
22122 pub sip_group_name: String,
22123}
22124
22125#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22126pub struct BatchAddLocationsRequest {
22127 #[serde(
22128 default,
22129 skip_serializing_if = "Vec::is_empty",
22130 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
22131 )]
22132 pub locations: Vec<Locations>,
22133 #[serde(
22137 default,
22138 skip_serializing_if = "String::is_empty",
22139 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22140 )]
22141 pub site_id: String,
22142}
22143
22144#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22145pub struct BatchAddLocationsResponse {
22146 #[serde(
22150 default,
22151 skip_serializing_if = "String::is_empty",
22152 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22153 )]
22154 pub display_name: String,
22155 #[serde(
22159 default,
22160 skip_serializing_if = "String::is_empty",
22161 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22162 )]
22163 pub location_id: String,
22164}
22165
22166#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22168pub struct Elin {
22169 #[serde(
22173 default,
22174 skip_serializing_if = "String::is_empty",
22175 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22176 )]
22177 pub phone_number: String,
22178 #[serde(
22182 default,
22183 skip_serializing_if = "String::is_empty",
22184 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22185 )]
22186 pub phone_number_id: String,
22187}
22188
22189#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22191pub struct ListLocationsResponseSipGroup {
22192 #[serde(
22196 default,
22197 skip_serializing_if = "String::is_empty",
22198 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22199 )]
22200 pub display_name: String,
22201 #[serde(
22205 default,
22206 skip_serializing_if = "String::is_empty",
22207 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22208 )]
22209 pub id: String,
22210}
22211
22212#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22214pub struct ListLocationsResponseSite {
22215 #[serde(
22219 default,
22220 skip_serializing_if = "String::is_empty",
22221 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22222 )]
22223 pub id: String,
22224 #[serde(
22228 default,
22229 skip_serializing_if = "String::is_empty",
22230 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22231 )]
22232 pub name: String,
22233}
22234
22235#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22236pub struct ListLocationsResponse {
22237 #[serde(
22241 default,
22242 skip_serializing_if = "String::is_empty",
22243 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22244 )]
22245 pub bssid: String,
22246 #[serde(default, skip_serializing_if = "Option::is_none")]
22250 pub elin: Option<Elin>,
22251 #[serde(
22255 default,
22256 skip_serializing_if = "String::is_empty",
22257 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22258 )]
22259 pub id: String,
22260 #[serde(
22264 default,
22265 skip_serializing_if = "String::is_empty",
22266 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22267 )]
22268 pub identifier: String,
22269 #[serde(
22273 default,
22274 skip_serializing_if = "String::is_empty",
22275 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22276 )]
22277 pub name: String,
22278 #[serde(
22279 default,
22280 skip_serializing_if = "Vec::is_empty",
22281 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
22282 )]
22283 pub network_switches: Vec<NetworkSwitches>,
22284 #[serde(
22288 default,
22289 skip_serializing_if = "String::is_empty",
22290 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22291 )]
22292 pub parent_location_id: String,
22293 #[serde(
22297 default,
22298 skip_serializing_if = "String::is_empty",
22299 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22300 )]
22301 pub private_ip: String,
22302 #[serde(
22306 default,
22307 skip_serializing_if = "String::is_empty",
22308 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22309 )]
22310 pub public_ip: String,
22311 #[serde(default, skip_serializing_if = "Option::is_none")]
22315 pub sip_group: Option<ListLocationsResponseSipGroup>,
22316 #[serde(default, skip_serializing_if = "Option::is_none")]
22320 pub site: Option<ListLocationsResponseSite>,
22321}
22322
22323#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22324pub struct ListLocationsResponseData {
22325 #[serde(
22329 default,
22330 skip_serializing_if = "Vec::is_empty",
22331 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
22332 )]
22333 pub locations: Vec<ListLocationsResponse>,
22334 #[serde(
22338 default,
22339 skip_serializing_if = "String::is_empty",
22340 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22341 )]
22342 pub next_page_token: String,
22343 #[serde(
22347 default,
22348 skip_serializing_if = "crate::utils::zero_i64",
22349 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
22350 )]
22351 pub page_size: i64,
22352}
22353
22354#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22355pub struct AddLocationRequest {
22356 #[serde(
22360 default,
22361 skip_serializing_if = "String::is_empty",
22362 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22363 )]
22364 pub bssid: String,
22365 #[serde(
22369 default,
22370 skip_serializing_if = "String::is_empty",
22371 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22372 )]
22373 pub elin_phone_number_id: String,
22374 #[serde(
22378 default,
22379 skip_serializing_if = "String::is_empty",
22380 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22381 )]
22382 pub emergency_address_id: String,
22383 #[serde(
22387 default,
22388 skip_serializing_if = "String::is_empty",
22389 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22390 )]
22391 pub name: String,
22392 #[serde(
22396 default,
22397 skip_serializing_if = "String::is_empty",
22398 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22399 )]
22400 pub parent_location_id: String,
22401 #[serde(
22405 default,
22406 skip_serializing_if = "String::is_empty",
22407 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22408 )]
22409 pub private_ip: String,
22410 #[serde(
22414 default,
22415 skip_serializing_if = "String::is_empty",
22416 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22417 )]
22418 pub public_ip: String,
22419 #[serde(
22423 default,
22424 skip_serializing_if = "String::is_empty",
22425 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22426 )]
22427 pub sip_group_id: String,
22428 #[serde(
22432 default,
22433 skip_serializing_if = "String::is_empty",
22434 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22435 )]
22436 pub site_id: String,
22437}
22438
22439#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22441pub struct GetLocationResponseElin {
22442 #[serde(
22446 default,
22447 skip_serializing_if = "String::is_empty",
22448 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22449 )]
22450 pub phone_number: String,
22451 #[serde(
22455 default,
22456 skip_serializing_if = "String::is_empty",
22457 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22458 )]
22459 pub phone_number_id: String,
22460}
22461
22462#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22464pub struct GetLocationResponseEmergencyAddress {
22465 #[serde(
22469 default,
22470 skip_serializing_if = "String::is_empty",
22471 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
22472 rename = "address_line1"
22473 )]
22474 pub address_line_1: String,
22475 #[serde(
22479 default,
22480 skip_serializing_if = "String::is_empty",
22481 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
22482 rename = "address_line2"
22483 )]
22484 pub address_line_2: String,
22485 #[serde(
22489 default,
22490 skip_serializing_if = "String::is_empty",
22491 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22492 )]
22493 pub city: String,
22494 #[serde(
22498 default,
22499 skip_serializing_if = "String::is_empty",
22500 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22501 )]
22502 pub country: String,
22503 #[serde(
22507 default,
22508 skip_serializing_if = "String::is_empty",
22509 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22510 )]
22511 pub id: String,
22512 #[serde(
22516 default,
22517 skip_serializing_if = "String::is_empty",
22518 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22519 )]
22520 pub state_code: String,
22521 #[serde(
22525 default,
22526 skip_serializing_if = "String::is_empty",
22527 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22528 )]
22529 pub zip: String,
22530}
22531
22532#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22534pub struct GetLocationResponseSipGroup {
22535 #[serde(
22539 default,
22540 skip_serializing_if = "String::is_empty",
22541 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22542 )]
22543 pub display_name: String,
22544 #[serde(
22548 default,
22549 skip_serializing_if = "String::is_empty",
22550 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22551 )]
22552 pub id: String,
22553}
22554
22555#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22557pub struct GetLocationResponseSite {
22558 #[serde(
22562 default,
22563 skip_serializing_if = "String::is_empty",
22564 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22565 )]
22566 pub id: String,
22567 #[serde(
22571 default,
22572 skip_serializing_if = "String::is_empty",
22573 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22574 )]
22575 pub name: String,
22576}
22577
22578#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22579pub struct GetLocationResponse {
22580 #[serde(
22584 default,
22585 skip_serializing_if = "String::is_empty",
22586 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22587 )]
22588 pub bssid: String,
22589 #[serde(default, skip_serializing_if = "Option::is_none")]
22593 pub elin: Option<GetLocationResponseElin>,
22594 #[serde(default, skip_serializing_if = "Option::is_none")]
22598 pub emergency_address: Option<GetLocationResponseEmergencyAddress>,
22599 #[serde(
22603 default,
22604 skip_serializing_if = "String::is_empty",
22605 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22606 )]
22607 pub id: String,
22608 #[serde(
22612 default,
22613 skip_serializing_if = "String::is_empty",
22614 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22615 )]
22616 pub name: String,
22617 #[serde(
22618 default,
22619 skip_serializing_if = "Vec::is_empty",
22620 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
22621 )]
22622 pub network_switches: Vec<NetworkSwitches>,
22623 #[serde(
22627 default,
22628 skip_serializing_if = "String::is_empty",
22629 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22630 )]
22631 pub parent_location_id: String,
22632 #[serde(
22636 default,
22637 skip_serializing_if = "String::is_empty",
22638 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22639 )]
22640 pub private_ip: String,
22641 #[serde(
22645 default,
22646 skip_serializing_if = "String::is_empty",
22647 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22648 )]
22649 pub public_ip: String,
22650 #[serde(default, skip_serializing_if = "Option::is_none")]
22654 pub sip_group: Option<GetLocationResponseSipGroup>,
22655 #[serde(default, skip_serializing_if = "Option::is_none")]
22659 pub site: Option<GetLocationResponseSite>,
22660}
22661
22662#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22663pub struct UpdateLocationRequest {
22664 #[serde(
22668 default,
22669 skip_serializing_if = "String::is_empty",
22670 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22671 )]
22672 pub bssid: String,
22673 #[serde(
22677 default,
22678 skip_serializing_if = "String::is_empty",
22679 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22680 )]
22681 pub elin_phone_number_id: String,
22682 #[serde(
22686 default,
22687 skip_serializing_if = "String::is_empty",
22688 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22689 )]
22690 pub emergency_address_id: String,
22691 #[serde(
22695 default,
22696 skip_serializing_if = "String::is_empty",
22697 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22698 )]
22699 pub name: String,
22700 #[serde(
22701 default,
22702 skip_serializing_if = "Vec::is_empty",
22703 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
22704 )]
22705 pub network_switches: Vec<NetworkSwitches>,
22706 #[serde(
22710 default,
22711 skip_serializing_if = "String::is_empty",
22712 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22713 )]
22714 pub private_ip: String,
22715 #[serde(
22719 default,
22720 skip_serializing_if = "String::is_empty",
22721 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22722 )]
22723 pub public_ip: String,
22724 #[serde(
22728 default,
22729 skip_serializing_if = "String::is_empty",
22730 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22731 )]
22732 pub sip_group_id: String,
22733}
22734
22735#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22737pub struct SipTrunk {
22738 #[serde(
22742 default,
22743 skip_serializing_if = "String::is_empty",
22744 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22745 )]
22746 pub id: String,
22747 #[serde(
22751 default,
22752 skip_serializing_if = "String::is_empty",
22753 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22754 )]
22755 pub name: String,
22756}
22757
22758#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22759pub struct SipGroups {
22760 #[serde(
22764 default,
22765 skip_serializing_if = "String::is_empty",
22766 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22767 )]
22768 pub description: String,
22769 #[serde(
22773 default,
22774 skip_serializing_if = "String::is_empty",
22775 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22776 )]
22777 pub display_name: String,
22778 #[serde(
22782 default,
22783 skip_serializing_if = "String::is_empty",
22784 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22785 )]
22786 pub id: String,
22787 #[serde(
22791 default,
22792 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
22793 )]
22794 pub send_sip_group_name: bool,
22795 #[serde(default, skip_serializing_if = "Option::is_none")]
22799 pub sip_trunk: Option<SipTrunk>,
22800}
22801
22802#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22803pub struct ListSipGroupsResponse {
22804 #[serde(
22808 default,
22809 skip_serializing_if = "String::is_empty",
22810 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22811 )]
22812 pub next_page_token: String,
22813 #[serde(
22817 default,
22818 skip_serializing_if = "crate::utils::zero_i64",
22819 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
22820 )]
22821 pub page_size: i64,
22822 #[serde(
22826 default,
22827 skip_serializing_if = "Vec::is_empty",
22828 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
22829 )]
22830 pub sip_groups: Vec<SipGroups>,
22831}
22832
22833#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
22837pub enum GetSettingTemplateResponseType {
22838 #[serde(rename = "autoReceptionist")]
22839 AutoReceptionist,
22840 #[serde(rename = "commonArea")]
22841 CommonArea,
22842 #[serde(rename = "group")]
22843 Group,
22844 #[serde(rename = "interop")]
22845 Interop,
22846 #[serde(rename = "user")]
22847 User,
22848 #[serde(rename = "zr")]
22849 Zr,
22850 #[serde(rename = "")]
22851 #[default]
22852 Noop,
22853 #[serde(other)]
22854 FallthroughString,
22855}
22856
22857impl std::fmt::Display for GetSettingTemplateResponseType {
22858 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
22859 match self {
22860 GetSettingTemplateResponseType::AutoReceptionist => "autoReceptionist",
22861 GetSettingTemplateResponseType::CommonArea => "commonArea",
22862 GetSettingTemplateResponseType::Group => "group",
22863 GetSettingTemplateResponseType::Interop => "interop",
22864 GetSettingTemplateResponseType::User => "user",
22865 GetSettingTemplateResponseType::Zr => "zr",
22866 GetSettingTemplateResponseType::Noop => "",
22867 GetSettingTemplateResponseType::FallthroughString => "*",
22868 }
22869 .fmt(f)
22870 }
22871}
22872
22873impl GetSettingTemplateResponseType {
22874 pub fn is_noop(&self) -> bool {
22875 matches!(self, GetSettingTemplateResponseType::Noop)
22876 }
22877}
22878
22879#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22880pub struct GetSettingTemplateResponseProfile {
22881 #[serde(
22885 default,
22886 skip_serializing_if = "String::is_empty",
22887 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22888 )]
22889 pub area_code: String,
22890 #[serde(
22894 default,
22895 skip_serializing_if = "String::is_empty",
22896 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22897 )]
22898 pub country: String,
22899}
22900
22901#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22902pub struct AutoCallRecording {
22903 #[serde(
22907 default,
22908 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
22909 )]
22910 pub enable: bool,
22911 #[serde(
22915 default,
22916 skip_serializing_if = "String::is_empty",
22917 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
22918 )]
22919 pub recording_calls: String,
22920 #[serde(
22924 default,
22925 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
22926 )]
22927 pub recording_start_prompt: bool,
22928 #[serde(
22932 default,
22933 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
22934 )]
22935 pub recording_transcription: bool,
22936}
22937
22938#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22939pub struct AdHocCallRecording {
22940 #[serde(
22944 default,
22945 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
22946 )]
22947 pub enable: bool,
22948 #[serde(
22952 default,
22953 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
22954 )]
22955 pub recording_start_prompt: bool,
22956 #[serde(
22960 default,
22961 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
22962 )]
22963 pub recording_transcription: bool,
22964}
22965
22966#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22967pub struct Sms {
22968 #[serde(
22972 default,
22973 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
22974 )]
22975 pub enable: bool,
22976 #[serde(
22980 default,
22981 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
22982 )]
22983 pub international_sms: bool,
22984}
22985
22986#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
22987pub struct Voicemail {
22988 #[serde(
22992 default,
22993 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
22994 )]
22995 pub allow_transcription: bool,
22996 #[serde(
23000 default,
23001 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
23002 )]
23003 pub enable: bool,
23004}
23005
23006#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
23007pub struct GetSettingTemplateResponsePolicy {
23008 #[serde(default, skip_serializing_if = "Option::is_none")]
23009 pub ad_hoc_call_recording: Option<AdHocCallRecording>,
23010 #[serde(default, skip_serializing_if = "Option::is_none")]
23011 pub auto_call_recording: Option<AutoCallRecording>,
23012 #[serde(default, skip_serializing_if = "Option::is_none")]
23013 pub sms: Option<Sms>,
23014 #[serde(default, skip_serializing_if = "Option::is_none")]
23015 pub voicemail: Option<Voicemail>,
23016}
23017
23018#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
23019pub struct CustomHours {
23020 #[serde(default, skip_serializing_if = "Option::is_none")]
23025 pub from: Option<chrono::NaiveTime>,
23026 #[serde(default, skip_serializing_if = "Option::is_none")]
23031 pub to: Option<chrono::NaiveTime>,
23032 #[serde(
23036 default,
23037 skip_serializing_if = "crate::utils::zero_i64",
23038 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
23039 rename = "type"
23040 )]
23041 pub type_: i64,
23042 #[serde(
23046 default,
23047 skip_serializing_if = "crate::utils::zero_i64",
23048 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
23049 )]
23050 pub weekday: i64,
23051}
23052
23053#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
23063pub enum GetSettingTemplateResponseUserSettingsCallHandlingBusinessHoursConnectOperatorType {
23064 #[serde(rename = "autoReceptionist")]
23065 AutoReceptionist,
23066 #[serde(rename = "callQueue")]
23067 CallQueue,
23068 #[serde(rename = "commonAreaPhone")]
23069 CommonAreaPhone,
23070 #[serde(rename = "sharedLineGroup")]
23071 SharedLineGroup,
23072 #[serde(rename = "user")]
23073 User,
23074 #[serde(rename = "zoomRoom")]
23075 ZoomRoom,
23076 #[serde(rename = "")]
23077 #[default]
23078 Noop,
23079 #[serde(other)]
23080 FallthroughString,
23081}
23082
23083impl std::fmt::Display
23084 for GetSettingTemplateResponseUserSettingsCallHandlingBusinessHoursConnectOperatorType
23085{
23086 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
23087 match self {
23088GetSettingTemplateResponseUserSettingsCallHandlingBusinessHoursConnectOperatorType::AutoReceptionist => "autoReceptionist",
23089GetSettingTemplateResponseUserSettingsCallHandlingBusinessHoursConnectOperatorType::CallQueue => "callQueue",
23090GetSettingTemplateResponseUserSettingsCallHandlingBusinessHoursConnectOperatorType::CommonAreaPhone => "commonAreaPhone",
23091GetSettingTemplateResponseUserSettingsCallHandlingBusinessHoursConnectOperatorType::SharedLineGroup => "sharedLineGroup",
23092GetSettingTemplateResponseUserSettingsCallHandlingBusinessHoursConnectOperatorType::User => "user",
23093GetSettingTemplateResponseUserSettingsCallHandlingBusinessHoursConnectOperatorType::ZoomRoom => "zoomRoom",
23094GetSettingTemplateResponseUserSettingsCallHandlingBusinessHoursConnectOperatorType::Noop => "",
23095GetSettingTemplateResponseUserSettingsCallHandlingBusinessHoursConnectOperatorType::FallthroughString => "*",
23096}
23097.fmt(f)
23098 }
23099}
23100
23101impl GetSettingTemplateResponseUserSettingsCallHandlingBusinessHoursConnectOperatorType {
23102 pub fn is_noop(&self) -> bool {
23103 matches!(self, GetSettingTemplateResponseUserSettingsCallHandlingBusinessHoursConnectOperatorType::Noop)
23104 }
23105}
23106
23107#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
23109pub struct ConnectOperator {
23110 #[serde(
23114 default,
23115 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
23116 )]
23117 pub enable: bool,
23118 #[serde(
23122 default,
23123 skip_serializing_if = "String::is_empty",
23124 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23125 )]
23126 pub id: String,
23127 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
23131 pub type_:
23132 Option<GetSettingTemplateResponseUserSettingsCallHandlingBusinessHoursConnectOperatorType>,
23133}
23134
23135#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
23136pub struct BusinessHours {
23137 #[serde(
23141 default,
23142 skip_serializing_if = "crate::utils::zero_i64",
23143 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
23144 )]
23145 pub business_hour_action: i64,
23146 #[serde(default, skip_serializing_if = "Option::is_none")]
23150 pub connect_to_operator: Option<ConnectOperator>,
23151 #[serde(
23152 default,
23153 skip_serializing_if = "Vec::is_empty",
23154 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
23155 )]
23156 pub custom_hours: Vec<CustomHours>,
23157 #[serde(default, skip_serializing_if = "Option::is_none")]
23162 pub ring_type: Option<serde_json::Value>,
23163 #[serde(default, skip_serializing_if = "Option::is_none")]
23168 pub ringing_duration: Option<serde_json::Value>,
23169 #[serde(
23173 default,
23174 skip_serializing_if = "crate::utils::zero_i64",
23175 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
23176 rename = "type"
23177 )]
23178 pub type_: i64,
23179}
23180
23181#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
23182pub struct CloseHours {
23183 #[serde(
23187 default,
23188 skip_serializing_if = "crate::utils::zero_i64",
23189 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
23190 )]
23191 pub close_hour_action: i64,
23192 #[serde(default, skip_serializing_if = "Option::is_none")]
23196 pub connect_to_operator: Option<ConnectOperator>,
23197 #[serde(default, skip_serializing_if = "Option::is_none")]
23202 pub max_wait_time: Option<serde_json::Value>,
23203}
23204
23205#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
23206pub struct CallHandling {
23207 #[serde(default, skip_serializing_if = "Option::is_none")]
23208 pub business_hours: Option<BusinessHours>,
23209 #[serde(default, skip_serializing_if = "Option::is_none")]
23210 pub close_hours: Option<CloseHours>,
23211}
23212
23213#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
23214pub struct GetSettingTemplateResponseUserSettingsDeskPhone {
23215 #[serde(
23219 default,
23220 skip_serializing_if = "String::is_empty",
23221 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23222 )]
23223 pub pin_code: String,
23224}
23225
23226#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
23234pub enum HoldMusic {
23235 #[serde(rename = "default")]
23236 Default,
23237 #[serde(rename = "disable")]
23238 Disable,
23239 #[serde(rename = "")]
23240 #[default]
23241 Noop,
23242 #[serde(other)]
23243 FallthroughString,
23244}
23245
23246impl std::fmt::Display for HoldMusic {
23247 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
23248 match self {
23249 HoldMusic::Default => "default",
23250 HoldMusic::Disable => "disable",
23251 HoldMusic::Noop => "",
23252 HoldMusic::FallthroughString => "*",
23253 }
23254 .fmt(f)
23255 }
23256}
23257
23258impl HoldMusic {
23259 pub fn is_noop(&self) -> bool {
23260 matches!(self, HoldMusic::Noop)
23261 }
23262}
23263
23264#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
23265pub struct GetSettingTemplateResponseUserSettings {
23266 #[serde(
23270 default,
23271 skip_serializing_if = "String::is_empty",
23272 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23273 )]
23274 pub audio_prompt_language: String,
23275 #[serde(
23279 default,
23280 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
23281 )]
23282 pub block_calls_without_caller_id: bool,
23283 #[serde(default, skip_serializing_if = "Option::is_none")]
23284 pub call_handling: Option<CallHandling>,
23285 #[serde(default, skip_serializing_if = "Option::is_none")]
23286 pub desk_phone: Option<GetSettingTemplateResponseUserSettingsDeskPhone>,
23287 #[serde(default, skip_serializing_if = "Option::is_none")]
23295 pub hold_music: Option<HoldMusic>,
23296}
23297
23298#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
23299pub struct GetSettingTemplateResponse {
23300 #[serde(
23304 default,
23305 skip_serializing_if = "String::is_empty",
23306 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23307 )]
23308 pub description: String,
23309 #[serde(
23313 default,
23314 skip_serializing_if = "String::is_empty",
23315 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23316 )]
23317 pub id: String,
23318 #[serde(
23322 default,
23323 skip_serializing_if = "String::is_empty",
23324 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23325 )]
23326 pub name: String,
23327 #[serde(default, skip_serializing_if = "Option::is_none")]
23328 pub policy: Option<GetSettingTemplateResponsePolicy>,
23329 #[serde(default, skip_serializing_if = "Option::is_none")]
23330 pub profile: Option<GetSettingTemplateResponseProfile>,
23331 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
23335 pub type_: Option<GetSettingTemplateResponseType>,
23336 #[serde(default, skip_serializing_if = "Option::is_none")]
23337 pub user_settings: Option<GetSettingTemplateResponseUserSettings>,
23338}
23339
23340#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
23344pub enum RecordingCalls {
23345 #[serde(rename = "both")]
23346 Both,
23347 #[serde(rename = "inbound")]
23348 Inbound,
23349 #[serde(rename = "outbound")]
23350 Outbound,
23351 #[serde(rename = "")]
23352 #[default]
23353 Noop,
23354 #[serde(other)]
23355 FallthroughString,
23356}
23357
23358impl std::fmt::Display for RecordingCalls {
23359 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
23360 match self {
23361 RecordingCalls::Both => "both",
23362 RecordingCalls::Inbound => "inbound",
23363 RecordingCalls::Outbound => "outbound",
23364 RecordingCalls::Noop => "",
23365 RecordingCalls::FallthroughString => "*",
23366 }
23367 .fmt(f)
23368 }
23369}
23370
23371impl RecordingCalls {
23372 pub fn is_noop(&self) -> bool {
23373 matches!(self, RecordingCalls::Noop)
23374 }
23375}
23376
23377#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
23378pub struct UpdateSettingTemplateRequestPolicyAutoCallRecording {
23379 #[serde(
23383 default,
23384 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
23385 )]
23386 pub enable: bool,
23387 #[serde(default, skip_serializing_if = "Option::is_none")]
23391 pub recording_calls: Option<RecordingCalls>,
23392 #[serde(
23396 default,
23397 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
23398 )]
23399 pub recording_start_prompt: bool,
23400 #[serde(
23404 default,
23405 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
23406 )]
23407 pub recording_transcription: bool,
23408}
23409
23410#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
23411pub struct UpdateSettingTemplateRequestPolicy {
23412 #[serde(default, skip_serializing_if = "Option::is_none")]
23413 pub ad_hoc_call_recording: Option<AdHocCallRecording>,
23414 #[serde(default, skip_serializing_if = "Option::is_none")]
23415 pub auto_call_recording: Option<UpdateSettingTemplateRequestPolicyAutoCallRecording>,
23416 #[serde(default, skip_serializing_if = "Option::is_none")]
23417 pub sms: Option<Sms>,
23418 #[serde(default, skip_serializing_if = "Option::is_none")]
23419 pub voicemail: Option<Voicemail>,
23420}
23421
23422#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
23423pub struct UpdateSettingTemplateRequest {
23424 #[serde(
23428 default,
23429 skip_serializing_if = "String::is_empty",
23430 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23431 )]
23432 pub description: String,
23433 #[serde(
23437 default,
23438 skip_serializing_if = "String::is_empty",
23439 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23440 )]
23441 pub name: String,
23442 #[serde(default, skip_serializing_if = "Option::is_none")]
23443 pub policy: Option<UpdateSettingTemplateRequestPolicy>,
23444 #[serde(default, skip_serializing_if = "Option::is_none")]
23445 pub profile: Option<GetSettingTemplateResponseProfile>,
23446 #[serde(default, skip_serializing_if = "Option::is_none")]
23447 pub user_settings: Option<GetSettingTemplateResponseUserSettings>,
23448}
23449
23450#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
23451pub enum PhoneUserCallLogsType {
23452 #[serde(rename = "all")]
23453 All,
23454 #[serde(rename = "missed")]
23455 Missed,
23456 #[serde(rename = "")]
23457 #[default]
23458 Noop,
23459 #[serde(other)]
23460 FallthroughString,
23461}
23462
23463impl std::fmt::Display for PhoneUserCallLogsType {
23464 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
23465 match self {
23466 PhoneUserCallLogsType::All => "all",
23467 PhoneUserCallLogsType::Missed => "missed",
23468 PhoneUserCallLogsType::Noop => "",
23469 PhoneUserCallLogsType::FallthroughString => "*",
23470 }
23471 .fmt(f)
23472 }
23473}
23474
23475impl PhoneUserCallLogsType {
23476 pub fn is_noop(&self) -> bool {
23477 matches!(self, PhoneUserCallLogsType::Noop)
23478 }
23479}
23480
23481#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
23485pub enum TimeType {
23486 #[serde(rename = "endTime")]
23487 EndTime,
23488 #[serde(rename = "startTime")]
23489 #[default]
23490 StartTime,
23491 #[serde(other)]
23492 FallthroughString,
23493}
23494
23495impl std::fmt::Display for TimeType {
23496 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
23497 match self {
23498 TimeType::EndTime => "endTime",
23499 TimeType::StartTime => "startTime",
23500 TimeType::FallthroughString => "*",
23501 }
23502 .fmt(f)
23503 }
23504}
23505
23506#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
23508pub struct ForwardedTo {
23509 #[serde(
23513 default,
23514 skip_serializing_if = "String::is_empty",
23515 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23516 )]
23517 pub extension_number: String,
23518 #[serde(
23522 default,
23523 skip_serializing_if = "String::is_empty",
23524 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23525 )]
23526 pub location: String,
23527 #[serde(
23531 default,
23532 skip_serializing_if = "String::is_empty",
23533 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23534 )]
23535 pub name: String,
23536 #[serde(
23540 default,
23541 skip_serializing_if = "String::is_empty",
23542 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23543 )]
23544 pub number_type: String,
23545 #[serde(
23549 default,
23550 skip_serializing_if = "String::is_empty",
23551 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23552 )]
23553 pub phone_number: String,
23554}
23555
23556#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
23557pub enum PhoneUserCallLogsResponseForwardedByExtensionType {
23558 #[serde(rename = "autoReceptionist")]
23559 AutoReceptionist,
23560 #[serde(rename = "callQueue")]
23561 CallQueue,
23562 #[serde(rename = "commonAreaPhone")]
23563 CommonAreaPhone,
23564 #[serde(rename = "sharedLineGroup")]
23565 SharedLineGroup,
23566 #[serde(rename = "user")]
23567 User,
23568 #[serde(rename = "")]
23569 #[default]
23570 Noop,
23571 #[serde(other)]
23572 FallthroughString,
23573}
23574
23575impl std::fmt::Display for PhoneUserCallLogsResponseForwardedByExtensionType {
23576 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
23577 match self {
23578 PhoneUserCallLogsResponseForwardedByExtensionType::AutoReceptionist => {
23579 "autoReceptionist"
23580 }
23581 PhoneUserCallLogsResponseForwardedByExtensionType::CallQueue => "callQueue",
23582 PhoneUserCallLogsResponseForwardedByExtensionType::CommonAreaPhone => "commonAreaPhone",
23583 PhoneUserCallLogsResponseForwardedByExtensionType::SharedLineGroup => "sharedLineGroup",
23584 PhoneUserCallLogsResponseForwardedByExtensionType::User => "user",
23585 PhoneUserCallLogsResponseForwardedByExtensionType::Noop => "",
23586 PhoneUserCallLogsResponseForwardedByExtensionType::FallthroughString => "*",
23587 }
23588 .fmt(f)
23589 }
23590}
23591
23592impl PhoneUserCallLogsResponseForwardedByExtensionType {
23593 pub fn is_noop(&self) -> bool {
23594 matches!(
23595 self,
23596 PhoneUserCallLogsResponseForwardedByExtensionType::Noop
23597 )
23598 }
23599}
23600
23601#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
23603pub struct ForwardedBy {
23604 #[serde(
23608 default,
23609 skip_serializing_if = "String::is_empty",
23610 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23611 )]
23612 pub extension_number: String,
23613 #[serde(default, skip_serializing_if = "Option::is_none")]
23617 pub extension_type: Option<PhoneUserCallLogsResponseForwardedByExtensionType>,
23618 #[serde(
23622 default,
23623 skip_serializing_if = "String::is_empty",
23624 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23625 )]
23626 pub location: String,
23627 #[serde(
23631 default,
23632 skip_serializing_if = "String::is_empty",
23633 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23634 )]
23635 pub name: String,
23636 #[serde(
23640 default,
23641 skip_serializing_if = "String::is_empty",
23642 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23643 )]
23644 pub number_type: String,
23645 #[serde(
23649 default,
23650 skip_serializing_if = "String::is_empty",
23651 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23652 )]
23653 pub phone_number: String,
23654}
23655
23656#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
23658pub struct AcceptedBy {
23659 #[serde(
23663 default,
23664 skip_serializing_if = "String::is_empty",
23665 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23666 )]
23667 pub extension_number: String,
23668 #[serde(
23672 default,
23673 skip_serializing_if = "String::is_empty",
23674 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23675 )]
23676 pub location: String,
23677 #[serde(
23681 default,
23682 skip_serializing_if = "String::is_empty",
23683 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23684 )]
23685 pub name: String,
23686 #[serde(
23690 default,
23691 skip_serializing_if = "String::is_empty",
23692 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23693 )]
23694 pub number_type: String,
23695 #[serde(
23699 default,
23700 skip_serializing_if = "String::is_empty",
23701 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23702 )]
23703 pub phone_number: String,
23704}
23705
23706#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
23707pub struct OutgoingBy {
23708 #[serde(
23712 default,
23713 skip_serializing_if = "String::is_empty",
23714 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23715 )]
23716 pub extension_number: String,
23717 #[serde(
23721 default,
23722 skip_serializing_if = "String::is_empty",
23723 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23724 )]
23725 pub location: String,
23726 #[serde(
23730 default,
23731 skip_serializing_if = "String::is_empty",
23732 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23733 )]
23734 pub name: String,
23735 #[serde(
23739 default,
23740 skip_serializing_if = "String::is_empty",
23741 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23742 )]
23743 pub number_type: String,
23744 #[serde(
23748 default,
23749 skip_serializing_if = "String::is_empty",
23750 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23751 )]
23752 pub phone_number: String,
23753}
23754
23755#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
23756pub struct CallLogs {
23757 #[serde(default, skip_serializing_if = "Option::is_none")]
23761 pub accepted_by: Option<AcceptedBy>,
23762 #[serde(
23766 default,
23767 skip_serializing_if = "String::is_empty",
23768 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23769 )]
23770 pub answer_start_time: String,
23771 #[serde(
23775 default,
23776 skip_serializing_if = "String::is_empty",
23777 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23778 )]
23779 pub call_end_time: String,
23780 #[serde(
23784 default,
23785 skip_serializing_if = "String::is_empty",
23786 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23787 )]
23788 pub call_id: String,
23789 #[serde(
23793 default,
23794 skip_serializing_if = "String::is_empty",
23795 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23796 )]
23797 pub callee_name: String,
23798 #[serde(
23802 default,
23803 skip_serializing_if = "String::is_empty",
23804 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23805 )]
23806 pub callee_number: String,
23807 #[serde(default, skip_serializing_if = "Option::is_none")]
23812 pub callee_number_type: Option<serde_json::Value>,
23813 #[serde(
23817 default,
23818 skip_serializing_if = "String::is_empty",
23819 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23820 )]
23821 pub caller_name: String,
23822 #[serde(
23826 default,
23827 skip_serializing_if = "String::is_empty",
23828 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23829 )]
23830 pub caller_number: String,
23831 #[serde(
23835 default,
23836 skip_serializing_if = "String::is_empty",
23837 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23838 )]
23839 pub caller_number_type: String,
23840 #[serde(
23844 default,
23845 skip_serializing_if = "String::is_empty",
23846 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23847 )]
23848 pub charge: String,
23849 #[serde(
23853 default,
23854 skip_serializing_if = "String::is_empty",
23855 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23856 )]
23857 pub client_code: String,
23858 #[serde(
23862 default,
23863 skip_serializing_if = "Option::is_none",
23864 deserialize_with = "crate::utils::date_format::deserialize"
23865 )]
23866 pub date_time: Option<chrono::NaiveDate>,
23867 #[serde(
23871 default,
23872 skip_serializing_if = "String::is_empty",
23873 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23874 )]
23875 pub direction: String,
23876 #[serde(
23880 default,
23881 skip_serializing_if = "crate::utils::zero_i64",
23882 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
23883 )]
23884 pub duration: i64,
23885 #[serde(default, skip_serializing_if = "Option::is_none")]
23889 pub forwarded_by: Option<ForwardedBy>,
23890 #[serde(default, skip_serializing_if = "Option::is_none")]
23894 pub forwarded_to: Option<ForwardedTo>,
23895 #[serde(
23899 default,
23900 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
23901 )]
23902 pub has_recording: bool,
23903 #[serde(
23907 default,
23908 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
23909 )]
23910 pub has_voicemail: bool,
23911 #[serde(
23915 default,
23916 skip_serializing_if = "String::is_empty",
23917 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23918 )]
23919 pub id: String,
23920 #[serde(default, skip_serializing_if = "Option::is_none")]
23921 pub outgoing_by: Option<OutgoingBy>,
23922 #[serde(
23926 default,
23927 skip_serializing_if = "String::is_empty",
23928 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23929 )]
23930 pub path: String,
23931 #[serde(
23935 default,
23936 skip_serializing_if = "String::is_empty",
23937 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23938 )]
23939 pub rate: String,
23940 #[serde(
23944 default,
23945 skip_serializing_if = "String::is_empty",
23946 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23947 )]
23948 pub recording_type: String,
23949 #[serde(
23953 default,
23954 skip_serializing_if = "String::is_empty",
23955 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23956 )]
23957 pub result: String,
23958 #[serde(default, skip_serializing_if = "Option::is_none")]
23959 pub site: Option<Site>,
23960 #[serde(
23964 default,
23965 skip_serializing_if = "String::is_empty",
23966 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23967 )]
23968 pub user_id: String,
23969 #[serde(
23973 default,
23974 skip_serializing_if = "crate::utils::zero_i64",
23975 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
23976 )]
23977 pub waiting_time: i64,
23978}
23979
23980#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
23982pub struct PhoneUserCallLogsResponse {
23983 #[serde(
23987 default,
23988 skip_serializing_if = "Vec::is_empty",
23989 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
23990 )]
23991 pub call_logs: Vec<CallLogs>,
23992 #[serde(
23996 default,
23997 skip_serializing_if = "String::is_empty",
23998 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23999 )]
24000 pub from: String,
24001 #[serde(
24005 default,
24006 skip_serializing_if = "String::is_empty",
24007 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24008 )]
24009 pub next_page_token: String,
24010 #[serde(
24014 default,
24015 skip_serializing_if = "crate::utils::zero_i64",
24016 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
24017 )]
24018 pub page_count: i64,
24019 #[serde(
24023 default,
24024 skip_serializing_if = "crate::utils::zero_i64",
24025 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
24026 )]
24027 pub page_size: i64,
24028 #[serde(
24032 default,
24033 skip_serializing_if = "String::is_empty",
24034 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24035 )]
24036 pub to: String,
24037 #[serde(
24041 default,
24042 skip_serializing_if = "crate::utils::zero_i64",
24043 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
24044 )]
24045 pub total_records: i64,
24046}
24047
24048#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
24049pub struct Recordings {
24050 #[serde(
24054 default,
24055 skip_serializing_if = "String::is_empty",
24056 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24057 )]
24058 pub call_id: String,
24059 #[serde(
24063 default,
24064 skip_serializing_if = "String::is_empty",
24065 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24066 )]
24067 pub call_log_id: String,
24068 #[serde(
24072 default,
24073 skip_serializing_if = "String::is_empty",
24074 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24075 )]
24076 pub callee_name: String,
24077 #[serde(
24081 default,
24082 skip_serializing_if = "String::is_empty",
24083 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24084 )]
24085 pub callee_number: String,
24086 #[serde(
24090 default,
24091 skip_serializing_if = "String::is_empty",
24092 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24093 )]
24094 pub callee_number_type: String,
24095 #[serde(
24099 default,
24100 skip_serializing_if = "String::is_empty",
24101 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24102 )]
24103 pub caller_name: String,
24104 #[serde(
24108 default,
24109 skip_serializing_if = "String::is_empty",
24110 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24111 )]
24112 pub caller_number: String,
24113 #[serde(
24117 default,
24118 skip_serializing_if = "String::is_empty",
24119 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24120 )]
24121 pub caller_number_type: String,
24122 #[serde(
24126 default,
24127 skip_serializing_if = "Option::is_none",
24128 deserialize_with = "crate::utils::date_format::deserialize"
24129 )]
24130 pub date_time: Option<chrono::NaiveDate>,
24131 #[serde(
24135 default,
24136 skip_serializing_if = "String::is_empty",
24137 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24138 )]
24139 pub direction: String,
24140 #[serde(
24144 default,
24145 skip_serializing_if = "String::is_empty",
24146 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24147 )]
24148 pub download_url: String,
24149 #[serde(
24153 default,
24154 skip_serializing_if = "String::is_empty",
24155 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24156 )]
24157 pub duration: String,
24158 #[serde(
24162 default,
24163 skip_serializing_if = "String::is_empty",
24164 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24165 )]
24166 pub id: String,
24167}
24168
24169#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
24171pub struct PhoneUserRecordingsResponse {
24172 #[serde(
24176 default,
24177 skip_serializing_if = "Option::is_none",
24178 deserialize_with = "crate::utils::date_format::deserialize"
24179 )]
24180 pub from: Option<chrono::NaiveDate>,
24181 #[serde(
24185 default,
24186 skip_serializing_if = "String::is_empty",
24187 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24188 )]
24189 pub next_page_token: String,
24190 #[serde(
24194 default,
24195 skip_serializing_if = "crate::utils::zero_i64",
24196 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
24197 )]
24198 pub page_count: i64,
24199 #[serde(
24203 default,
24204 skip_serializing_if = "crate::utils::zero_i64",
24205 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
24206 )]
24207 pub page_size: i64,
24208 #[serde(
24212 default,
24213 skip_serializing_if = "Vec::is_empty",
24214 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
24215 )]
24216 pub recordings: Vec<Recordings>,
24217 #[serde(
24221 default,
24222 skip_serializing_if = "Option::is_none",
24223 deserialize_with = "crate::utils::date_format::deserialize"
24224 )]
24225 pub to: Option<chrono::NaiveDate>,
24226 #[serde(
24230 default,
24231 skip_serializing_if = "crate::utils::zero_i64",
24232 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
24233 )]
24234 pub total_records: i64,
24235}
24236
24237#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
24241pub enum PhoneUserVoiceMailsStatus {
24242 #[serde(rename = "all")]
24243 #[default]
24244 All,
24245 #[serde(rename = "read")]
24246 Read,
24247 #[serde(rename = "unread")]
24248 Unread,
24249 #[serde(other)]
24250 FallthroughString,
24251}
24252
24253impl std::fmt::Display for PhoneUserVoiceMailsStatus {
24254 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
24255 match self {
24256 PhoneUserVoiceMailsStatus::All => "all",
24257 PhoneUserVoiceMailsStatus::Read => "read",
24258 PhoneUserVoiceMailsStatus::Unread => "unread",
24259 PhoneUserVoiceMailsStatus::FallthroughString => "*",
24260 }
24261 .fmt(f)
24262 }
24263}
24264
24265#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
24269pub enum PhoneUserVoiceMailsResponseStatus {
24270 #[serde(rename = "read")]
24271 Read,
24272 #[serde(rename = "unread")]
24273 Unread,
24274 #[serde(rename = "")]
24275 #[default]
24276 Noop,
24277 #[serde(other)]
24278 FallthroughString,
24279}
24280
24281impl std::fmt::Display for PhoneUserVoiceMailsResponseStatus {
24282 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
24283 match self {
24284 PhoneUserVoiceMailsResponseStatus::Read => "read",
24285 PhoneUserVoiceMailsResponseStatus::Unread => "unread",
24286 PhoneUserVoiceMailsResponseStatus::Noop => "",
24287 PhoneUserVoiceMailsResponseStatus::FallthroughString => "*",
24288 }
24289 .fmt(f)
24290 }
24291}
24292
24293impl PhoneUserVoiceMailsResponseStatus {
24294 pub fn is_noop(&self) -> bool {
24295 matches!(self, PhoneUserVoiceMailsResponseStatus::Noop)
24296 }
24297}
24298
24299#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
24300pub struct VoiceMails {
24301 #[serde(
24305 default,
24306 skip_serializing_if = "String::is_empty",
24307 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24308 )]
24309 pub callee_name: String,
24310 #[serde(
24314 default,
24315 skip_serializing_if = "String::is_empty",
24316 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24317 )]
24318 pub callee_number: String,
24319 #[serde(
24323 default,
24324 skip_serializing_if = "String::is_empty",
24325 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24326 )]
24327 pub callee_number_type: String,
24328 #[serde(
24332 default,
24333 skip_serializing_if = "String::is_empty",
24334 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24335 )]
24336 pub caller_name: String,
24337 #[serde(
24341 default,
24342 skip_serializing_if = "String::is_empty",
24343 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24344 )]
24345 pub caller_number: String,
24346 #[serde(
24350 default,
24351 skip_serializing_if = "String::is_empty",
24352 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24353 )]
24354 pub caller_number_type: String,
24355 #[serde(
24359 default,
24360 skip_serializing_if = "Option::is_none",
24361 deserialize_with = "crate::utils::date_format::deserialize"
24362 )]
24363 pub date_time: Option<chrono::NaiveDate>,
24364 #[serde(
24368 default,
24369 skip_serializing_if = "String::is_empty",
24370 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24371 )]
24372 pub download_url: String,
24373 #[serde(
24377 default,
24378 skip_serializing_if = "String::is_empty",
24379 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24380 )]
24381 pub duration: String,
24382 #[serde(
24386 default,
24387 skip_serializing_if = "String::is_empty",
24388 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24389 )]
24390 pub id: String,
24391 #[serde(default, skip_serializing_if = "Option::is_none")]
24395 pub status: Option<PhoneUserVoiceMailsResponseStatus>,
24396}
24397
24398#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
24400pub struct PhoneUserVoiceMailsResponse {
24401 #[serde(
24405 default,
24406 skip_serializing_if = "Option::is_none",
24407 deserialize_with = "crate::utils::date_format::deserialize"
24408 )]
24409 pub from: Option<chrono::NaiveDate>,
24410 #[serde(
24414 default,
24415 skip_serializing_if = "String::is_empty",
24416 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24417 )]
24418 pub next_page_token: String,
24419 #[serde(
24423 default,
24424 skip_serializing_if = "crate::utils::zero_i64",
24425 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
24426 )]
24427 pub page_count: i64,
24428 #[serde(
24432 default,
24433 skip_serializing_if = "crate::utils::zero_i64",
24434 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
24435 )]
24436 pub page_size: i64,
24437 #[serde(
24441 default,
24442 skip_serializing_if = "Option::is_none",
24443 deserialize_with = "crate::utils::date_format::deserialize"
24444 )]
24445 pub to: Option<chrono::NaiveDate>,
24446 #[serde(
24450 default,
24451 skip_serializing_if = "crate::utils::zero_i64",
24452 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
24453 )]
24454 pub total_records: i64,
24455 #[serde(
24459 default,
24460 skip_serializing_if = "Vec::is_empty",
24461 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
24462 )]
24463 pub voice_mails: Vec<VoiceMails>,
24464}
24465
24466#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
24468pub struct AddUserSettingRequestVoiceMail {
24469 #[serde(
24473 default,
24474 skip_serializing_if = "String::is_empty",
24475 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24476 )]
24477 pub access_user_id: String,
24478 #[serde(
24482 default,
24483 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
24484 )]
24485 pub delete: bool,
24486 #[serde(
24490 default,
24491 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
24492 )]
24493 pub download: bool,
24494}
24495
24496#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
24497pub struct AddUserSettingRequest {
24498 #[serde(default, skip_serializing_if = "Option::is_none")]
24502 pub voice_mail: Option<AddUserSettingRequestVoiceMail>,
24503}
24504
24505#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
24506pub struct AddUserSettingResponseVoiceMail {
24507 #[serde(
24511 default,
24512 skip_serializing_if = "String::is_empty",
24513 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24514 )]
24515 pub access_user_id: String,
24516 #[serde(
24520 default,
24521 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
24522 )]
24523 pub delete: bool,
24524 #[serde(
24528 default,
24529 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
24530 )]
24531 pub download: bool,
24532 #[serde(
24536 default,
24537 skip_serializing_if = "String::is_empty",
24538 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24539 )]
24540 pub shared_id: String,
24541}
24542
24543#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
24544pub struct AddUserSettingResponse {
24545 #[serde(default, skip_serializing_if = "Option::is_none")]
24546 pub voice_mail: Option<AddUserSettingResponseVoiceMail>,
24547}
24548
24549#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
24551pub struct UpdateUserSettingRequestVoiceMail {
24552 #[serde(
24556 default,
24557 skip_serializing_if = "String::is_empty",
24558 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24559 )]
24560 pub access_user_id: String,
24561 #[serde(
24565 default,
24566 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
24567 )]
24568 pub delete: bool,
24569 #[serde(
24573 default,
24574 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
24575 )]
24576 pub download: bool,
24577 #[serde(
24581 default,
24582 skip_serializing_if = "String::is_empty",
24583 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24584 )]
24585 pub shared_id: String,
24586}
24587
24588#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
24589pub struct UpdateUserSettingRequest {
24590 #[serde(default, skip_serializing_if = "Option::is_none")]
24594 pub voice_mail: Option<UpdateUserSettingRequestVoiceMail>,
24595}
24596
24597#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
24606pub enum CallType {
24607 #[serde(rename = "contactCenter")]
24608 ContactCenter,
24609 #[serde(rename = "international")]
24610 International,
24611 #[serde(rename = "pstn")]
24612 Pstn,
24613 #[serde(rename = "tollfree")]
24614 Tollfree,
24615 #[serde(rename = "voip")]
24616 Voip,
24617 #[serde(rename = "")]
24618 #[default]
24619 Noop,
24620 #[serde(other)]
24621 FallthroughString,
24622}
24623
24624impl std::fmt::Display for CallType {
24625 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
24626 match self {
24627 CallType::ContactCenter => "contactCenter",
24628 CallType::International => "international",
24629 CallType::Pstn => "pstn",
24630 CallType::Tollfree => "tollfree",
24631 CallType::Voip => "voip",
24632 CallType::Noop => "",
24633 CallType::FallthroughString => "*",
24634 }
24635 .fmt(f)
24636 }
24637}
24638
24639impl CallType {
24640 pub fn is_noop(&self) -> bool {
24641 matches!(self, CallType::Noop)
24642 }
24643}
24644
24645#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
24646pub struct Owner {
24647 #[serde(
24651 default,
24652 skip_serializing_if = "crate::utils::zero_i64",
24653 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
24654 )]
24655 pub extension_number: i64,
24656 #[serde(
24660 default,
24661 skip_serializing_if = "String::is_empty",
24662 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24663 )]
24664 pub id: String,
24665 #[serde(
24669 default,
24670 skip_serializing_if = "String::is_empty",
24671 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24672 )]
24673 pub name: String,
24674 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
24675 pub type_: Option<PhoneUserCallLogsResponseForwardedByExtensionType>,
24676}
24677
24678#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
24679pub struct AccountCallLogsResponse {
24680 #[serde(
24684 default,
24685 skip_serializing_if = "Option::is_none",
24686 deserialize_with = "crate::utils::date_time_format::deserialize"
24687 )]
24688 pub answer_start_time: Option<chrono::DateTime<chrono::Utc>>,
24689 #[serde(
24693 default,
24694 skip_serializing_if = "String::is_empty",
24695 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24696 )]
24697 pub call_id: String,
24698 #[serde(default, skip_serializing_if = "Option::is_none")]
24707 pub call_type: Option<CallType>,
24708 #[serde(
24712 default,
24713 skip_serializing_if = "String::is_empty",
24714 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24715 )]
24716 pub callee_name: String,
24717 #[serde(
24721 default,
24722 skip_serializing_if = "String::is_empty",
24723 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24724 )]
24725 pub callee_number: String,
24726 #[serde(default, skip_serializing_if = "Option::is_none")]
24731 pub callee_number_type: Option<serde_json::Value>,
24732 #[serde(
24736 default,
24737 skip_serializing_if = "String::is_empty",
24738 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24739 )]
24740 pub caller_name: String,
24741 #[serde(
24745 default,
24746 skip_serializing_if = "String::is_empty",
24747 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24748 )]
24749 pub caller_number: String,
24750 #[serde(
24754 default,
24755 skip_serializing_if = "String::is_empty",
24756 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24757 )]
24758 pub caller_number_type: String,
24759 #[serde(
24763 default,
24764 skip_serializing_if = "String::is_empty",
24765 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24766 )]
24767 pub charge: String,
24768 #[serde(
24772 default,
24773 skip_serializing_if = "String::is_empty",
24774 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24775 )]
24776 pub client_code: String,
24777 #[serde(
24781 default,
24782 skip_serializing_if = "Option::is_none",
24783 deserialize_with = "crate::utils::date_format::deserialize"
24784 )]
24785 pub date_time: Option<chrono::NaiveDate>,
24786 #[serde(
24790 default,
24791 skip_serializing_if = "String::is_empty",
24792 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24793 )]
24794 pub device_private_ip: String,
24795 #[serde(
24799 default,
24800 skip_serializing_if = "String::is_empty",
24801 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24802 )]
24803 pub device_public_ip: String,
24804 #[serde(
24808 default,
24809 skip_serializing_if = "String::is_empty",
24810 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24811 )]
24812 pub direction: String,
24813 #[serde(
24817 default,
24818 skip_serializing_if = "crate::utils::zero_i64",
24819 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
24820 )]
24821 pub duration: i64,
24822 #[serde(
24826 default,
24827 skip_serializing_if = "String::is_empty",
24828 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24829 )]
24830 pub id: String,
24831 #[serde(default, skip_serializing_if = "Option::is_none")]
24832 pub owner: Option<Owner>,
24833 #[serde(
24837 default,
24838 skip_serializing_if = "String::is_empty",
24839 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24840 )]
24841 pub path: String,
24842 #[serde(
24846 default,
24847 skip_serializing_if = "String::is_empty",
24848 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24849 )]
24850 pub rate: String,
24851 #[serde(
24855 default,
24856 skip_serializing_if = "String::is_empty",
24857 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24858 )]
24859 pub recording_id: String,
24860 #[serde(default, skip_serializing_if = "Option::is_none")]
24865 pub recording_type: Option<serde_json::Value>,
24866 #[serde(
24870 default,
24871 skip_serializing_if = "String::is_empty",
24872 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24873 )]
24874 pub result: String,
24875 #[serde(default, skip_serializing_if = "Option::is_none")]
24876 pub site: Option<Site>,
24877 #[serde(
24881 default,
24882 skip_serializing_if = "String::is_empty",
24883 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24884 )]
24885 pub user_id: String,
24886 #[serde(
24890 default,
24891 skip_serializing_if = "String::is_empty",
24892 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24893 )]
24894 pub waiting_time: String,
24895}
24896
24897#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
24899pub struct AccountCallLogsResponseData {
24900 #[serde(
24904 default,
24905 skip_serializing_if = "Vec::is_empty",
24906 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
24907 )]
24908 pub call_logs: Vec<AccountCallLogsResponse>,
24909 #[serde(
24913 default,
24914 skip_serializing_if = "String::is_empty",
24915 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24916 )]
24917 pub from: String,
24918 #[serde(
24922 default,
24923 skip_serializing_if = "String::is_empty",
24924 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24925 )]
24926 pub next_page_token: String,
24927 #[serde(
24931 default,
24932 skip_serializing_if = "crate::utils::zero_i64",
24933 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
24934 )]
24935 pub page_count: i64,
24936 #[serde(
24940 default,
24941 skip_serializing_if = "crate::utils::zero_i64",
24942 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
24943 )]
24944 pub page_size: i64,
24945 #[serde(
24949 default,
24950 skip_serializing_if = "String::is_empty",
24951 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
24952 )]
24953 pub to: String,
24954 #[serde(
24958 default,
24959 skip_serializing_if = "crate::utils::zero_i64",
24960 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
24961 )]
24962 pub total_records: i64,
24963}
24964
24965#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
24966pub struct AddByocNumberResponse {
24967 #[serde(
24968 default,
24969 skip_serializing_if = "Vec::is_empty",
24970 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
24971 )]
24972 pub phone_numbers: Vec<PhoneUserResponseNumbers>,
24973}
24974
24975#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
24976pub struct CallingPlans {
24977 #[serde(
24981 default,
24982 skip_serializing_if = "String::is_empty",
24983 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
24984 rename = "type"
24985 )]
24986 pub type_: String,
24987}
24988
24989#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
24990pub struct AssignCallingPlanRequest {
24991 #[serde(
24992 default,
24993 skip_serializing_if = "Vec::is_empty",
24994 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
24995 )]
24996 pub calling_plans: Vec<CallingPlans>,
24997}
24998
24999#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
25003pub enum GetPhoneRecordingsResponseOwnerType {
25004 #[serde(rename = "call queue")]
25005 CallQueue,
25006 #[serde(rename = "user")]
25007 User,
25008 #[serde(rename = "")]
25009 #[default]
25010 Noop,
25011 #[serde(other)]
25012 FallthroughString,
25013}
25014
25015impl std::fmt::Display for GetPhoneRecordingsResponseOwnerType {
25016 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
25017 match self {
25018 GetPhoneRecordingsResponseOwnerType::CallQueue => "call queue",
25019 GetPhoneRecordingsResponseOwnerType::User => "user",
25020 GetPhoneRecordingsResponseOwnerType::Noop => "",
25021 GetPhoneRecordingsResponseOwnerType::FallthroughString => "*",
25022 }
25023 .fmt(f)
25024 }
25025}
25026
25027impl GetPhoneRecordingsResponseOwnerType {
25028 pub fn is_noop(&self) -> bool {
25029 matches!(self, GetPhoneRecordingsResponseOwnerType::Noop)
25030 }
25031}
25032
25033#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
25035pub struct GetPhoneRecordingsResponseOwner {
25036 #[serde(
25040 default,
25041 skip_serializing_if = "String::is_empty",
25042 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25043 )]
25044 pub extension_number: String,
25045 #[serde(
25049 default,
25050 skip_serializing_if = "String::is_empty",
25051 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25052 )]
25053 pub id: String,
25054 #[serde(
25058 default,
25059 skip_serializing_if = "String::is_empty",
25060 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25061 )]
25062 pub name: String,
25063 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
25067 pub type_: Option<GetPhoneRecordingsResponseOwnerType>,
25068}
25069
25070#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
25074pub enum Direction {
25075 #[serde(rename = "inbound")]
25076 Inbound,
25077 #[serde(rename = "outbound")]
25078 Outbound,
25079 #[serde(rename = "")]
25080 #[default]
25081 Noop,
25082 #[serde(other)]
25083 FallthroughString,
25084}
25085
25086impl std::fmt::Display for Direction {
25087 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
25088 match self {
25089 Direction::Inbound => "inbound",
25090 Direction::Outbound => "outbound",
25091 Direction::Noop => "",
25092 Direction::FallthroughString => "*",
25093 }
25094 .fmt(f)
25095 }
25096}
25097
25098impl Direction {
25099 pub fn is_noop(&self) -> bool {
25100 matches!(self, Direction::Noop)
25101 }
25102}
25103
25104#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
25105pub struct GetPhoneRecordingsResponse {
25106 #[serde(
25110 default,
25111 skip_serializing_if = "String::is_empty",
25112 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25113 )]
25114 pub call_id: String,
25115 #[serde(
25119 default,
25120 skip_serializing_if = "String::is_empty",
25121 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25122 )]
25123 pub call_log_id: String,
25124 #[serde(
25128 default,
25129 skip_serializing_if = "String::is_empty",
25130 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25131 )]
25132 pub callee_name: String,
25133 #[serde(
25137 default,
25138 skip_serializing_if = "String::is_empty",
25139 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25140 )]
25141 pub callee_number: String,
25142 #[serde(default, skip_serializing_if = "Option::is_none")]
25147 pub callee_number_type: Option<serde_json::Value>,
25148 #[serde(
25152 default,
25153 skip_serializing_if = "String::is_empty",
25154 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25155 )]
25156 pub caller_name: String,
25157 #[serde(
25161 default,
25162 skip_serializing_if = "String::is_empty",
25163 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25164 )]
25165 pub caller_number: String,
25166 #[serde(default, skip_serializing_if = "Option::is_none")]
25171 pub caller_number_type: Option<serde_json::Value>,
25172 #[serde(
25176 default,
25177 skip_serializing_if = "Option::is_none",
25178 deserialize_with = "crate::utils::date_time_format::deserialize"
25179 )]
25180 pub date_time: Option<chrono::DateTime<chrono::Utc>>,
25181 #[serde(default, skip_serializing_if = "Option::is_none")]
25185 pub direction: Option<Direction>,
25186 #[serde(
25190 default,
25191 skip_serializing_if = "String::is_empty",
25192 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25193 )]
25194 pub download_url: String,
25195 #[serde(
25199 default,
25200 skip_serializing_if = "crate::utils::zero_i64",
25201 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
25202 )]
25203 pub duration: i64,
25204 #[serde(
25208 default,
25209 skip_serializing_if = "Option::is_none",
25210 deserialize_with = "crate::utils::date_time_format::deserialize"
25211 )]
25212 pub end_time: Option<chrono::DateTime<chrono::Utc>>,
25213 #[serde(
25217 default,
25218 skip_serializing_if = "String::is_empty",
25219 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25220 )]
25221 pub id: String,
25222 #[serde(default, skip_serializing_if = "Option::is_none")]
25226 pub owner: Option<GetPhoneRecordingsResponseOwner>,
25227 #[serde(
25231 default,
25232 skip_serializing_if = "String::is_empty",
25233 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25234 )]
25235 pub recording_type: String,
25236 #[serde(default, skip_serializing_if = "Option::is_none")]
25237 pub site: Option<Site>,
25238}
25239
25240#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
25241pub struct GetPhoneRecordingsResponseData {
25242 #[serde(
25246 default,
25247 skip_serializing_if = "String::is_empty",
25248 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25249 )]
25250 pub next_page_token: String,
25251 #[serde(
25255 default,
25256 skip_serializing_if = "crate::utils::zero_i64",
25257 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
25258 )]
25259 pub page_size: i64,
25260 #[serde(
25261 default,
25262 skip_serializing_if = "Vec::is_empty",
25263 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
25264 )]
25265 pub recordings: Vec<GetPhoneRecordingsResponse>,
25266 #[serde(
25270 default,
25271 skip_serializing_if = "crate::utils::zero_i64",
25272 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
25273 )]
25274 pub total_records: i64,
25275}
25276
25277#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
25278pub struct ByocSipTrunk {
25279 #[serde(
25283 default,
25284 skip_serializing_if = "String::is_empty",
25285 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25286 )]
25287 pub carrier: String,
25288 #[serde(
25292 default,
25293 skip_serializing_if = "String::is_empty",
25294 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25295 )]
25296 pub carrier_account: String,
25297 #[serde(
25301 default,
25302 skip_serializing_if = "String::is_empty",
25303 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25304 )]
25305 pub id: String,
25306 #[serde(
25310 default,
25311 skip_serializing_if = "String::is_empty",
25312 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25313 )]
25314 pub name: String,
25315 #[serde(
25319 default,
25320 skip_serializing_if = "String::is_empty",
25321 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25322 )]
25323 pub region: String,
25324 #[serde(
25328 default,
25329 skip_serializing_if = "String::is_empty",
25330 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25331 )]
25332 pub sbc_label: String,
25333}
25334
25335#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
25336pub struct ListByocsipTrunkResponse {
25337 #[serde(
25338 default,
25339 skip_serializing_if = "Vec::is_empty",
25340 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
25341 )]
25342 pub byoc_sip_trunk: Vec<ByocSipTrunk>,
25343 #[serde(
25347 default,
25348 skip_serializing_if = "String::is_empty",
25349 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25350 )]
25351 pub next_page_token: String,
25352 #[serde(
25356 default,
25357 skip_serializing_if = "crate::utils::zero_i64",
25358 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
25359 )]
25360 pub page_size: i64,
25361}
25362
25363#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
25364pub struct SipTrunks {
25365 #[serde(
25369 default,
25370 skip_serializing_if = "String::is_empty",
25371 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25372 )]
25373 pub carrier_account: String,
25374 #[serde(
25378 default,
25379 skip_serializing_if = "String::is_empty",
25380 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25381 )]
25382 pub id: String,
25383 #[serde(
25387 default,
25388 skip_serializing_if = "String::is_empty",
25389 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25390 )]
25391 pub name: String,
25392}
25393
25394#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
25395pub struct PostPhoneSipTrunkRequest {
25396 #[serde(
25400 default,
25401 skip_serializing_if = "Vec::is_empty",
25402 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
25403 )]
25404 pub sip_trunks: Vec<SipTrunks>,
25405}
25406
25407#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
25408pub struct UpdatePhoneSipTrunkRequest {
25409 #[serde(
25413 default,
25414 skip_serializing_if = "String::is_empty",
25415 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25416 )]
25417 pub carrier_account: String,
25418 #[serde(
25422 default,
25423 skip_serializing_if = "String::is_empty",
25424 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25425 )]
25426 pub name: String,
25427}
25428
25429#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
25430pub struct AccountPlanBaseDeleteRequest {
25431 #[serde(
25435 default,
25436 skip_serializing_if = "String::is_empty",
25437 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25438 )]
25439 pub action: String,
25440 #[serde(
25444 default,
25445 skip_serializing_if = "String::is_empty",
25446 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25447 )]
25448 pub comment: String,
25449 #[serde(
25453 default,
25454 skip_serializing_if = "crate::utils::zero_i64",
25455 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
25456 )]
25457 pub reason: i64,
25458}
25459
25460#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
25464pub enum AccountPlanAddonCancelRequestAction {
25465 #[serde(rename = "cancel")]
25466 Cancel,
25467 #[serde(rename = "")]
25468 #[default]
25469 Noop,
25470 #[serde(other)]
25471 FallthroughString,
25472}
25473
25474impl std::fmt::Display for AccountPlanAddonCancelRequestAction {
25475 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
25476 match self {
25477 AccountPlanAddonCancelRequestAction::Cancel => "cancel",
25478 AccountPlanAddonCancelRequestAction::Noop => "",
25479 AccountPlanAddonCancelRequestAction::FallthroughString => "*",
25480 }
25481 .fmt(f)
25482 }
25483}
25484
25485impl AccountPlanAddonCancelRequestAction {
25486 pub fn is_noop(&self) -> bool {
25487 matches!(self, AccountPlanAddonCancelRequestAction::Noop)
25488 }
25489}
25490
25491#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
25493pub struct AccountPlanAddonCancelRequest {
25494 #[serde(default, skip_serializing_if = "Option::is_none")]
25498 pub action: Option<AccountPlanAddonCancelRequestAction>,
25499 #[serde(
25503 default,
25504 skip_serializing_if = "String::is_empty",
25505 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25506 )]
25507 pub comment: String,
25508 #[serde(
25512 default,
25513 skip_serializing_if = "crate::utils::zero_i64",
25514 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
25515 )]
25516 pub reason: i64,
25517 #[serde(
25521 default,
25522 skip_serializing_if = "String::is_empty",
25523 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
25524 rename = "type"
25525 )]
25526 pub type_: String,
25527}
25528
25529#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
25530pub struct ActivityLogs {
25531 #[serde(
25535 default,
25536 skip_serializing_if = "String::is_empty",
25537 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25538 )]
25539 pub client_type: String,
25540 #[serde(
25544 default,
25545 skip_serializing_if = "String::is_empty",
25546 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25547 )]
25548 pub email: String,
25549 #[serde(
25553 default,
25554 skip_serializing_if = "String::is_empty",
25555 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25556 )]
25557 pub ip_address: String,
25558 #[serde(
25562 default,
25563 skip_serializing_if = "Option::is_none",
25564 deserialize_with = "crate::utils::date_time_format::deserialize"
25565 )]
25566 pub time: Option<chrono::DateTime<chrono::Utc>>,
25567 #[serde(
25571 default,
25572 skip_serializing_if = "String::is_empty",
25573 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
25574 rename = "type"
25575 )]
25576 pub type_: String,
25577 #[serde(
25581 default,
25582 skip_serializing_if = "String::is_empty",
25583 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25584 )]
25585 pub version: String,
25586}
25587
25588#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
25590pub struct ReportSignInOutActivitiesResponse {
25591 #[serde(
25595 default,
25596 skip_serializing_if = "Vec::is_empty",
25597 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
25598 )]
25599 pub activity_logs: Vec<ActivityLogs>,
25600 #[serde(
25604 default,
25605 skip_serializing_if = "String::is_empty",
25606 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25607 )]
25608 pub from: String,
25609 #[serde(
25613 default,
25614 skip_serializing_if = "String::is_empty",
25615 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25616 )]
25617 pub next_page_token: String,
25618 #[serde(
25622 default,
25623 skip_serializing_if = "String::is_empty",
25624 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25625 )]
25626 pub page_size: String,
25627 #[serde(
25631 default,
25632 skip_serializing_if = "String::is_empty",
25633 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25634 )]
25635 pub to: String,
25636}
25637
25638#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
25639pub struct GetGroupSettingsResponseScheduleMeeting {
25640 #[serde(
25644 default,
25645 skip_serializing_if = "String::is_empty",
25646 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25647 )]
25648 pub audio_type: String,
25649 #[serde(
25653 default,
25654 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25655 )]
25656 pub embed_password_in_join_link: bool,
25657 #[serde(
25661 default,
25662 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25663 )]
25664 pub force_pmi_jbh_password: bool,
25665 #[serde(
25669 default,
25670 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25671 )]
25672 pub host_video: bool,
25673 #[serde(
25677 default,
25678 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25679 )]
25680 pub join_before_host: bool,
25681 #[serde(
25685 default,
25686 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25687 )]
25688 pub mute_upon_entry: bool,
25689 #[serde(
25693 default,
25694 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25695 )]
25696 pub participant_video: bool,
25697 #[serde(
25701 default,
25702 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25703 )]
25704 pub personal_meeting: bool,
25705 #[serde(
25709 default,
25710 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25711 )]
25712 pub pstn_password_protected: bool,
25713 #[serde(
25717 default,
25718 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25719 )]
25720 pub require_password_for_instant_meetings: bool,
25721 #[serde(default, skip_serializing_if = "Option::is_none")]
25726 pub require_password_for_pmi_meetings: Option<RequirePasswordPmiMeetings>,
25727 #[serde(
25731 default,
25732 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25733 )]
25734 pub require_password_for_scheduled_meetings: bool,
25735 #[serde(
25739 default,
25740 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25741 )]
25742 pub require_password_for_scheduling_new_meetings: bool,
25743 #[serde(
25747 default,
25748 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25749 )]
25750 pub upcoming_meeting_reminder: bool,
25751 #[serde(
25755 default,
25756 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25757 )]
25758 pub use_pmi_for_instant_meetings: bool,
25759 #[serde(
25763 default,
25764 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25765 )]
25766 pub use_pmi_for_schedule_meetings: bool,
25767}
25768
25769#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
25770pub struct GetGroupSettingsResponseInMeeting {
25771 #[serde(
25775 default,
25776 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25777 )]
25778 pub alert_guest_join: bool,
25779 #[serde(
25783 default,
25784 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25785 )]
25786 pub allow_show_zoom_windows: bool,
25787 #[serde(
25791 default,
25792 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25793 )]
25794 pub annotation: bool,
25795 #[serde(
25799 default,
25800 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25801 )]
25802 pub attendee_on_hold: bool,
25803 #[serde(
25807 default,
25808 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25809 )]
25810 pub auto_answer: bool,
25811 #[serde(
25815 default,
25816 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25817 )]
25818 pub auto_saving_chat: bool,
25819 #[serde(
25823 default,
25824 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25825 )]
25826 pub breakout_room: bool,
25827 #[serde(
25831 default,
25832 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25833 )]
25834 pub chat: bool,
25835 #[serde(
25839 default,
25840 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25841 )]
25842 pub closed_caption: bool,
25843 #[serde(
25847 default,
25848 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25849 )]
25850 pub co_host: bool,
25851 #[serde(
25855 default,
25856 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25857 )]
25858 pub custom_data_center_regions: bool,
25859 #[serde(
25866 default,
25867 skip_serializing_if = "Vec::is_empty",
25868 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
25869 )]
25870 pub data_center_regions: Vec<String>,
25871 #[serde(
25875 default,
25876 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
25877 rename = "e2e_encryption"
25878 )]
25879 pub e_2e_encryption: bool,
25880 #[serde(
25884 default,
25885 skip_serializing_if = "String::is_empty",
25886 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
25887 )]
25888 pub entry_exit_chime: String,
25889 #[serde(
25893 default,
25894 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25895 )]
25896 pub far_end_camera_control: bool,
25897 #[serde(
25901 default,
25902 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25903 )]
25904 pub feedback: bool,
25905 #[serde(
25909 default,
25910 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25911 )]
25912 pub file_transfer: bool,
25913 #[serde(
25917 default,
25918 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25919 )]
25920 pub group_hd: bool,
25921 #[serde(
25925 default,
25926 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25927 )]
25928 pub join_from_desktop: bool,
25929 #[serde(
25933 default,
25934 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25935 )]
25936 pub join_from_mobile: bool,
25937 #[serde(
25941 default,
25942 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25943 )]
25944 pub non_verbal_feedback: bool,
25945 #[serde(
25949 default,
25950 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25951 )]
25952 pub only_host_view_device_list: bool,
25953 #[serde(
25957 default,
25958 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25959 )]
25960 pub original_audio: bool,
25961 #[serde(
25965 default,
25966 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25967 )]
25968 pub polling: bool,
25969 #[serde(
25973 default,
25974 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25975 )]
25976 pub post_meeting_feedback: bool,
25977 #[serde(
25981 default,
25982 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25983 )]
25984 pub private_chat: bool,
25985 #[serde(
25989 default,
25990 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25991 )]
25992 pub record_play_own_voice: bool,
25993 #[serde(
25997 default,
25998 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
25999 )]
26000 pub remote_control: bool,
26001 #[serde(
26005 default,
26006 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26007 )]
26008 pub remote_support: bool,
26009 #[serde(
26013 default,
26014 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26015 )]
26016 pub request_permission_to_unmute: bool,
26017 #[serde(
26021 default,
26022 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26023 )]
26024 pub screen_sharing: bool,
26025 #[serde(
26029 default,
26030 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26031 )]
26032 pub sending_default_email_invites: bool,
26033 #[serde(
26037 default,
26038 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26039 )]
26040 pub show_a_join_from_your_browser_link: bool,
26041 #[serde(
26045 default,
26046 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26047 )]
26048 pub show_browser_join_link: bool,
26049 #[serde(
26053 default,
26054 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26055 )]
26056 pub show_device_list: bool,
26057 #[serde(
26061 default,
26062 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26063 )]
26064 pub show_meeting_control_toolbar: bool,
26065 #[serde(
26069 default,
26070 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26071 )]
26072 pub stereo_audio: bool,
26073 #[serde(
26077 default,
26078 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26079 )]
26080 pub use_html_format_email: bool,
26081 #[serde(
26085 default,
26086 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26087 )]
26088 pub virtual_background: bool,
26089 #[serde(default, skip_serializing_if = "Option::is_none")]
26093 pub virtual_background_settings: Option<VirtualBackgroundSettings>,
26094 #[serde(
26098 default,
26099 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26100 )]
26101 pub waiting_room: bool,
26102 #[serde(
26106 default,
26107 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26108 )]
26109 pub whiteboard: bool,
26110 #[serde(default, skip_serializing_if = "Option::is_none")]
26117 pub who_can_share_screen: Option<WhoCanShareScreen>,
26118 #[serde(default, skip_serializing_if = "Option::is_none")]
26125 pub who_can_share_screen_when_someone_is_sharing: Option<WhoCanShareScreen>,
26126}
26127
26128#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
26129pub struct GetGroupSettingsResponseEmailNotification {
26130 #[serde(
26134 default,
26135 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26136 )]
26137 pub alternative_host_reminder: bool,
26138 #[serde(
26142 default,
26143 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26144 )]
26145 pub cancel_meeting_reminder: bool,
26146 #[serde(
26150 default,
26151 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26152 )]
26153 pub cloud_recording_available_reminder: bool,
26154 #[serde(
26158 default,
26159 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26160 )]
26161 pub jbh_reminder: bool,
26162 #[serde(
26166 default,
26167 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26168 )]
26169 pub schedule_for_host_reminder: bool,
26170}
26171
26172#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
26174pub struct GetGroupSettingsResponseRecordingArchive {
26175 #[serde(
26179 default,
26180 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26181 )]
26182 pub enable: bool,
26183 #[serde(default, skip_serializing_if = "Option::is_none")]
26187 pub settings: Option<Settings>,
26188 #[serde(
26192 default,
26193 skip_serializing_if = "crate::utils::zero_i64",
26194 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
26195 rename = "type"
26196 )]
26197 pub type_: i64,
26198}
26199
26200#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
26201pub struct GetGroupSettingsResponseRecording {
26202 #[serde(
26206 default,
26207 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26208 )]
26209 pub account_user_access_recording: bool,
26210 #[serde(default, skip_serializing_if = "Option::is_none")]
26214 pub archive: Option<GetGroupSettingsResponseRecordingArchive>,
26215 #[serde(
26219 default,
26220 skip_serializing_if = "String::is_empty",
26221 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
26222 )]
26223 pub auto_recording: String,
26224 #[serde(
26228 default,
26229 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26230 )]
26231 pub cloud_recording: bool,
26232 #[serde(
26236 default,
26237 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26238 )]
26239 pub cloud_recording_download: bool,
26240 #[serde(
26244 default,
26245 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26246 )]
26247 pub cloud_recording_download_host: bool,
26248 #[serde(
26252 default,
26253 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26254 )]
26255 pub host_delete_cloud_recording: bool,
26256 #[serde(default, skip_serializing_if = "Option::is_none")]
26261 pub ip_address_access_control: Option<IpAddressAccessControl>,
26262 #[serde(
26266 default,
26267 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26268 )]
26269 pub local_recording: bool,
26270 #[serde(
26274 default,
26275 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26276 )]
26277 pub prevent_host_access_recording: bool,
26278 #[serde(
26282 default,
26283 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26284 )]
26285 pub record_audio_file: bool,
26286 #[serde(
26290 default,
26291 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26292 )]
26293 pub record_audio_file_each_participant: bool,
26294 #[serde(
26298 default,
26299 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26300 )]
26301 pub record_gallery_view: bool,
26302 #[serde(
26306 default,
26307 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26308 )]
26309 pub record_speaker_view: bool,
26310 #[serde(
26314 default,
26315 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26316 )]
26317 pub recording_audio_transcript: bool,
26318 #[serde(
26322 default,
26323 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26324 )]
26325 pub save_chat_text: bool,
26326 #[serde(
26330 default,
26331 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26332 )]
26333 pub show_timestamp: bool,
26334}
26335
26336#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
26337pub struct GetGroupSettingsResponseTelephony {
26338 #[serde(
26342 default,
26343 skip_serializing_if = "String::is_empty",
26344 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
26345 )]
26346 pub audio_conference_info: String,
26347 #[serde(default, skip_serializing_if = "Option::is_none")]
26351 pub telephony_regions: Option<UpdateAccountSettingsTelephonyRegions>,
26352 #[serde(
26356 default,
26357 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26358 )]
26359 pub third_party_audio: bool,
26360}
26361
26362#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
26363pub struct GetGroupSettingsResponse {
26364 #[serde(default, skip_serializing_if = "Option::is_none")]
26365 pub email_notification: Option<GetGroupSettingsResponseEmailNotification>,
26366 #[serde(default, skip_serializing_if = "Option::is_none")]
26367 pub in_meeting: Option<GetGroupSettingsResponseInMeeting>,
26368 #[serde(default, skip_serializing_if = "Option::is_none")]
26369 pub profile: Option<Profile>,
26370 #[serde(default, skip_serializing_if = "Option::is_none")]
26371 pub recording: Option<GetGroupSettingsResponseRecording>,
26372 #[serde(default, skip_serializing_if = "Option::is_none")]
26373 pub schedule_meeting: Option<GetGroupSettingsResponseScheduleMeeting>,
26374 #[serde(default, skip_serializing_if = "Option::is_none")]
26375 pub telephony: Option<GetGroupSettingsResponseTelephony>,
26376}
26377
26378#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
26387#[serde(untagged)]
26388pub enum GetGroupSettingsResponseOneOf {
26389 Domains(Domains),
26390 MeetingSecuritySettings(MeetingSecuritySettings),
26391 GetGroupSettingsResponse(GetGroupSettingsResponse),
26392}
26393
26394impl GetGroupSettingsResponseOneOf {
26395 pub fn domains(&self) -> Option<&Domains> {
26396 if let GetGroupSettingsResponseOneOf::Domains(ref_) = self {
26397 return Some(ref_);
26398 }
26399 None
26400 }
26401
26402 pub fn get_group_settings_response(&self) -> Option<&GetGroupSettingsResponse> {
26403 if let GetGroupSettingsResponseOneOf::GetGroupSettingsResponse(ref_) = self {
26404 return Some(ref_);
26405 }
26406 None
26407 }
26408
26409 pub fn meeting_security_settings(&self) -> Option<&MeetingSecuritySettings> {
26410 if let GetGroupSettingsResponseOneOf::MeetingSecuritySettings(ref_) = self {
26411 return Some(ref_);
26412 }
26413 None
26414 }
26415}
26416
26417#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
26418pub struct UpdateGroupSettingsRequestScheduleMeeting {
26419 #[serde(
26423 default,
26424 skip_serializing_if = "String::is_empty",
26425 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
26426 )]
26427 pub audio_type: String,
26428 #[serde(
26432 default,
26433 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26434 )]
26435 pub embed_password_in_join_link: bool,
26436 #[serde(
26440 default,
26441 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26442 )]
26443 pub force_pmi_jbh_password: bool,
26444 #[serde(
26448 default,
26449 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26450 )]
26451 pub host_video: bool,
26452 #[serde(
26456 default,
26457 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26458 )]
26459 pub join_before_host: bool,
26460 #[serde(
26464 default,
26465 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26466 )]
26467 pub mute_upon_entry: bool,
26468 #[serde(
26472 default,
26473 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26474 )]
26475 pub participant_video: bool,
26476 #[serde(
26480 default,
26481 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26482 )]
26483 pub pstn_password_protected: bool,
26484 #[serde(
26488 default,
26489 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26490 )]
26491 pub require_password_for_all_meetings: bool,
26492 #[serde(
26496 default,
26497 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26498 )]
26499 pub require_password_for_instant_meetings: bool,
26500 #[serde(default, skip_serializing_if = "Option::is_none")]
26505 pub require_password_for_pmi_meetings: Option<RequirePasswordPmiMeetings>,
26506 #[serde(
26510 default,
26511 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26512 )]
26513 pub require_password_for_scheduled_meetings: bool,
26514 #[serde(
26518 default,
26519 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26520 )]
26521 pub require_password_for_scheduling_new_meetings: bool,
26522 #[serde(
26526 default,
26527 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26528 )]
26529 pub upcoming_meeting_reminder: bool,
26530}
26531
26532#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
26533pub struct UpdateGroupSettingsRequestInMeeting {
26534 #[serde(
26538 default,
26539 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26540 )]
26541 pub alert_guest_join: bool,
26542 #[serde(
26546 default,
26547 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26548 )]
26549 pub allow_show_zoom_windows: bool,
26550 #[serde(
26554 default,
26555 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26556 )]
26557 pub annotation: bool,
26558 #[serde(
26562 default,
26563 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26564 )]
26565 pub attendee_on_hold: bool,
26566 #[serde(
26570 default,
26571 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26572 )]
26573 pub auto_answer: bool,
26574 #[serde(
26578 default,
26579 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26580 )]
26581 pub auto_saving_chat: bool,
26582 #[serde(
26586 default,
26587 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26588 )]
26589 pub breakout_room: bool,
26590 #[serde(
26594 default,
26595 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26596 )]
26597 pub chat: bool,
26598 #[serde(
26602 default,
26603 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26604 )]
26605 pub closed_caption: bool,
26606 #[serde(
26610 default,
26611 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26612 )]
26613 pub co_host: bool,
26614 #[serde(
26618 default,
26619 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26620 )]
26621 pub custom_data_center_regions: bool,
26622 #[serde(
26629 default,
26630 skip_serializing_if = "Vec::is_empty",
26631 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
26632 )]
26633 pub data_center_regions: Vec<String>,
26634 #[serde(
26638 default,
26639 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
26640 rename = "e2e_encryption"
26641 )]
26642 pub e_2e_encryption: bool,
26643 #[serde(
26647 default,
26648 skip_serializing_if = "String::is_empty",
26649 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
26650 )]
26651 pub entry_exit_chime: String,
26652 #[serde(
26656 default,
26657 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26658 )]
26659 pub far_end_camera_control: bool,
26660 #[serde(
26664 default,
26665 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26666 )]
26667 pub feedback: bool,
26668 #[serde(
26672 default,
26673 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26674 )]
26675 pub file_transfer: bool,
26676 #[serde(
26680 default,
26681 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26682 )]
26683 pub group_hd: bool,
26684 #[serde(
26688 default,
26689 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26690 )]
26691 pub join_from_desktop: bool,
26692 #[serde(
26696 default,
26697 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26698 )]
26699 pub join_from_mobile: bool,
26700 #[serde(
26704 default,
26705 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26706 )]
26707 pub non_verbal_feedback: bool,
26708 #[serde(
26712 default,
26713 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26714 )]
26715 pub only_host_view_device_list: bool,
26716 #[serde(
26720 default,
26721 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26722 )]
26723 pub original_audio: bool,
26724 #[serde(
26728 default,
26729 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26730 )]
26731 pub polling: bool,
26732 #[serde(
26736 default,
26737 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26738 )]
26739 pub post_meeting_feedback: bool,
26740 #[serde(
26744 default,
26745 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26746 )]
26747 pub private_chat: bool,
26748 #[serde(
26752 default,
26753 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26754 )]
26755 pub record_play_own_voice: bool,
26756 #[serde(
26760 default,
26761 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26762 )]
26763 pub remote_control: bool,
26764 #[serde(
26768 default,
26769 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26770 )]
26771 pub remote_support: bool,
26772 #[serde(
26776 default,
26777 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26778 )]
26779 pub request_permission_to_unmute: bool,
26780 #[serde(
26784 default,
26785 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26786 )]
26787 pub screen_sharing: bool,
26788 #[serde(
26792 default,
26793 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26794 )]
26795 pub sending_default_email_invites: bool,
26796 #[serde(
26800 default,
26801 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26802 )]
26803 pub show_a_join_from_your_browser_link: bool,
26804 #[serde(
26808 default,
26809 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26810 )]
26811 pub show_browser_join_link: bool,
26812 #[serde(
26816 default,
26817 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26818 )]
26819 pub show_device_list: bool,
26820 #[serde(
26824 default,
26825 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26826 )]
26827 pub show_meeting_control_toolbar: bool,
26828 #[serde(
26832 default,
26833 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26834 )]
26835 pub stereo_audio: bool,
26836 #[serde(
26840 default,
26841 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26842 )]
26843 pub use_html_format_email: bool,
26844 #[serde(
26848 default,
26849 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26850 )]
26851 pub virtual_background: bool,
26852 #[serde(
26856 default,
26857 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26858 )]
26859 pub waiting_room: bool,
26860 #[serde(
26864 default,
26865 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26866 )]
26867 pub whiteboard: bool,
26868 #[serde(default, skip_serializing_if = "Option::is_none")]
26875 pub who_can_share_screen: Option<WhoCanShareScreen>,
26876 #[serde(default, skip_serializing_if = "Option::is_none")]
26883 pub who_can_share_screen_when_someone_is_sharing: Option<WhoCanShareScreen>,
26884}
26885
26886#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
26887pub struct UpdateGroupSettingsRequestTelephony {
26888 #[serde(
26892 default,
26893 skip_serializing_if = "String::is_empty",
26894 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
26895 )]
26896 pub audio_conference_info: String,
26897 #[serde(
26901 default,
26902 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
26903 )]
26904 pub third_party_audio: bool,
26905}
26906
26907#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
26908pub struct UpdateGroupSettingsRequest {
26909 #[serde(default, skip_serializing_if = "Option::is_none")]
26910 pub email_notification: Option<GetGroupSettingsResponseEmailNotification>,
26911 #[serde(default, skip_serializing_if = "Option::is_none")]
26912 pub in_meeting: Option<UpdateGroupSettingsRequestInMeeting>,
26913 #[serde(default, skip_serializing_if = "Option::is_none")]
26914 pub profile: Option<Profile>,
26915 #[serde(default, skip_serializing_if = "Option::is_none")]
26916 pub recording: Option<GetGroupSettingsResponseRecording>,
26917 #[serde(default, skip_serializing_if = "Option::is_none")]
26918 pub schedule_meeting: Option<UpdateGroupSettingsRequestScheduleMeeting>,
26919 #[serde(default, skip_serializing_if = "Option::is_none")]
26920 pub telephony: Option<UpdateGroupSettingsRequestTelephony>,
26921}
26922
26923#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
26932#[serde(untagged)]
26933pub enum UpdateGroupSettingsRequestOneOf {
26934 Domains(Domains),
26935 MeetingSecuritySettings(MeetingSecuritySettings),
26936 UpdateGroupSettingsRequest(UpdateGroupSettingsRequest),
26937}
26938
26939impl UpdateGroupSettingsRequestOneOf {
26940 pub fn domains(&self) -> Option<&Domains> {
26941 if let UpdateGroupSettingsRequestOneOf::Domains(ref_) = self {
26942 return Some(ref_);
26943 }
26944 None
26945 }
26946
26947 pub fn meeting_security_settings(&self) -> Option<&MeetingSecuritySettings> {
26948 if let UpdateGroupSettingsRequestOneOf::MeetingSecuritySettings(ref_) = self {
26949 return Some(ref_);
26950 }
26951 None
26952 }
26953
26954 pub fn update_group_settings_request(&self) -> Option<&UpdateGroupSettingsRequest> {
26955 if let UpdateGroupSettingsRequestOneOf::UpdateGroupSettingsRequest(ref_) = self {
26956 return Some(ref_);
26957 }
26958 None
26959 }
26960}
26961
26962#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
26963pub enum UpdateGroupSettingsOption {
26964 #[serde(rename = "meeting_authentication")]
26965 MeetingAuthentication,
26966 #[serde(rename = "meeting_security")]
26967 MeetingSecurity,
26968 #[serde(rename = "recording_authentication")]
26969 RecordingAuthentication,
26970 #[serde(rename = "")]
26971 #[default]
26972 Noop,
26973 #[serde(other)]
26974 FallthroughString,
26975}
26976
26977impl std::fmt::Display for UpdateGroupSettingsOption {
26978 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
26979 match self {
26980 UpdateGroupSettingsOption::MeetingAuthentication => "meeting_authentication",
26981 UpdateGroupSettingsOption::MeetingSecurity => "meeting_security",
26982 UpdateGroupSettingsOption::RecordingAuthentication => "recording_authentication",
26983 UpdateGroupSettingsOption::Noop => "",
26984 UpdateGroupSettingsOption::FallthroughString => "*",
26985 }
26986 .fmt(f)
26987 }
26988}
26989
26990impl UpdateGroupSettingsOption {
26991 pub fn is_noop(&self) -> bool {
26992 matches!(self, UpdateGroupSettingsOption::Noop)
26993 }
26994}
26995
26996#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
26997pub struct GetGroupLockSettingsResponseScheduleMeeting {
26998 #[serde(
27002 default,
27003 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27004 )]
27005 pub audio_type: bool,
27006 #[serde(
27010 default,
27011 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27012 )]
27013 pub embed_password_in_join_link: bool,
27014 #[serde(
27018 default,
27019 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27020 )]
27021 pub force_pmi_jbh_password: bool,
27022 #[serde(
27026 default,
27027 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27028 )]
27029 pub host_video: bool,
27030 #[serde(
27034 default,
27035 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27036 )]
27037 pub join_before_host: bool,
27038 #[serde(
27042 default,
27043 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27044 )]
27045 pub meeting_authentication: bool,
27046 #[serde(
27050 default,
27051 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27052 )]
27053 pub mute_upon_entry: bool,
27054 #[serde(
27058 default,
27059 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27060 )]
27061 pub participant_video: bool,
27062 #[serde(
27066 default,
27067 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27068 )]
27069 pub pstn_password_protected: bool,
27070 #[serde(
27074 default,
27075 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27076 )]
27077 pub require_password_for_instant_meetings: bool,
27078 #[serde(
27082 default,
27083 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27084 )]
27085 pub require_password_for_pmi_meetings: bool,
27086 #[serde(
27090 default,
27091 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27092 )]
27093 pub require_password_for_scheduling_new_meetings: bool,
27094 #[serde(
27098 default,
27099 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27100 )]
27101 pub upcoming_meeting_reminder: bool,
27102}
27103
27104#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
27105pub struct GetGroupLockSettingsResponseInMeeting {
27106 #[serde(
27110 default,
27111 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27112 )]
27113 pub alert_guest_join: bool,
27114 #[serde(
27118 default,
27119 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27120 )]
27121 pub allow_show_zoom_windows: bool,
27122 #[serde(
27126 default,
27127 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27128 )]
27129 pub annotation: bool,
27130 #[serde(
27134 default,
27135 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27136 )]
27137 pub attendee_on_hold: bool,
27138 #[serde(
27142 default,
27143 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27144 )]
27145 pub auto_answer: bool,
27146 #[serde(
27150 default,
27151 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27152 )]
27153 pub auto_saving_chat: bool,
27154 #[serde(
27158 default,
27159 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27160 )]
27161 pub breakout_room: bool,
27162 #[serde(
27166 default,
27167 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27168 )]
27169 pub chat: bool,
27170 #[serde(
27174 default,
27175 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27176 )]
27177 pub closed_caption: bool,
27178 #[serde(
27182 default,
27183 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27184 )]
27185 pub co_host: bool,
27186 #[serde(
27190 default,
27191 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27192 )]
27193 pub custom_data_center_regions: bool,
27194 #[serde(
27198 default,
27199 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize",
27200 rename = "e2e_encryption"
27201 )]
27202 pub e_2e_encryption: bool,
27203 #[serde(
27207 default,
27208 skip_serializing_if = "String::is_empty",
27209 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
27210 )]
27211 pub entry_exit_chime: String,
27212 #[serde(
27216 default,
27217 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27218 )]
27219 pub far_end_camera_control: bool,
27220 #[serde(
27224 default,
27225 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27226 )]
27227 pub feedback: bool,
27228 #[serde(
27232 default,
27233 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27234 )]
27235 pub file_transfer: bool,
27236 #[serde(
27240 default,
27241 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27242 )]
27243 pub group_hd: bool,
27244 #[serde(
27248 default,
27249 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27250 )]
27251 pub non_verbal_feedback: bool,
27252 #[serde(
27256 default,
27257 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27258 )]
27259 pub original_audio: bool,
27260 #[serde(
27264 default,
27265 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27266 )]
27267 pub polling: bool,
27268 #[serde(
27272 default,
27273 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27274 )]
27275 pub post_meeting_feedback: bool,
27276 #[serde(
27280 default,
27281 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27282 )]
27283 pub private_chat: bool,
27284 #[serde(
27288 default,
27289 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27290 )]
27291 pub remote_control: bool,
27292 #[serde(
27296 default,
27297 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27298 )]
27299 pub remote_support: bool,
27300 #[serde(
27304 default,
27305 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27306 )]
27307 pub request_permission_to_unmute: bool,
27308 #[serde(
27312 default,
27313 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27314 )]
27315 pub screen_sharing: bool,
27316 #[serde(
27320 default,
27321 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27322 )]
27323 pub sending_default_email_invites: bool,
27324 #[serde(
27328 default,
27329 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27330 )]
27331 pub show_a_join_from_your_browser_link: bool,
27332 #[serde(
27336 default,
27337 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27338 )]
27339 pub show_browser_join_link: bool,
27340 #[serde(
27344 default,
27345 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27346 )]
27347 pub show_meeting_control_toolbar: bool,
27348 #[serde(
27352 default,
27353 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27354 )]
27355 pub stereo_audio: bool,
27356 #[serde(
27360 default,
27361 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27362 )]
27363 pub use_html_format_email: bool,
27364 #[serde(
27368 default,
27369 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27370 )]
27371 pub virtual_background: bool,
27372 #[serde(
27376 default,
27377 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27378 )]
27379 pub waiting_room: bool,
27380 #[serde(
27384 default,
27385 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27386 )]
27387 pub whiteboard: bool,
27388}
27389
27390#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
27391pub struct GetGroupLockSettingsResponseRecording {
27392 #[serde(
27396 default,
27397 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27398 )]
27399 pub account_user_access_recording: bool,
27400 #[serde(
27404 default,
27405 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27406 )]
27407 pub auto_delete_cmr: bool,
27408 #[serde(
27412 default,
27413 skip_serializing_if = "String::is_empty",
27414 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
27415 )]
27416 pub auto_recording: String,
27417 #[serde(
27421 default,
27422 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27423 )]
27424 pub cloud_recording: bool,
27425 #[serde(
27429 default,
27430 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27431 )]
27432 pub cloud_recording_download: bool,
27433 #[serde(
27437 default,
27438 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27439 )]
27440 pub host_delete_cloud_recording: bool,
27441 #[serde(default, skip_serializing_if = "Option::is_none")]
27446 pub ip_address_access_control: Option<IpAddressAccessControl>,
27447 #[serde(
27451 default,
27452 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27453 )]
27454 pub local_recording: bool,
27455 #[serde(
27459 default,
27460 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27461 )]
27462 pub prevent_host_access_recording: bool,
27463 #[serde(
27467 default,
27468 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27469 )]
27470 pub recording_authentication: bool,
27471}
27472
27473#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
27474pub struct GetGroupLockSettingsResponseTelephony {
27475 #[serde(
27479 default,
27480 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27481 )]
27482 pub telephony_regions: bool,
27483 #[serde(
27487 default,
27488 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27489 )]
27490 pub third_party_audio: bool,
27491}
27492
27493#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
27494pub struct GetGroupLockSettingsResponse {
27495 #[serde(default, skip_serializing_if = "Option::is_none")]
27496 pub email_notification: Option<GetGroupSettingsResponseEmailNotification>,
27497 #[serde(default, skip_serializing_if = "Option::is_none")]
27498 pub in_meeting: Option<GetGroupLockSettingsResponseInMeeting>,
27499 #[serde(default, skip_serializing_if = "Option::is_none")]
27500 pub recording: Option<GetGroupLockSettingsResponseRecording>,
27501 #[serde(default, skip_serializing_if = "Option::is_none")]
27502 pub schedule_meeting: Option<GetGroupLockSettingsResponseScheduleMeeting>,
27503 #[serde(default, skip_serializing_if = "Option::is_none")]
27504 pub telephony: Option<GetGroupLockSettingsResponseTelephony>,
27505}
27506
27507#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
27515#[serde(untagged)]
27516pub enum GetGroupLockSettingsResponseOneOf {
27517 MeetingSecuritySettings(MeetingSecuritySettings),
27518 GetGroupLockSettingsResponse(GetGroupLockSettingsResponse),
27519}
27520
27521impl GetGroupLockSettingsResponseOneOf {
27522 pub fn get_group_lock_settings_response(&self) -> Option<&GetGroupLockSettingsResponse> {
27523 if let GetGroupLockSettingsResponseOneOf::GetGroupLockSettingsResponse(ref_) = self {
27524 return Some(ref_);
27525 }
27526 None
27527 }
27528
27529 pub fn meeting_security_settings(&self) -> Option<&MeetingSecuritySettings> {
27530 if let GetGroupLockSettingsResponseOneOf::MeetingSecuritySettings(ref_) = self {
27531 return Some(ref_);
27532 }
27533 None
27534 }
27535}
27536
27537#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
27538pub struct GroupLockedSettingsRequestScheduleMeeting {
27539 #[serde(
27543 default,
27544 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27545 )]
27546 pub audio_type: bool,
27547 #[serde(
27551 default,
27552 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27553 )]
27554 pub embed_password_in_join_link: bool,
27555 #[serde(
27559 default,
27560 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27561 )]
27562 pub force_pmi_jbh_password: bool,
27563 #[serde(
27567 default,
27568 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27569 )]
27570 pub host_video: bool,
27571 #[serde(
27575 default,
27576 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27577 )]
27578 pub join_before_host: bool,
27579 #[serde(
27583 default,
27584 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27585 )]
27586 pub meeting_authentication: bool,
27587 #[serde(
27591 default,
27592 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27593 )]
27594 pub mute_upon_entry: bool,
27595 #[serde(
27599 default,
27600 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27601 )]
27602 pub participant_video: bool,
27603 #[serde(
27607 default,
27608 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27609 )]
27610 pub personal_meeting: bool,
27611 #[serde(
27615 default,
27616 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27617 )]
27618 pub pstn_password_protected: bool,
27619 #[serde(
27623 default,
27624 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27625 )]
27626 pub require_password_for_instant_meetings: bool,
27627 #[serde(
27631 default,
27632 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27633 )]
27634 pub require_password_for_pmi_meetings: bool,
27635 #[serde(
27639 default,
27640 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27641 )]
27642 pub require_password_for_scheduling_new_meetings: bool,
27643 #[serde(
27647 default,
27648 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27649 )]
27650 pub upcoming_meeting_reminder: bool,
27651}
27652
27653#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
27654pub struct GroupLockedSettingsRequestRecording {
27655 #[serde(
27659 default,
27660 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27661 )]
27662 pub account_user_access_recording: bool,
27663 #[serde(
27667 default,
27668 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27669 )]
27670 pub auto_delete_cmr: bool,
27671 #[serde(
27675 default,
27676 skip_serializing_if = "String::is_empty",
27677 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
27678 )]
27679 pub auto_recording: String,
27680 #[serde(
27684 default,
27685 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27686 )]
27687 pub cloud_recording: bool,
27688 #[serde(
27692 default,
27693 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27694 )]
27695 pub cloud_recording_download: bool,
27696 #[serde(
27700 default,
27701 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27702 )]
27703 pub host_delete_cloud_recording: bool,
27704 #[serde(default, skip_serializing_if = "Option::is_none")]
27709 pub ip_address_access_control: Option<IpAddressAccessControl>,
27710 #[serde(
27714 default,
27715 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
27716 )]
27717 pub local_recording: bool,
27718 #[serde(
27722 default,
27723 skip_serializing_if = "String::is_empty",
27724 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
27725 )]
27726 pub recording_authentication: String,
27727}
27728
27729#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
27730pub struct GroupLockedSettingsRequest {
27731 #[serde(default, skip_serializing_if = "Option::is_none")]
27732 pub email_notification: Option<GetGroupSettingsResponseEmailNotification>,
27733 #[serde(default, skip_serializing_if = "Option::is_none")]
27734 pub in_meeting: Option<GetGroupLockSettingsResponseInMeeting>,
27735 #[serde(default, skip_serializing_if = "Option::is_none")]
27736 pub recording: Option<GroupLockedSettingsRequestRecording>,
27737 #[serde(default, skip_serializing_if = "Option::is_none")]
27738 pub schedule_meeting: Option<GroupLockedSettingsRequestScheduleMeeting>,
27739 #[serde(default, skip_serializing_if = "Option::is_none")]
27740 pub telephony: Option<GetGroupLockSettingsResponseTelephony>,
27741}
27742
27743#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
27751#[serde(untagged)]
27752pub enum GroupLockedSettingsRequestOneOf {
27753 MeetingSecuritySettings(MeetingSecuritySettings),
27754 GroupLockedSettingsRequest(GroupLockedSettingsRequest),
27755}
27756
27757impl GroupLockedSettingsRequestOneOf {
27758 pub fn group_locked_settings_request(&self) -> Option<&GroupLockedSettingsRequest> {
27759 if let GroupLockedSettingsRequestOneOf::GroupLockedSettingsRequest(ref_) = self {
27760 return Some(ref_);
27761 }
27762 None
27763 }
27764
27765 pub fn meeting_security_settings(&self) -> Option<&MeetingSecuritySettings> {
27766 if let GroupLockedSettingsRequestOneOf::MeetingSecuritySettings(ref_) = self {
27767 return Some(ref_);
27768 }
27769 None
27770 }
27771}
27772
27773#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
27775pub struct SubAccountPrivileges {
27776 #[serde(
27780 default,
27781 skip_serializing_if = "crate::utils::zero_i64",
27782 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
27783 )]
27784 pub second_level: i64,
27785}
27786
27787#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
27788pub struct GetRoleInformationResponse {
27789 #[serde(
27793 default,
27794 skip_serializing_if = "String::is_empty",
27795 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
27796 )]
27797 pub description: String,
27798 #[serde(
27802 default,
27803 skip_serializing_if = "String::is_empty",
27804 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
27805 )]
27806 pub id: String,
27807 #[serde(
27811 default,
27812 skip_serializing_if = "String::is_empty",
27813 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
27814 )]
27815 pub name: String,
27816 #[serde(
27823 default,
27824 skip_serializing_if = "Vec::is_empty",
27825 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
27826 )]
27827 pub privileges: Vec<String>,
27828 #[serde(default, skip_serializing_if = "Option::is_none")]
27832 pub sub_account_privileges: Option<SubAccountPrivileges>,
27833 #[serde(
27837 default,
27838 skip_serializing_if = "crate::utils::zero_i64",
27839 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
27840 )]
27841 pub total_members: i64,
27842}
27843
27844#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
27846pub struct UpdateRoleRequestSubAccountPrivileges {
27847 #[serde(
27851 default,
27852 skip_serializing_if = "crate::utils::zero_i64",
27853 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
27854 )]
27855 pub second_level: i64,
27856}
27857
27858#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
27859pub struct UpdateRoleRequest {
27860 #[serde(
27864 default,
27865 skip_serializing_if = "String::is_empty",
27866 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
27867 )]
27868 pub description: String,
27869 #[serde(
27873 default,
27874 skip_serializing_if = "String::is_empty",
27875 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
27876 )]
27877 pub id: String,
27878 #[serde(
27882 default,
27883 skip_serializing_if = "String::is_empty",
27884 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
27885 )]
27886 pub name: String,
27887 #[serde(
27894 default,
27895 skip_serializing_if = "Vec::is_empty",
27896 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
27897 )]
27898 pub privileges: Vec<String>,
27899 #[serde(default, skip_serializing_if = "Option::is_none")]
27903 pub sub_account_privileges: Option<UpdateRoleRequestSubAccountPrivileges>,
27904 #[serde(
27908 default,
27909 skip_serializing_if = "crate::utils::zero_i64",
27910 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
27911 )]
27912 pub total_members: i64,
27913}
27914
27915#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
27916pub struct GetPlanUsageResponseBase {
27917 #[serde(
27921 default,
27922 skip_serializing_if = "crate::utils::zero_i64",
27923 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
27924 )]
27925 pub hosts: i64,
27926 #[serde(
27930 default,
27931 skip_serializing_if = "String::is_empty",
27932 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
27933 rename = "type"
27934 )]
27935 pub type_: String,
27936 #[serde(
27940 default,
27941 skip_serializing_if = "crate::utils::zero_i64",
27942 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
27943 )]
27944 pub usage: i64,
27945}
27946
27947#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
27949pub struct PlanRecording {
27950 #[serde(
27954 default,
27955 skip_serializing_if = "String::is_empty",
27956 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
27957 )]
27958 pub free_storage: String,
27959 #[serde(
27963 default,
27964 skip_serializing_if = "String::is_empty",
27965 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
27966 )]
27967 pub free_storage_usage: String,
27968 #[serde(
27972 default,
27973 skip_serializing_if = "String::is_empty",
27974 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
27975 )]
27976 pub plan_storage: String,
27977 #[serde(
27981 default,
27982 skip_serializing_if = "String::is_empty",
27983 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
27984 )]
27985 pub plan_storage_exceed: String,
27986 #[serde(
27990 default,
27991 skip_serializing_if = "String::is_empty",
27992 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
27993 )]
27994 pub plan_storage_usage: String,
27995 #[serde(
27999 default,
28000 skip_serializing_if = "String::is_empty",
28001 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
28002 rename = "type"
28003 )]
28004 pub type_: String,
28005}
28006
28007#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
28009pub struct PlanUnited {
28010 #[serde(
28014 default,
28015 skip_serializing_if = "crate::utils::zero_i64",
28016 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
28017 )]
28018 pub hosts: i64,
28019 #[serde(
28023 default,
28024 skip_serializing_if = "String::is_empty",
28025 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28026 )]
28027 pub name: String,
28028 #[serde(
28032 default,
28033 skip_serializing_if = "String::is_empty",
28034 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
28035 rename = "type"
28036 )]
28037 pub type_: String,
28038 #[serde(
28042 default,
28043 skip_serializing_if = "crate::utils::zero_i64",
28044 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
28045 )]
28046 pub usage: i64,
28047}
28048
28049#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
28050pub struct GetPlanUsageResponse {
28051 #[serde(
28055 default,
28056 skip_serializing_if = "Vec::is_empty",
28057 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
28058 )]
28059 pub plan_base: Vec<GetPlanUsageResponseBase>,
28060 #[serde(
28064 default,
28065 skip_serializing_if = "Vec::is_empty",
28066 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
28067 )]
28068 pub plan_large_meeting: Vec<GetPlanUsageResponseBase>,
28069 #[serde(default, skip_serializing_if = "Option::is_none")]
28073 pub plan_recording: Option<PlanRecording>,
28074 #[serde(default, skip_serializing_if = "Option::is_none")]
28078 pub plan_united: Option<PlanUnited>,
28079 #[serde(
28083 default,
28084 skip_serializing_if = "Vec::is_empty",
28085 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
28086 )]
28087 pub plan_webinar: Vec<GetPlanUsageResponseBase>,
28088 #[serde(
28092 default,
28093 skip_serializing_if = "Vec::is_empty",
28094 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
28095 )]
28096 pub plan_zoom_rooms: Vec<GetPlanUsageResponseBase>,
28097}
28098
28099#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
28100pub struct SwitchUserAccountRequest {
28101 #[serde(
28105 default,
28106 skip_serializing_if = "String::is_empty",
28107 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28108 )]
28109 pub account_id: String,
28110}
28111
28112#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
28126pub enum GetAccountCloudRecordingResponseMeetingsFilesFileType {
28127 #[serde(rename = "CC")]
28128 Cc,
28129 #[serde(rename = "CHAT")]
28130 Chat,
28131 #[serde(rename = "CSV")]
28132 Csv,
28133 #[serde(rename = "M4A")]
28134 M4A,
28135 #[serde(rename = "MP4")]
28136 Mp4,
28137 #[serde(rename = "TB")]
28138 Tb,
28139 #[serde(rename = "TRANSCRIPT")]
28140 Transcript,
28141 #[serde(rename = "")]
28142 #[default]
28143 Noop,
28144 #[serde(other)]
28145 FallthroughString,
28146}
28147
28148impl std::fmt::Display for GetAccountCloudRecordingResponseMeetingsFilesFileType {
28149 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
28150 match self {
28151 GetAccountCloudRecordingResponseMeetingsFilesFileType::Cc => "CC",
28152 GetAccountCloudRecordingResponseMeetingsFilesFileType::Chat => "CHAT",
28153 GetAccountCloudRecordingResponseMeetingsFilesFileType::Csv => "CSV",
28154 GetAccountCloudRecordingResponseMeetingsFilesFileType::M4A => "M4A",
28155 GetAccountCloudRecordingResponseMeetingsFilesFileType::Mp4 => "MP4",
28156 GetAccountCloudRecordingResponseMeetingsFilesFileType::Tb => "TB",
28157 GetAccountCloudRecordingResponseMeetingsFilesFileType::Transcript => "TRANSCRIPT",
28158 GetAccountCloudRecordingResponseMeetingsFilesFileType::Noop => "",
28159 GetAccountCloudRecordingResponseMeetingsFilesFileType::FallthroughString => "*",
28160 }
28161 .fmt(f)
28162 }
28163}
28164
28165impl GetAccountCloudRecordingResponseMeetingsFilesFileType {
28166 pub fn is_noop(&self) -> bool {
28167 matches!(
28168 self,
28169 GetAccountCloudRecordingResponseMeetingsFilesFileType::Noop
28170 )
28171 }
28172}
28173
28174#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
28178pub enum GetAccountCloudRecordingResponseMeetingsFilesStatus {
28179 #[serde(rename = "completed")]
28180 Completed,
28181 #[serde(rename = "processing")]
28182 Processing,
28183 #[serde(rename = "")]
28184 #[default]
28185 Noop,
28186 #[serde(other)]
28187 FallthroughString,
28188}
28189
28190impl std::fmt::Display for GetAccountCloudRecordingResponseMeetingsFilesStatus {
28191 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
28192 match self {
28193 GetAccountCloudRecordingResponseMeetingsFilesStatus::Completed => "completed",
28194 GetAccountCloudRecordingResponseMeetingsFilesStatus::Processing => "processing",
28195 GetAccountCloudRecordingResponseMeetingsFilesStatus::Noop => "",
28196 GetAccountCloudRecordingResponseMeetingsFilesStatus::FallthroughString => "*",
28197 }
28198 .fmt(f)
28199 }
28200}
28201
28202impl GetAccountCloudRecordingResponseMeetingsFilesStatus {
28203 pub fn is_noop(&self) -> bool {
28204 matches!(
28205 self,
28206 GetAccountCloudRecordingResponseMeetingsFilesStatus::Noop
28207 )
28208 }
28209}
28210
28211#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
28230pub enum GetAccountCloudRecordingResponseMeetingsFilesType {
28231 #[serde(rename = "active_speaker")]
28232 ActiveSpeaker,
28233 #[serde(rename = "audio_only")]
28234 AudioOnly,
28235 #[serde(rename = "audio_transcript")]
28236 AudioTranscript,
28237 #[serde(rename = "chat_file")]
28238 ChatFile,
28239 #[serde(rename = "closed_caption")]
28240 ClosedCaption,
28241 #[serde(rename = "gallery_view")]
28242 GalleryView,
28243 #[serde(rename = "host_video")]
28244 HostVideo,
28245 #[serde(rename = "poll")]
28246 Poll,
28247 #[serde(rename = "shared_screen")]
28248 SharedScreen,
28249 #[serde(rename = "shared_screen_with_gallery_view")]
28250 SharedScreenWithGalleryView,
28251 #[serde(rename = "shared_screen_with_speaker_view")]
28252 SharedScreenWithSpeakerView,
28253 #[serde(rename = "shared_screen_with_speaker_view(CC)")]
28254 SharedScreenWithSpeakerViewCc,
28255 #[serde(rename = "thumbnail")]
28256 Thumbnail,
28257 #[serde(rename = "timeline")]
28258 Timeline,
28259 #[serde(rename = "")]
28260 #[default]
28261 Noop,
28262 #[serde(other)]
28263 FallthroughString,
28264}
28265
28266impl std::fmt::Display for GetAccountCloudRecordingResponseMeetingsFilesType {
28267 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
28268 match self {
28269 GetAccountCloudRecordingResponseMeetingsFilesType::ActiveSpeaker => "active_speaker",
28270 GetAccountCloudRecordingResponseMeetingsFilesType::AudioOnly => "audio_only",
28271 GetAccountCloudRecordingResponseMeetingsFilesType::AudioTranscript => {
28272 "audio_transcript"
28273 }
28274 GetAccountCloudRecordingResponseMeetingsFilesType::ChatFile => "chat_file",
28275 GetAccountCloudRecordingResponseMeetingsFilesType::ClosedCaption => "closed_caption",
28276 GetAccountCloudRecordingResponseMeetingsFilesType::GalleryView => "gallery_view",
28277 GetAccountCloudRecordingResponseMeetingsFilesType::HostVideo => "host_video",
28278 GetAccountCloudRecordingResponseMeetingsFilesType::Poll => "poll",
28279 GetAccountCloudRecordingResponseMeetingsFilesType::SharedScreen => "shared_screen",
28280 GetAccountCloudRecordingResponseMeetingsFilesType::SharedScreenWithGalleryView => {
28281 "shared_screen_with_gallery_view"
28282 }
28283 GetAccountCloudRecordingResponseMeetingsFilesType::SharedScreenWithSpeakerView => {
28284 "shared_screen_with_speaker_view"
28285 }
28286 GetAccountCloudRecordingResponseMeetingsFilesType::SharedScreenWithSpeakerViewCc => {
28287 "shared_screen_with_speaker_view(CC)"
28288 }
28289 GetAccountCloudRecordingResponseMeetingsFilesType::Thumbnail => "thumbnail",
28290 GetAccountCloudRecordingResponseMeetingsFilesType::Timeline => "timeline",
28291 GetAccountCloudRecordingResponseMeetingsFilesType::Noop => "",
28292 GetAccountCloudRecordingResponseMeetingsFilesType::FallthroughString => "*",
28293 }
28294 .fmt(f)
28295 }
28296}
28297
28298impl GetAccountCloudRecordingResponseMeetingsFilesType {
28299 pub fn is_noop(&self) -> bool {
28300 matches!(
28301 self,
28302 GetAccountCloudRecordingResponseMeetingsFilesType::Noop
28303 )
28304 }
28305}
28306
28307#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
28308pub struct RecordingFiles {
28309 #[serde(
28313 default,
28314 skip_serializing_if = "String::is_empty",
28315 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28316 )]
28317 pub download_url: String,
28318 #[serde(
28322 default,
28323 skip_serializing_if = "crate::utils::zero_f64",
28324 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
28325 )]
28326 pub file_size: f64,
28327 #[serde(default, skip_serializing_if = "Option::is_none")]
28341 pub file_type: Option<GetAccountCloudRecordingResponseMeetingsFilesFileType>,
28342 #[serde(
28346 default,
28347 skip_serializing_if = "String::is_empty",
28348 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28349 )]
28350 pub id: String,
28351 #[serde(
28355 default,
28356 skip_serializing_if = "String::is_empty",
28357 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28358 )]
28359 pub meeting_id: String,
28360 #[serde(
28364 default,
28365 skip_serializing_if = "String::is_empty",
28366 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28367 )]
28368 pub play_url: String,
28369 #[serde(
28373 default,
28374 skip_serializing_if = "String::is_empty",
28375 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28376 )]
28377 pub recording_end: String,
28378 #[serde(
28382 default,
28383 skip_serializing_if = "String::is_empty",
28384 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28385 )]
28386 pub recording_start: String,
28387 #[serde(default, skip_serializing_if = "Option::is_none")]
28406 pub recording_type: Option<GetAccountCloudRecordingResponseMeetingsFilesType>,
28407 #[serde(default, skip_serializing_if = "Option::is_none")]
28411 pub status: Option<GetAccountCloudRecordingResponseMeetingsFilesStatus>,
28412}
28413
28414#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
28415pub struct GetAccountCloudRecordingResponseMeetings {
28416 #[serde(
28420 default,
28421 skip_serializing_if = "crate::utils::zero_i64",
28422 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
28423 )]
28424 pub duration: i64,
28425 #[serde(
28429 default,
28430 skip_serializing_if = "String::is_empty",
28431 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28432 )]
28433 pub host_id: String,
28434 #[serde(
28438 default,
28439 skip_serializing_if = "String::is_empty",
28440 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28441 )]
28442 pub id: String,
28443 #[serde(
28447 default,
28448 skip_serializing_if = "crate::utils::zero_i64",
28449 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
28450 )]
28451 pub recording_count: i64,
28452 #[serde(
28456 default,
28457 skip_serializing_if = "Vec::is_empty",
28458 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
28459 )]
28460 pub recording_files: Vec<RecordingFiles>,
28461 #[serde(
28465 default,
28466 skip_serializing_if = "Option::is_none",
28467 deserialize_with = "crate::utils::date_time_format::deserialize"
28468 )]
28469 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
28470 #[serde(
28474 default,
28475 skip_serializing_if = "String::is_empty",
28476 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28477 )]
28478 pub topic: String,
28479 #[serde(
28483 default,
28484 skip_serializing_if = "crate::utils::zero_i64",
28485 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
28486 )]
28487 pub total_size: i64,
28488 #[serde(
28492 default,
28493 skip_serializing_if = "String::is_empty",
28494 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28495 )]
28496 pub uuid: String,
28497}
28498
28499#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
28500pub struct GetAccountCloudRecordingResponse {
28501 #[serde(
28505 default,
28506 skip_serializing_if = "Option::is_none",
28507 deserialize_with = "crate::utils::date_time_format::deserialize"
28508 )]
28509 pub from: Option<chrono::DateTime<chrono::Utc>>,
28510 #[serde(
28514 default,
28515 skip_serializing_if = "Vec::is_empty",
28516 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
28517 )]
28518 pub meetings: Vec<GetAccountCloudRecordingResponseMeetings>,
28519 #[serde(
28523 default,
28524 skip_serializing_if = "String::is_empty",
28525 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28526 )]
28527 pub next_page_token: String,
28528 #[serde(
28532 default,
28533 skip_serializing_if = "crate::utils::zero_i64",
28534 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
28535 )]
28536 pub page_size: i64,
28537 #[serde(
28541 default,
28542 skip_serializing_if = "Option::is_none",
28543 deserialize_with = "crate::utils::date_time_format::deserialize"
28544 )]
28545 pub to: Option<chrono::DateTime<chrono::Utc>>,
28546 #[serde(
28550 default,
28551 skip_serializing_if = "crate::utils::zero_i64",
28552 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
28553 )]
28554 pub total_records: i64,
28555}
28556
28557#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
28558pub struct TrackingSources {
28559 #[serde(
28563 default,
28564 skip_serializing_if = "String::is_empty",
28565 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28566 )]
28567 pub id: String,
28568 #[serde(
28572 default,
28573 skip_serializing_if = "crate::utils::zero_i64",
28574 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
28575 )]
28576 pub registration_count: i64,
28577 #[serde(
28581 default,
28582 skip_serializing_if = "String::is_empty",
28583 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28584 )]
28585 pub source_name: String,
28586 #[serde(
28590 default,
28591 skip_serializing_if = "String::is_empty",
28592 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28593 )]
28594 pub tracking_url: String,
28595 #[serde(
28599 default,
28600 skip_serializing_if = "crate::utils::zero_i64",
28601 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
28602 )]
28603 pub visitor_count: i64,
28604}
28605
28606#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
28607pub struct GetTrackingSourcesResponse {
28608 #[serde(
28612 default,
28613 skip_serializing_if = "crate::utils::zero_i64",
28614 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
28615 )]
28616 pub total_records: i64,
28617 #[serde(
28621 default,
28622 skip_serializing_if = "Vec::is_empty",
28623 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
28624 )]
28625 pub tracking_sources: Vec<TrackingSources>,
28626}
28627
28628#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
28629pub struct Basic {
28630 #[serde(
28634 default,
28635 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
28636 )]
28637 pub required_code_to_ext: bool,
28638 #[serde(
28642 default,
28643 skip_serializing_if = "String::is_empty",
28644 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28645 )]
28646 pub room_passcode: String,
28647 #[serde(
28651 default,
28652 skip_serializing_if = "String::is_empty",
28653 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28654 )]
28655 pub support_email: String,
28656 #[serde(
28660 default,
28661 skip_serializing_if = "String::is_empty",
28662 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28663 )]
28664 pub support_phone: String,
28665}
28666
28667#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
28668pub struct UpdateZrAccProfileRequest {
28669 #[serde(default, skip_serializing_if = "Option::is_none")]
28670 pub basic: Option<Basic>,
28671}
28672
28673#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
28679pub enum SettingType {
28680 #[serde(rename = "alert")]
28681 Alert,
28682 #[serde(rename = "meeting")]
28683 #[default]
28684 Meeting,
28685 #[serde(other)]
28686 FallthroughString,
28687}
28688
28689impl std::fmt::Display for SettingType {
28690 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
28691 match self {
28692 SettingType::Alert => "alert",
28693 SettingType::Meeting => "meeting",
28694 SettingType::FallthroughString => "*",
28695 }
28696 .fmt(f)
28697 }
28698}
28699
28700#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
28705pub enum ListZrLocationsResponseType {
28706 #[serde(rename = "building")]
28707 Building,
28708 #[serde(rename = "campus")]
28709 Campus,
28710 #[serde(rename = "city")]
28711 City,
28712 #[serde(rename = "country")]
28713 Country,
28714 #[serde(rename = "floor")]
28715 Floor,
28716 #[serde(rename = "states")]
28717 States,
28718 #[serde(rename = "")]
28719 #[default]
28720 Noop,
28721 #[serde(other)]
28722 FallthroughString,
28723}
28724
28725impl std::fmt::Display for ListZrLocationsResponseType {
28726 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
28727 match self {
28728 ListZrLocationsResponseType::Building => "building",
28729 ListZrLocationsResponseType::Campus => "campus",
28730 ListZrLocationsResponseType::City => "city",
28731 ListZrLocationsResponseType::Country => "country",
28732 ListZrLocationsResponseType::Floor => "floor",
28733 ListZrLocationsResponseType::States => "states",
28734 ListZrLocationsResponseType::Noop => "",
28735 ListZrLocationsResponseType::FallthroughString => "*",
28736 }
28737 .fmt(f)
28738 }
28739}
28740
28741impl ListZrLocationsResponseType {
28742 pub fn is_noop(&self) -> bool {
28743 matches!(self, ListZrLocationsResponseType::Noop)
28744 }
28745}
28746
28747#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
28748pub struct AddAzrLocationResponse {
28749 #[serde(
28753 default,
28754 skip_serializing_if = "String::is_empty",
28755 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28756 )]
28757 pub id: String,
28758 #[serde(
28762 default,
28763 skip_serializing_if = "String::is_empty",
28764 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28765 )]
28766 pub name: String,
28767 #[serde(
28771 default,
28772 skip_serializing_if = "String::is_empty",
28773 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28774 )]
28775 pub parent_location_id: String,
28776 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
28781 pub type_: Option<ListZrLocationsResponseType>,
28782}
28783
28784#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
28785pub struct ListZrLocationsResponseData {
28786 #[serde(
28787 default,
28788 skip_serializing_if = "Vec::is_empty",
28789 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
28790 )]
28791 pub locations: Vec<AddAzrLocationResponse>,
28792 #[serde(
28796 default,
28797 skip_serializing_if = "String::is_empty",
28798 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28799 )]
28800 pub next_page_token: String,
28801 #[serde(
28805 default,
28806 skip_serializing_if = "crate::utils::zero_i64",
28807 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
28808 )]
28809 pub page_size: i64,
28810}
28811
28812#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
28813pub struct AddAzrLocationRequest {
28814 #[serde(
28818 default,
28819 skip_serializing_if = "String::is_empty",
28820 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28821 )]
28822 pub name: String,
28823 #[serde(
28827 default,
28828 skip_serializing_if = "String::is_empty",
28829 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28830 )]
28831 pub parent_location_id: String,
28832}
28833
28834#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
28835pub struct GetZrLocationProfileResponseBasic {
28836 #[serde(
28840 default,
28841 skip_serializing_if = "String::is_empty",
28842 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28843 )]
28844 pub address: String,
28845 #[serde(
28849 default,
28850 skip_serializing_if = "String::is_empty",
28851 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
28852 rename = "description "
28853 )]
28854 pub description: String,
28855 #[serde(
28859 default,
28860 skip_serializing_if = "String::is_empty",
28861 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28862 )]
28863 pub name: String,
28864 #[serde(
28868 default,
28869 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
28870 )]
28871 pub required_code_to_ext: bool,
28872 #[serde(
28876 default,
28877 skip_serializing_if = "String::is_empty",
28878 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28879 )]
28880 pub room_passcode: String,
28881 #[serde(
28885 default,
28886 skip_serializing_if = "String::is_empty",
28887 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28888 )]
28889 pub support_email: String,
28890 #[serde(
28894 default,
28895 skip_serializing_if = "String::is_empty",
28896 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28897 )]
28898 pub support_phone: String,
28899 #[serde(
28903 default,
28904 skip_serializing_if = "String::is_empty",
28905 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28906 )]
28907 pub timezone: String,
28908}
28909
28910#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
28911pub struct GetZrLocationProfileResponse {
28912 #[serde(default, skip_serializing_if = "Option::is_none")]
28913 pub basic: Option<GetZrLocationProfileResponseBasic>,
28914}
28915
28916#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
28917pub struct GetZrLocationStructureResponse {
28918 #[serde(
28925 default,
28926 skip_serializing_if = "Vec::is_empty",
28927 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
28928 )]
28929 pub structures: Vec<String>,
28930}
28931
28932#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
28933pub struct GetZrProfileResponseBasic {
28934 #[serde(
28938 default,
28939 skip_serializing_if = "String::is_empty",
28940 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28941 )]
28942 pub activation_code: String,
28943 #[serde(
28947 default,
28948 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
28949 )]
28950 pub hide_room_in_contacts: bool,
28951 #[serde(
28955 default,
28956 skip_serializing_if = "String::is_empty",
28957 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28958 )]
28959 pub name: String,
28960 #[serde(
28964 default,
28965 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
28966 )]
28967 pub required_code_to_ext: bool,
28968 #[serde(
28972 default,
28973 skip_serializing_if = "String::is_empty",
28974 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28975 )]
28976 pub room_passcode: String,
28977 #[serde(
28981 default,
28982 skip_serializing_if = "String::is_empty",
28983 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28984 )]
28985 pub support_email: String,
28986 #[serde(
28990 default,
28991 skip_serializing_if = "String::is_empty",
28992 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
28993 )]
28994 pub support_phone: String,
28995}
28996
28997#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
28998pub struct GetZrProfileResponse {
28999 #[serde(default, skip_serializing_if = "Option::is_none")]
29000 pub basic: Option<GetZrProfileResponseBasic>,
29001}
29002
29003#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29004pub struct UpdateRoomProfileRequestBasic {
29005 #[serde(
29009 default,
29010 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
29011 )]
29012 pub hide_room_in_contacts: bool,
29013 #[serde(
29017 default,
29018 skip_serializing_if = "String::is_empty",
29019 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29020 )]
29021 pub name: String,
29022 #[serde(
29026 default,
29027 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
29028 )]
29029 pub required_code_to_ext: bool,
29030 #[serde(
29034 default,
29035 skip_serializing_if = "String::is_empty",
29036 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29037 )]
29038 pub room_passcode: String,
29039 #[serde(
29043 default,
29044 skip_serializing_if = "String::is_empty",
29045 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29046 )]
29047 pub support_email: String,
29048 #[serde(
29052 default,
29053 skip_serializing_if = "String::is_empty",
29054 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29055 )]
29056 pub support_phone: String,
29057}
29058
29059#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29060pub struct UpdateRoomProfileRequest {
29061 #[serde(default, skip_serializing_if = "Option::is_none")]
29062 pub basic: Option<UpdateRoomProfileRequestBasic>,
29063}
29064
29065#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
29069pub enum DeviceType {
29070 #[serde(rename = "Companion Whiteboard")]
29071 CompanionWhiteboard,
29072 #[serde(rename = "Controller")]
29073 Controller,
29074 #[serde(rename = "Scheduling Display")]
29075 SchedulingDisplay,
29076 #[serde(rename = "Zoom Rooms Computer")]
29077 ZoomRoomsComputer,
29078 #[serde(rename = "Zoom Rooms Control System")]
29079 ZoomRoomsControlSystem,
29080 #[serde(rename = "")]
29081 #[default]
29082 Noop,
29083 #[serde(other)]
29084 FallthroughString,
29085}
29086
29087impl std::fmt::Display for DeviceType {
29088 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
29089 match self {
29090 DeviceType::CompanionWhiteboard => "Companion Whiteboard",
29091 DeviceType::Controller => "Controller",
29092 DeviceType::SchedulingDisplay => "Scheduling Display",
29093 DeviceType::ZoomRoomsComputer => "Zoom Rooms Computer",
29094 DeviceType::ZoomRoomsControlSystem => "Zoom Rooms Control System",
29095 DeviceType::Noop => "",
29096 DeviceType::FallthroughString => "*",
29097 }
29098 .fmt(f)
29099 }
29100}
29101
29102impl DeviceType {
29103 pub fn is_noop(&self) -> bool {
29104 matches!(self, DeviceType::Noop)
29105 }
29106}
29107
29108#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
29112pub enum ListZrDevicesResponseStatus {
29113 #[serde(rename = "Offline")]
29114 Offline,
29115 #[serde(rename = "Online")]
29116 Online,
29117 #[serde(rename = "")]
29118 #[default]
29119 Noop,
29120 #[serde(other)]
29121 FallthroughString,
29122}
29123
29124impl std::fmt::Display for ListZrDevicesResponseStatus {
29125 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
29126 match self {
29127 ListZrDevicesResponseStatus::Offline => "Offline",
29128 ListZrDevicesResponseStatus::Online => "Online",
29129 ListZrDevicesResponseStatus::Noop => "",
29130 ListZrDevicesResponseStatus::FallthroughString => "*",
29131 }
29132 .fmt(f)
29133 }
29134}
29135
29136impl ListZrDevicesResponseStatus {
29137 pub fn is_noop(&self) -> bool {
29138 matches!(self, ListZrDevicesResponseStatus::Noop)
29139 }
29140}
29141
29142#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29143pub struct Devices {
29144 #[serde(
29148 default,
29149 skip_serializing_if = "String::is_empty",
29150 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29151 )]
29152 pub app_version: String,
29153 #[serde(
29157 default,
29158 skip_serializing_if = "String::is_empty",
29159 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29160 )]
29161 pub device_system: String,
29162 #[serde(default, skip_serializing_if = "Option::is_none")]
29166 pub device_type: Option<DeviceType>,
29167 #[serde(
29171 default,
29172 skip_serializing_if = "String::is_empty",
29173 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29174 )]
29175 pub id: String,
29176 #[serde(
29180 default,
29181 skip_serializing_if = "String::is_empty",
29182 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29183 )]
29184 pub room_name: String,
29185 #[serde(default, skip_serializing_if = "Option::is_none")]
29189 pub status: Option<ListZrDevicesResponseStatus>,
29190}
29191
29192#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29193pub struct ListZrDevicesResponse {
29194 #[serde(
29195 default,
29196 skip_serializing_if = "Vec::is_empty",
29197 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
29198 )]
29199 pub devices: Vec<Devices>,
29200}
29201
29202#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29203pub struct ListSipTrunkNumbersResponse {
29204 #[serde(
29208 default,
29209 skip_serializing_if = "Vec::is_empty",
29210 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
29211 )]
29212 pub phone_numbers: Vec<DedicatedDialInNumber>,
29213 #[serde(
29217 default,
29218 skip_serializing_if = "crate::utils::zero_i64",
29219 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
29220 )]
29221 pub total_records: i64,
29222}
29223
29224#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29225pub struct AssignSipConfigRequest {
29226 #[serde(default, skip_serializing_if = "Option::is_none")]
29230 pub enable: Option<bool>,
29231 #[serde(default, skip_serializing_if = "Option::is_none")]
29235 pub show_callout_internal_number: Option<bool>,
29236 #[serde(
29240 default,
29241 skip_serializing_if = "crate::utils::zero_i64",
29242 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
29243 )]
29244 pub show_zoom_provided_callout_countries: i64,
29245 #[serde(
29249 default,
29250 skip_serializing_if = "crate::utils::zero_i64",
29251 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
29252 )]
29253 pub show_zoom_provided_numbers: i64,
29254}
29255
29256#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29257pub struct AssignSipTrunkNumbersRequest {
29258 #[serde(
29265 default,
29266 skip_serializing_if = "Vec::is_empty",
29267 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
29268 )]
29269 pub phone_numbers: Vec<String>,
29270}
29271
29272#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29273pub struct InMeetingFiles {
29274 #[serde(
29278 default,
29279 skip_serializing_if = "String::is_empty",
29280 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29281 )]
29282 pub download_url: String,
29283 #[serde(
29287 default,
29288 skip_serializing_if = "String::is_empty",
29289 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29290 )]
29291 pub file_name: String,
29292 #[serde(
29296 default,
29297 skip_serializing_if = "crate::utils::zero_i64",
29298 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
29299 )]
29300 pub file_size: i64,
29301}
29302
29303#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29304pub struct ListPastMeetingFilesResponse {
29305 #[serde(
29306 default,
29307 skip_serializing_if = "Vec::is_empty",
29308 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
29309 )]
29310 pub in_meeting_files: Vec<InMeetingFiles>,
29311 #[serde(
29315 default,
29316 skip_serializing_if = "crate::utils::zero_i64",
29317 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
29318 )]
29319 pub total_records: i64,
29320}
29321
29322#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29323pub struct ClientSatisfaction {
29324 #[serde(
29328 default,
29329 skip_serializing_if = "Option::is_none",
29330 deserialize_with = "crate::utils::date_format::deserialize"
29331 )]
29332 pub date: Option<chrono::NaiveDate>,
29333 #[serde(
29337 default,
29338 skip_serializing_if = "crate::utils::zero_i64",
29339 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
29340 )]
29341 pub good_count: i64,
29342 #[serde(
29346 default,
29347 skip_serializing_if = "crate::utils::zero_i64",
29348 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
29349 )]
29350 pub none_count: i64,
29351 #[serde(
29355 default,
29356 skip_serializing_if = "crate::utils::zero_i64",
29357 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
29358 )]
29359 pub not_good_count: i64,
29360 #[serde(
29364 default,
29365 skip_serializing_if = "crate::utils::zero_i64",
29366 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
29367 )]
29368 pub satisfaction_percent: i64,
29369}
29370
29371#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29372pub struct ListMeetingSatisfactionResponse {
29373 #[serde(
29374 default,
29375 skip_serializing_if = "Vec::is_empty",
29376 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
29377 )]
29378 pub client_satisfaction: Vec<ClientSatisfaction>,
29379 #[serde(
29383 default,
29384 skip_serializing_if = "Option::is_none",
29385 deserialize_with = "crate::utils::date_format::deserialize"
29386 )]
29387 pub from: Option<chrono::NaiveDate>,
29388 #[serde(
29392 default,
29393 skip_serializing_if = "Option::is_none",
29394 deserialize_with = "crate::utils::date_format::deserialize"
29395 )]
29396 pub to: Option<chrono::NaiveDate>,
29397 #[serde(
29401 default,
29402 skip_serializing_if = "crate::utils::zero_i64",
29403 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
29404 )]
29405 pub total_records: i64,
29406}
29407
29408#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
29412pub enum ListPhoneDevicesType {
29413 #[serde(rename = "assigned")]
29414 Assigned,
29415 #[serde(rename = "unassigned")]
29416 Unassigned,
29417 #[serde(rename = "")]
29418 #[default]
29419 Noop,
29420 #[serde(other)]
29421 FallthroughString,
29422}
29423
29424impl std::fmt::Display for ListPhoneDevicesType {
29425 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
29426 match self {
29427 ListPhoneDevicesType::Assigned => "assigned",
29428 ListPhoneDevicesType::Unassigned => "unassigned",
29429 ListPhoneDevicesType::Noop => "",
29430 ListPhoneDevicesType::FallthroughString => "*",
29431 }
29432 .fmt(f)
29433 }
29434}
29435
29436impl ListPhoneDevicesType {
29437 pub fn is_noop(&self) -> bool {
29438 matches!(self, ListPhoneDevicesType::Noop)
29439 }
29440}
29441
29442#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29443pub struct AddAutoReceptionistResponse {
29444 #[serde(
29448 default,
29449 skip_serializing_if = "crate::utils::zero_i64",
29450 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
29451 )]
29452 pub extension_number: i64,
29453 #[serde(
29457 default,
29458 skip_serializing_if = "String::is_empty",
29459 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29460 )]
29461 pub id: String,
29462 #[serde(
29466 default,
29467 skip_serializing_if = "String::is_empty",
29468 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29469 )]
29470 pub name: String,
29471}
29472
29473#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
29477pub enum ListPhoneDevicesResponseStatus {
29478 #[serde(rename = "offline")]
29479 Offline,
29480 #[serde(rename = "online")]
29481 Online,
29482 #[serde(rename = "")]
29483 #[default]
29484 Noop,
29485 #[serde(other)]
29486 FallthroughString,
29487}
29488
29489impl std::fmt::Display for ListPhoneDevicesResponseStatus {
29490 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
29491 match self {
29492 ListPhoneDevicesResponseStatus::Offline => "offline",
29493 ListPhoneDevicesResponseStatus::Online => "online",
29494 ListPhoneDevicesResponseStatus::Noop => "",
29495 ListPhoneDevicesResponseStatus::FallthroughString => "*",
29496 }
29497 .fmt(f)
29498 }
29499}
29500
29501impl ListPhoneDevicesResponseStatus {
29502 pub fn is_noop(&self) -> bool {
29503 matches!(self, ListPhoneDevicesResponseStatus::Noop)
29504 }
29505}
29506
29507#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29508pub struct ListPhoneDevicesResponse {
29509 #[serde(default, skip_serializing_if = "Option::is_none")]
29510 pub assignee: Option<AddAutoReceptionistResponse>,
29511 #[serde(
29515 default,
29516 skip_serializing_if = "String::is_empty",
29517 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29518 )]
29519 pub device_type: String,
29520 #[serde(
29524 default,
29525 skip_serializing_if = "String::is_empty",
29526 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29527 )]
29528 pub display_name: String,
29529 #[serde(
29533 default,
29534 skip_serializing_if = "String::is_empty",
29535 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29536 )]
29537 pub id: String,
29538 #[serde(
29542 default,
29543 skip_serializing_if = "String::is_empty",
29544 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29545 )]
29546 pub mac_address: String,
29547 #[serde(default, skip_serializing_if = "Option::is_none")]
29548 pub site: Option<Site>,
29549 #[serde(default, skip_serializing_if = "Option::is_none")]
29553 pub status: Option<ListPhoneDevicesResponseStatus>,
29554}
29555
29556#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29557pub struct ListPhoneDevicesResponseData {
29558 #[serde(
29559 default,
29560 skip_serializing_if = "Vec::is_empty",
29561 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
29562 )]
29563 pub devices: Vec<ListPhoneDevicesResponse>,
29564 #[serde(
29568 default,
29569 skip_serializing_if = "String::is_empty",
29570 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29571 )]
29572 pub next_page_token: String,
29573 #[serde(
29577 default,
29578 skip_serializing_if = "crate::utils::zero_i64",
29579 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
29580 )]
29581 pub page_size: i64,
29582 #[serde(
29586 default,
29587 skip_serializing_if = "String::is_empty",
29588 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29589 )]
29590 pub total_records: String,
29591}
29592
29593#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29594pub struct AddPhoneDeviceRequest {
29595 #[serde(
29599 default,
29600 skip_serializing_if = "String::is_empty",
29601 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29602 )]
29603 pub assigned_to: String,
29604 #[serde(
29608 default,
29609 skip_serializing_if = "String::is_empty",
29610 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29611 )]
29612 pub display_name: String,
29613 #[serde(
29617 default,
29618 skip_serializing_if = "String::is_empty",
29619 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29620 )]
29621 pub mac_address: String,
29622 #[serde(
29626 default,
29627 skip_serializing_if = "String::is_empty",
29628 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29629 )]
29630 pub model: String,
29631 #[serde(
29635 default,
29636 skip_serializing_if = "String::is_empty",
29637 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
29638 rename = "type"
29639 )]
29640 pub type_: String,
29641}
29642
29643#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29645pub struct GetDeviceResponseAssignee {
29646 #[serde(
29650 default,
29651 skip_serializing_if = "crate::utils::zero_i64",
29652 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
29653 )]
29654 pub extension_number: i64,
29655 #[serde(
29659 default,
29660 skip_serializing_if = "String::is_empty",
29661 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29662 )]
29663 pub id: String,
29664 #[serde(
29668 default,
29669 skip_serializing_if = "String::is_empty",
29670 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29671 )]
29672 pub name: String,
29673}
29674
29675#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
29685pub enum GetDeviceResponseProvisionType {
29686 #[serde(rename = "assisted")]
29687 Assisted,
29688 #[serde(rename = "manual")]
29689 Manual,
29690 #[serde(rename = "ztp")]
29691 Ztp,
29692 #[serde(rename = "")]
29693 #[default]
29694 Noop,
29695 #[serde(other)]
29696 FallthroughString,
29697}
29698
29699impl std::fmt::Display for GetDeviceResponseProvisionType {
29700 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
29701 match self {
29702 GetDeviceResponseProvisionType::Assisted => "assisted",
29703 GetDeviceResponseProvisionType::Manual => "manual",
29704 GetDeviceResponseProvisionType::Ztp => "ztp",
29705 GetDeviceResponseProvisionType::Noop => "",
29706 GetDeviceResponseProvisionType::FallthroughString => "*",
29707 }
29708 .fmt(f)
29709 }
29710}
29711
29712impl GetDeviceResponseProvisionType {
29713 pub fn is_noop(&self) -> bool {
29714 matches!(self, GetDeviceResponseProvisionType::Noop)
29715 }
29716}
29717
29718#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29720pub struct LineSubscription {
29721 #[serde(
29725 default,
29726 skip_serializing_if = "String::is_empty",
29727 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29728 )]
29729 pub display_name: String,
29730 #[serde(
29734 default,
29735 skip_serializing_if = "crate::utils::zero_i64",
29736 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
29737 )]
29738 pub extension_number: i64,
29739 #[serde(
29743 default,
29744 skip_serializing_if = "String::is_empty",
29745 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29746 )]
29747 pub phone_number: String,
29748}
29749
29750#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29752pub struct SharedLine {
29753 #[serde(
29757 default,
29758 skip_serializing_if = "String::is_empty",
29759 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29760 )]
29761 pub alias: String,
29762 #[serde(default, skip_serializing_if = "Option::is_none")]
29766 pub line_subscription: Option<LineSubscription>,
29767 #[serde(
29771 default,
29772 skip_serializing_if = "String::is_empty",
29773 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29774 )]
29775 pub outbound_caller_id: String,
29776}
29777
29778#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29779pub struct SipAccounts {
29780 #[serde(
29784 default,
29785 skip_serializing_if = "String::is_empty",
29786 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29787 )]
29788 pub authorization_id: String,
29789 #[serde(
29793 default,
29794 skip_serializing_if = "String::is_empty",
29795 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29796 )]
29797 pub outbound_proxy: String,
29798 #[serde(
29802 default,
29803 skip_serializing_if = "String::is_empty",
29804 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29805 )]
29806 pub password: String,
29807 #[serde(
29811 default,
29812 skip_serializing_if = "String::is_empty",
29813 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29814 )]
29815 pub secondary_outbound_proxy: String,
29816 #[serde(default, skip_serializing_if = "Option::is_none")]
29820 pub shared_line: Option<SharedLine>,
29821 #[serde(
29825 default,
29826 skip_serializing_if = "String::is_empty",
29827 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29828 )]
29829 pub sip_domain: String,
29830 #[serde(
29834 default,
29835 skip_serializing_if = "String::is_empty",
29836 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29837 )]
29838 pub user_name: String,
29839}
29840
29841#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29843pub struct Provision {
29844 #[serde(
29848 default,
29849 skip_serializing_if = "Vec::is_empty",
29850 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
29851 )]
29852 pub sip_accounts: Vec<SipAccounts>,
29853 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
29857 pub type_: Option<GetDeviceResponseProvisionType>,
29858 #[serde(
29862 default,
29863 skip_serializing_if = "String::is_empty",
29864 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29865 )]
29866 pub url: String,
29867}
29868
29869#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29870pub struct GetDeviceResponse {
29871 #[serde(default, skip_serializing_if = "Option::is_none")]
29875 pub assignee: Option<GetDeviceResponseAssignee>,
29876 #[serde(
29880 default,
29881 skip_serializing_if = "String::is_empty",
29882 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29883 )]
29884 pub device_type: String,
29885 #[serde(
29889 default,
29890 skip_serializing_if = "String::is_empty",
29891 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29892 )]
29893 pub display_name: String,
29894 #[serde(
29898 default,
29899 skip_serializing_if = "String::is_empty",
29900 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29901 )]
29902 pub id: String,
29903 #[serde(
29907 default,
29908 skip_serializing_if = "String::is_empty",
29909 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29910 )]
29911 pub mac_address: String,
29912 #[serde(default, skip_serializing_if = "Option::is_none")]
29916 pub provision: Option<Provision>,
29917 #[serde(default, skip_serializing_if = "Option::is_none")]
29918 pub site: Option<Site>,
29919 #[serde(default, skip_serializing_if = "Option::is_none")]
29923 pub status: Option<ListPhoneDevicesResponseStatus>,
29924}
29925
29926#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29927pub struct UpdateDeviceRequest {
29928 #[serde(
29932 default,
29933 skip_serializing_if = "String::is_empty",
29934 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29935 )]
29936 pub assigned_to: String,
29937 #[serde(
29941 default,
29942 skip_serializing_if = "String::is_empty",
29943 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29944 )]
29945 pub display_name: String,
29946 #[serde(
29950 default,
29951 skip_serializing_if = "String::is_empty",
29952 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29953 )]
29954 pub mac_address: String,
29955}
29956
29957#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
29958pub struct ExternalContacts {
29959 #[serde(
29963 default,
29964 skip_serializing_if = "String::is_empty",
29965 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29966 )]
29967 pub description: String,
29968 #[serde(
29972 default,
29973 skip_serializing_if = "String::is_empty",
29974 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29975 )]
29976 pub email: String,
29977 #[serde(
29981 default,
29982 skip_serializing_if = "String::is_empty",
29983 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29984 )]
29985 pub extension_number: String,
29986 #[serde(
29990 default,
29991 skip_serializing_if = "String::is_empty",
29992 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
29993 )]
29994 pub external_contact_id: String,
29995 #[serde(
29999 default,
30000 skip_serializing_if = "String::is_empty",
30001 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30002 )]
30003 pub id: String,
30004 #[serde(
30008 default,
30009 skip_serializing_if = "String::is_empty",
30010 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30011 )]
30012 pub name: String,
30013 #[serde(
30020 default,
30021 skip_serializing_if = "Vec::is_empty",
30022 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
30023 )]
30024 pub phone_numbers: Vec<String>,
30025}
30026
30027#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30028pub struct ListExternalContactsResponse {
30029 #[serde(
30033 default,
30034 skip_serializing_if = "Vec::is_empty",
30035 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
30036 )]
30037 pub external_contacts: Vec<ExternalContacts>,
30038 #[serde(
30042 default,
30043 skip_serializing_if = "String::is_empty",
30044 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30045 )]
30046 pub next_page_token: String,
30047 #[serde(
30051 default,
30052 skip_serializing_if = "crate::utils::zero_i64",
30053 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
30054 )]
30055 pub page_size: i64,
30056}
30057
30058#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30059pub struct AddExternalContactRequest {
30060 #[serde(
30064 default,
30065 skip_serializing_if = "String::is_empty",
30066 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30067 )]
30068 pub description: String,
30069 #[serde(
30073 default,
30074 skip_serializing_if = "String::is_empty",
30075 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30076 )]
30077 pub email: String,
30078 #[serde(
30082 default,
30083 skip_serializing_if = "String::is_empty",
30084 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30085 )]
30086 pub extension_number: String,
30087 #[serde(
30091 default,
30092 skip_serializing_if = "String::is_empty",
30093 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30094 )]
30095 pub id: String,
30096 #[serde(
30100 default,
30101 skip_serializing_if = "String::is_empty",
30102 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30103 )]
30104 pub name: String,
30105 #[serde(
30112 default,
30113 skip_serializing_if = "Vec::is_empty",
30114 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
30115 )]
30116 pub phone_numbers: Vec<String>,
30117 #[serde(
30121 default,
30122 skip_serializing_if = "String::is_empty",
30123 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30124 )]
30125 pub routing_path: String,
30126}
30127
30128#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30129pub struct UpdateExternalContactRequest {
30130 #[serde(
30134 default,
30135 skip_serializing_if = "String::is_empty",
30136 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30137 )]
30138 pub description: String,
30139 #[serde(
30143 default,
30144 skip_serializing_if = "String::is_empty",
30145 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30146 )]
30147 pub email: String,
30148 #[serde(
30152 default,
30153 skip_serializing_if = "String::is_empty",
30154 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30155 )]
30156 pub extension_number: String,
30157 #[serde(
30161 default,
30162 skip_serializing_if = "String::is_empty",
30163 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30164 )]
30165 pub id: String,
30166 #[serde(
30170 default,
30171 skip_serializing_if = "String::is_empty",
30172 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30173 )]
30174 pub name: String,
30175 #[serde(
30182 default,
30183 skip_serializing_if = "Vec::is_empty",
30184 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
30185 )]
30186 pub phone_numbers: Vec<String>,
30187 #[serde(
30191 default,
30192 skip_serializing_if = "String::is_empty",
30193 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30194 )]
30195 pub routing_path: String,
30196}
30197
30198#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30199pub struct ChangeZrLocationRequest {
30200 #[serde(
30204 default,
30205 skip_serializing_if = "String::is_empty",
30206 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30207 )]
30208 pub location_id: String,
30209}
30210
30211#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30212pub struct ChangeParentLocationRequest {
30213 #[serde(
30217 default,
30218 skip_serializing_if = "String::is_empty",
30219 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30220 )]
30221 pub parent_location_id: String,
30222}
30223
30224#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30225pub struct ListCallQueuesResponsePhoneNumbers {
30226 #[serde(
30230 default,
30231 skip_serializing_if = "String::is_empty",
30232 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30233 )]
30234 pub id: String,
30235 #[serde(
30239 default,
30240 skip_serializing_if = "String::is_empty",
30241 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30242 )]
30243 pub number: String,
30244 #[serde(default, skip_serializing_if = "Option::is_none")]
30248 pub source: Option<Source>,
30249}
30250
30251#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30252pub struct CallQueues {
30253 #[serde(
30257 default,
30258 skip_serializing_if = "crate::utils::zero_i64",
30259 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
30260 )]
30261 pub extension_number: i64,
30262 #[serde(
30266 default,
30267 skip_serializing_if = "String::is_empty",
30268 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30269 )]
30270 pub id: String,
30271 #[serde(
30275 default,
30276 skip_serializing_if = "String::is_empty",
30277 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30278 )]
30279 pub name: String,
30280 #[serde(
30284 default,
30285 skip_serializing_if = "Vec::is_empty",
30286 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
30287 )]
30288 pub phone_numbers: Vec<ListCallQueuesResponsePhoneNumbers>,
30289 #[serde(default, skip_serializing_if = "Option::is_none")]
30290 pub site: Option<Site>,
30291 #[serde(default, skip_serializing_if = "Option::is_none")]
30295 pub status: Option<ReportUsersType>,
30296}
30297
30298#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30299pub struct ListCallQueuesResponse {
30300 #[serde(
30301 default,
30302 skip_serializing_if = "Vec::is_empty",
30303 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
30304 )]
30305 pub call_queues: Vec<CallQueues>,
30306 #[serde(
30310 default,
30311 skip_serializing_if = "String::is_empty",
30312 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30313 )]
30314 pub next_page_token: String,
30315 #[serde(
30319 default,
30320 skip_serializing_if = "crate::utils::zero_i64",
30321 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
30322 )]
30323 pub page_size: i64,
30324 #[serde(
30328 default,
30329 skip_serializing_if = "crate::utils::zero_i64",
30330 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
30331 )]
30332 pub total_records: i64,
30333}
30334
30335#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30337pub struct CreateCallQueueRequestMembers {
30338 #[serde(
30342 default,
30343 skip_serializing_if = "Vec::is_empty",
30344 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
30345 )]
30346 pub common_area_phone_ids: Vec<String>,
30347 #[serde(
30351 default,
30352 skip_serializing_if = "Vec::is_empty",
30353 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
30354 )]
30355 pub users: Vec<Assistants>,
30356}
30357
30358#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30359pub struct CreateCallQueueRequest {
30360 #[serde(
30364 default,
30365 skip_serializing_if = "String::is_empty",
30366 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30367 )]
30368 pub description: String,
30369 #[serde(
30373 default,
30374 skip_serializing_if = "crate::utils::zero_i64",
30375 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
30376 )]
30377 pub extension_number: i64,
30378 #[serde(default, skip_serializing_if = "Option::is_none")]
30382 pub members: Option<CreateCallQueueRequestMembers>,
30383 #[serde(
30387 default,
30388 skip_serializing_if = "String::is_empty",
30389 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30390 )]
30391 pub name: String,
30392 #[serde(
30396 default,
30397 skip_serializing_if = "String::is_empty",
30398 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30399 )]
30400 pub site_id: String,
30401}
30402
30403#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30404pub struct CreateCallQueueResponse {
30405 #[serde(
30409 default,
30410 skip_serializing_if = "crate::utils::zero_i64",
30411 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
30412 )]
30413 pub extension_number: i64,
30414 #[serde(
30418 default,
30419 skip_serializing_if = "String::is_empty",
30420 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30421 )]
30422 pub id: String,
30423 #[serde(
30427 default,
30428 skip_serializing_if = "String::is_empty",
30429 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30430 )]
30431 pub name: String,
30432 #[serde(
30436 default,
30437 skip_serializing_if = "String::is_empty",
30438 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30439 )]
30440 pub status: String,
30441}
30442
30443#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
30449pub enum Level {
30450 #[serde(rename = "manager")]
30451 Manager,
30452 #[serde(rename = "user")]
30453 User,
30454 #[serde(rename = "")]
30455 #[default]
30456 Noop,
30457 #[serde(other)]
30458 FallthroughString,
30459}
30460
30461impl std::fmt::Display for Level {
30462 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
30463 match self {
30464 Level::Manager => "manager",
30465 Level::User => "user",
30466 Level::Noop => "",
30467 Level::FallthroughString => "*",
30468 }
30469 .fmt(f)
30470 }
30471}
30472
30473impl Level {
30474 pub fn is_noop(&self) -> bool {
30475 matches!(self, Level::Noop)
30476 }
30477}
30478
30479#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30480pub struct GetCallQueueResponseMembersUsers {
30481 #[serde(
30485 default,
30486 skip_serializing_if = "String::is_empty",
30487 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30488 )]
30489 pub id: String,
30490 #[serde(default, skip_serializing_if = "Option::is_none")]
30496 pub level: Option<Level>,
30497 #[serde(
30501 default,
30502 skip_serializing_if = "String::is_empty",
30503 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30504 )]
30505 pub name: String,
30506 #[serde(
30510 default,
30511 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
30512 )]
30513 pub receive_call: bool,
30514}
30515
30516#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30517pub struct GetCallQueueResponseMembers {
30518 #[serde(
30519 default,
30520 skip_serializing_if = "Vec::is_empty",
30521 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
30522 )]
30523 pub common_area_phones: Vec<Site>,
30524 #[serde(
30525 default,
30526 skip_serializing_if = "Vec::is_empty",
30527 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
30528 )]
30529 pub users: Vec<GetCallQueueResponseMembersUsers>,
30530}
30531
30532#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30533pub struct GetCallQueueResponse {
30534 #[serde(
30538 default,
30539 skip_serializing_if = "crate::utils::zero_i64",
30540 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
30541 )]
30542 pub extension_number: i64,
30543 #[serde(
30547 default,
30548 skip_serializing_if = "String::is_empty",
30549 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30550 )]
30551 pub id: String,
30552 #[serde(default, skip_serializing_if = "Option::is_none")]
30553 pub members: Option<GetCallQueueResponseMembers>,
30554 #[serde(
30558 default,
30559 skip_serializing_if = "String::is_empty",
30560 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30561 )]
30562 pub name: String,
30563 #[serde(
30567 default,
30568 skip_serializing_if = "Vec::is_empty",
30569 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
30570 )]
30571 pub phone_numbers: Vec<ListCallQueuesResponsePhoneNumbers>,
30572 #[serde(default, skip_serializing_if = "Option::is_none")]
30573 pub site: Option<Site>,
30574 #[serde(default, skip_serializing_if = "Option::is_none")]
30578 pub status: Option<ReportUsersType>,
30579}
30580
30581#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30582pub struct UpdateCallQueueRequest {
30583 #[serde(
30587 default,
30588 skip_serializing_if = "String::is_empty",
30589 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30590 )]
30591 pub description: String,
30592 #[serde(
30596 default,
30597 skip_serializing_if = "crate::utils::zero_i64",
30598 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
30599 )]
30600 pub extension_number: i64,
30601 #[serde(
30605 default,
30606 skip_serializing_if = "String::is_empty",
30607 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30608 )]
30609 pub name: String,
30610 #[serde(
30614 default,
30615 skip_serializing_if = "String::is_empty",
30616 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30617 )]
30618 pub site_id: String,
30619 #[serde(default, skip_serializing_if = "Option::is_none")]
30623 pub status: Option<ReportUsersType>,
30624 #[serde(
30628 default,
30629 skip_serializing_if = "String::is_empty",
30630 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30631 )]
30632 pub timezone: String,
30633}
30634
30635#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30637pub struct AddMembersCallQueueRequest {
30638 #[serde(
30642 default,
30643 skip_serializing_if = "Vec::is_empty",
30644 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
30645 )]
30646 pub common_area_phone_ids: Vec<String>,
30647 #[serde(
30651 default,
30652 skip_serializing_if = "Vec::is_empty",
30653 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
30654 )]
30655 pub users: Vec<Assistants>,
30656}
30657
30658#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30659pub struct AddMembersCallQueueRequestData {
30660 #[serde(default, skip_serializing_if = "Option::is_none")]
30664 pub members: Option<AddMembersCallQueueRequest>,
30665}
30666
30667#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30668pub struct ChangeCallQueueManagerRequest {
30669 #[serde(
30673 default,
30674 skip_serializing_if = "String::is_empty",
30675 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30676 )]
30677 pub member_id: String,
30678}
30679
30680#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30681pub struct GetPhoneNumberDetailsResponseCarrier {
30682 #[serde(
30686 default,
30687 skip_serializing_if = "crate::utils::zero_i64",
30688 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
30689 )]
30690 pub code: i64,
30691 #[serde(
30695 default,
30696 skip_serializing_if = "String::is_empty",
30697 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30698 )]
30699 pub name: String,
30700}
30701
30702#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30703pub struct AddCommonAreaPhoneResponse {
30704 #[serde(
30708 default,
30709 skip_serializing_if = "String::is_empty",
30710 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30711 )]
30712 pub display_name: String,
30713 #[serde(
30717 default,
30718 skip_serializing_if = "String::is_empty",
30719 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30720 )]
30721 pub id: String,
30722}
30723
30724#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30725pub struct GetPhoneNumberDetailsResponse {
30726 #[serde(default, skip_serializing_if = "Option::is_none")]
30727 pub assignee: Option<Assignee>,
30728 #[serde(
30735 default,
30736 skip_serializing_if = "Vec::is_empty",
30737 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
30738 )]
30739 pub capability: Vec<String>,
30740 #[serde(default, skip_serializing_if = "Option::is_none")]
30741 pub carrier: Option<GetPhoneNumberDetailsResponseCarrier>,
30742 #[serde(
30746 default,
30747 skip_serializing_if = "String::is_empty",
30748 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30749 )]
30750 pub display_name: String,
30751 #[serde(
30755 default,
30756 skip_serializing_if = "String::is_empty",
30757 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30758 )]
30759 pub id: String,
30760 #[serde(
30764 default,
30765 skip_serializing_if = "String::is_empty",
30766 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30767 )]
30768 pub location: String,
30769 #[serde(
30773 default,
30774 skip_serializing_if = "String::is_empty",
30775 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30776 )]
30777 pub number: String,
30778 #[serde(default, skip_serializing_if = "Option::is_none")]
30782 pub number_type: Option<Type>,
30783 #[serde(default, skip_serializing_if = "Option::is_none")]
30784 pub sip_group: Option<AddCommonAreaPhoneResponse>,
30785 #[serde(default, skip_serializing_if = "Option::is_none")]
30786 pub site: Option<Site>,
30787 #[serde(default, skip_serializing_if = "Option::is_none")]
30791 pub source: Option<Source>,
30792 #[serde(default, skip_serializing_if = "Option::is_none")]
30796 pub status: Option<ListAccountPhoneNumbersResponseStatus>,
30797}
30798
30799#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30800pub struct UpdatePhoneNumberDetailsRequest {
30801 #[serde(
30808 default,
30809 skip_serializing_if = "Vec::is_empty",
30810 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
30811 )]
30812 pub capability: Vec<String>,
30813 #[serde(
30817 default,
30818 skip_serializing_if = "String::is_empty",
30819 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30820 )]
30821 pub display_name: String,
30822 #[serde(
30826 default,
30827 skip_serializing_if = "String::is_empty",
30828 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30829 )]
30830 pub sip_group_id: String,
30831}
30832
30833#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30834pub struct ChangeMainCompanyNumberRequest {
30835 #[serde(
30839 default,
30840 skip_serializing_if = "String::is_empty",
30841 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30842 )]
30843 pub phone_number: String,
30844}
30845
30846#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30847pub struct ListCallingPlansResponse {
30848 #[serde(
30852 default,
30853 skip_serializing_if = "crate::utils::zero_i64",
30854 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
30855 )]
30856 pub assigned: i64,
30857 #[serde(
30861 default,
30862 skip_serializing_if = "crate::utils::zero_i64",
30863 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
30864 )]
30865 pub available: i64,
30866 #[serde(
30870 default,
30871 skip_serializing_if = "String::is_empty",
30872 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30873 )]
30874 pub name: String,
30875 #[serde(
30879 default,
30880 skip_serializing_if = "crate::utils::zero_i64",
30881 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
30882 )]
30883 pub subscribed: i64,
30884 #[serde(
30888 default,
30889 skip_serializing_if = "crate::utils::zero_i64",
30890 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
30891 rename = "type"
30892 )]
30893 pub type_: i64,
30894}
30895
30896#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30897pub struct ListCallingPlansResponseData {
30898 #[serde(
30899 default,
30900 skip_serializing_if = "Vec::is_empty",
30901 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
30902 )]
30903 pub calling_plans: Vec<ListCallingPlansResponse>,
30904}
30905
30906#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30907pub struct ListPhoneUsersResponseCallingPlans {
30908 #[serde(
30912 default,
30913 skip_serializing_if = "String::is_empty",
30914 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30915 )]
30916 pub name: String,
30917 #[serde(
30921 default,
30922 skip_serializing_if = "String::is_empty",
30923 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
30924 rename = "type"
30925 )]
30926 pub type_: String,
30927}
30928
30929#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30930pub struct ListPhoneUsersResponse {
30931 #[serde(
30932 default,
30933 skip_serializing_if = "Vec::is_empty",
30934 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
30935 )]
30936 pub calling_plans: Vec<ListPhoneUsersResponseCallingPlans>,
30937 #[serde(
30941 default,
30942 skip_serializing_if = "String::is_empty",
30943 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30944 )]
30945 pub email: String,
30946 #[serde(
30950 default,
30951 skip_serializing_if = "crate::utils::zero_i64",
30952 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
30953 )]
30954 pub extension_number: i64,
30955 #[serde(
30959 default,
30960 skip_serializing_if = "String::is_empty",
30961 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30962 )]
30963 pub id: String,
30964 #[serde(
30968 default,
30969 skip_serializing_if = "String::is_empty",
30970 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30971 )]
30972 pub name: String,
30973 #[serde(
30977 default,
30978 skip_serializing_if = "String::is_empty",
30979 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30980 )]
30981 pub phone_user_id: String,
30982 #[serde(default, skip_serializing_if = "Option::is_none")]
30983 pub site: Option<Site>,
30984 #[serde(
30988 default,
30989 skip_serializing_if = "String::is_empty",
30990 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
30991 )]
30992 pub status: String,
30993}
30994
30995#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
30996pub struct ListPhoneUsersResponseData {
30997 #[serde(
31001 default,
31002 skip_serializing_if = "String::is_empty",
31003 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31004 )]
31005 pub next_page_token: String,
31006 #[serde(
31010 default,
31011 skip_serializing_if = "crate::utils::zero_i64",
31012 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
31013 )]
31014 pub page_size: i64,
31015 #[serde(
31019 default,
31020 skip_serializing_if = "crate::utils::zero_i64",
31021 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
31022 )]
31023 pub total_records: i64,
31024 #[serde(
31025 default,
31026 skip_serializing_if = "Vec::is_empty",
31027 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
31028 )]
31029 pub users: Vec<ListPhoneUsersResponse>,
31030}
31031
31032#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31033pub struct UpdateAutoReceptionistRequest {
31034 #[serde(
31038 default,
31039 skip_serializing_if = "crate::utils::zero_i64",
31040 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
31041 )]
31042 pub extension_number: i64,
31043 #[serde(
31047 default,
31048 skip_serializing_if = "String::is_empty",
31049 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31050 )]
31051 pub name: String,
31052}
31053
31054#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31055pub struct CommonAreaPhones {
31056 #[serde(
31057 default,
31058 skip_serializing_if = "Vec::is_empty",
31059 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
31060 )]
31061 pub calling_plans: Vec<ListPhoneUsersResponseCallingPlans>,
31062 #[serde(
31066 default,
31067 skip_serializing_if = "String::is_empty",
31068 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31069 )]
31070 pub device_type: String,
31071 #[serde(
31075 default,
31076 skip_serializing_if = "String::is_empty",
31077 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31078 )]
31079 pub display_name: String,
31080 #[serde(
31084 default,
31085 skip_serializing_if = "String::is_empty",
31086 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31087 )]
31088 pub id: String,
31089 #[serde(
31093 default,
31094 skip_serializing_if = "String::is_empty",
31095 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31096 )]
31097 pub mac_address: String,
31098 #[serde(
31102 default,
31103 skip_serializing_if = "Vec::is_empty",
31104 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
31105 )]
31106 pub phone_numbers: Vec<ListCallQueuesResponsePhoneNumbers>,
31107 #[serde(default, skip_serializing_if = "Option::is_none")]
31108 pub site: Option<Site>,
31109 #[serde(
31113 default,
31114 skip_serializing_if = "String::is_empty",
31115 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31116 )]
31117 pub status: String,
31118}
31119
31120#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31121pub struct ListCommonAreaPhonesResponse {
31122 #[serde(
31123 default,
31124 skip_serializing_if = "Vec::is_empty",
31125 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
31126 )]
31127 pub common_area_phones: Vec<CommonAreaPhones>,
31128 #[serde(
31132 default,
31133 skip_serializing_if = "String::is_empty",
31134 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31135 )]
31136 pub next_page_token: String,
31137 #[serde(
31141 default,
31142 skip_serializing_if = "crate::utils::zero_i64",
31143 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
31144 )]
31145 pub page_size: i64,
31146 #[serde(
31150 default,
31151 skip_serializing_if = "crate::utils::zero_i64",
31152 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
31153 )]
31154 pub total_records: i64,
31155}
31156
31157#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31158pub struct AddCommonAreaPhoneRequest {
31159 #[serde(
31163 default,
31164 skip_serializing_if = "String::is_empty",
31165 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31166 )]
31167 pub description: String,
31168 #[serde(
31172 default,
31173 skip_serializing_if = "String::is_empty",
31174 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31175 )]
31176 pub display_name: String,
31177 #[serde(
31181 default,
31182 skip_serializing_if = "crate::utils::zero_i64",
31183 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
31184 )]
31185 pub extension_number: i64,
31186 #[serde(
31190 default,
31191 skip_serializing_if = "String::is_empty",
31192 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31193 )]
31194 pub mac_address: String,
31195 #[serde(
31199 default,
31200 skip_serializing_if = "String::is_empty",
31201 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31202 )]
31203 pub model: String,
31204 #[serde(
31208 default,
31209 skip_serializing_if = "String::is_empty",
31210 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31211 )]
31212 pub provision_template_id: String,
31213 #[serde(
31217 default,
31218 skip_serializing_if = "String::is_empty",
31219 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31220 )]
31221 pub site_id: String,
31222 #[serde(
31226 default,
31227 skip_serializing_if = "String::is_empty",
31228 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31229 )]
31230 pub time_zone: String,
31231 #[serde(
31235 default,
31236 skip_serializing_if = "String::is_empty",
31237 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
31238 rename = "type"
31239 )]
31240 pub type_: String,
31241}
31242
31243#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31244pub struct GetCommonAreaPhoneResponseProvisionSipAccounts {
31245 #[serde(
31249 default,
31250 skip_serializing_if = "String::is_empty",
31251 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31252 )]
31253 pub authorization_id: String,
31254 #[serde(
31258 default,
31259 skip_serializing_if = "String::is_empty",
31260 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31261 )]
31262 pub outbound_proxy: String,
31263 #[serde(
31267 default,
31268 skip_serializing_if = "String::is_empty",
31269 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31270 )]
31271 pub password: String,
31272 #[serde(
31276 default,
31277 skip_serializing_if = "String::is_empty",
31278 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31279 )]
31280 pub secondary_outbound_proxy: String,
31281 #[serde(
31285 default,
31286 skip_serializing_if = "String::is_empty",
31287 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31288 )]
31289 pub sip_domain: String,
31290 #[serde(
31294 default,
31295 skip_serializing_if = "String::is_empty",
31296 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31297 )]
31298 pub user_name: String,
31299}
31300
31301#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31303pub struct GetCommonAreaPhoneResponseProvision {
31304 #[serde(
31308 default,
31309 skip_serializing_if = "Vec::is_empty",
31310 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
31311 )]
31312 pub sip_accounts: Vec<GetCommonAreaPhoneResponseProvisionSipAccounts>,
31313 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
31317 pub type_: Option<GetDeviceResponseProvisionType>,
31318 #[serde(
31322 default,
31323 skip_serializing_if = "String::is_empty",
31324 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31325 )]
31326 pub url: String,
31327}
31328
31329#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31330pub struct GetCommonAreaPhoneResponseNumbers {
31331 #[serde(
31335 default,
31336 skip_serializing_if = "String::is_empty",
31337 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31338 )]
31339 pub display_name: String,
31340 #[serde(
31344 default,
31345 skip_serializing_if = "String::is_empty",
31346 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31347 )]
31348 pub id: String,
31349 #[serde(
31353 default,
31354 skip_serializing_if = "String::is_empty",
31355 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31356 )]
31357 pub number: String,
31358 #[serde(default, skip_serializing_if = "Option::is_none")]
31362 pub source: Option<Source>,
31363}
31364
31365#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31366pub struct ProvisionTemplate {
31367 #[serde(
31371 default,
31372 skip_serializing_if = "String::is_empty",
31373 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31374 )]
31375 pub id: String,
31376 #[serde(
31380 default,
31381 skip_serializing_if = "String::is_empty",
31382 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31383 )]
31384 pub name: String,
31385 #[serde(
31389 default,
31390 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
31391 )]
31392 pub supported: bool,
31393}
31394
31395#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31397pub struct InternationalCall {
31398 #[serde(
31402 default,
31403 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
31404 )]
31405 pub enable: bool,
31406}
31407
31408#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
31412pub enum GetCommonAreaPhoneResponsePolicyHotDeskingStatus {
31413 #[serde(rename = "off")]
31414 Off,
31415 #[serde(rename = "on")]
31416 On,
31417 #[serde(rename = "unsupported")]
31418 Unsupported,
31419 #[serde(rename = "")]
31420 #[default]
31421 Noop,
31422 #[serde(other)]
31423 FallthroughString,
31424}
31425
31426impl std::fmt::Display for GetCommonAreaPhoneResponsePolicyHotDeskingStatus {
31427 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
31428 match self {
31429 GetCommonAreaPhoneResponsePolicyHotDeskingStatus::Off => "off",
31430 GetCommonAreaPhoneResponsePolicyHotDeskingStatus::On => "on",
31431 GetCommonAreaPhoneResponsePolicyHotDeskingStatus::Unsupported => "unsupported",
31432 GetCommonAreaPhoneResponsePolicyHotDeskingStatus::Noop => "",
31433 GetCommonAreaPhoneResponsePolicyHotDeskingStatus::FallthroughString => "*",
31434 }
31435 .fmt(f)
31436 }
31437}
31438
31439impl GetCommonAreaPhoneResponsePolicyHotDeskingStatus {
31440 pub fn is_noop(&self) -> bool {
31441 matches!(self, GetCommonAreaPhoneResponsePolicyHotDeskingStatus::Noop)
31442 }
31443}
31444
31445#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31447pub struct HotDesking {
31448 #[serde(default, skip_serializing_if = "Option::is_none")]
31452 pub status: Option<GetCommonAreaPhoneResponsePolicyHotDeskingStatus>,
31453}
31454
31455#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31456pub struct GetCommonAreaPhoneResponsePolicy {
31457 #[serde(default, skip_serializing_if = "Option::is_none")]
31461 pub hot_desking: Option<HotDesking>,
31462 #[serde(default, skip_serializing_if = "Option::is_none")]
31466 pub international_call: Option<InternationalCall>,
31467 #[serde(default, skip_serializing_if = "Option::is_none")]
31471 pub select_outbound_caller_id: Option<InternationalCall>,
31472}
31473
31474#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31475pub struct GetCommonAreaPhoneResponse {
31476 #[serde(
31477 default,
31478 skip_serializing_if = "Vec::is_empty",
31479 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
31480 )]
31481 pub calling_plans: Vec<ListPhoneUsersResponseCallingPlans>,
31482 #[serde(
31486 default,
31487 skip_serializing_if = "String::is_empty",
31488 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31489 )]
31490 pub device_type: String,
31491 #[serde(
31495 default,
31496 skip_serializing_if = "String::is_empty",
31497 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31498 )]
31499 pub id: String,
31500 #[serde(
31504 default,
31505 skip_serializing_if = "String::is_empty",
31506 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31507 )]
31508 pub mac_address: String,
31509 #[serde(
31513 default,
31514 skip_serializing_if = "String::is_empty",
31515 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31516 )]
31517 pub name: String,
31518 #[serde(
31519 default,
31520 skip_serializing_if = "Vec::is_empty",
31521 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
31522 )]
31523 pub phone_numbers: Vec<GetCommonAreaPhoneResponseNumbers>,
31524 #[serde(default, skip_serializing_if = "Option::is_none")]
31525 pub policy: Option<GetCommonAreaPhoneResponsePolicy>,
31526 #[serde(default, skip_serializing_if = "Option::is_none")]
31530 pub provision: Option<GetCommonAreaPhoneResponseProvision>,
31531 #[serde(default, skip_serializing_if = "Option::is_none")]
31532 pub provision_template: Option<ProvisionTemplate>,
31533 #[serde(default, skip_serializing_if = "Option::is_none")]
31534 pub site: Option<Site>,
31535 #[serde(
31539 default,
31540 skip_serializing_if = "String::is_empty",
31541 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31542 )]
31543 pub status: String,
31544}
31545
31546#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31547pub struct UpdateCommonAreaPhoneRequestPolicy {
31548 #[serde(default, skip_serializing_if = "Option::is_none")]
31552 pub hot_desking: Option<HotDesking>,
31553 #[serde(default, skip_serializing_if = "Option::is_none")]
31554 pub international_call: Option<ShowDeviceIpCallLog>,
31555 #[serde(default, skip_serializing_if = "Option::is_none")]
31556 pub select_outbound_caller_id: Option<ShowDeviceIpCallLog>,
31557}
31558
31559#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31560pub struct UpdateCommonAreaPhoneRequest {
31561 #[serde(
31565 default,
31566 skip_serializing_if = "String::is_empty",
31567 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31568 )]
31569 pub display_name: String,
31570 #[serde(
31574 default,
31575 skip_serializing_if = "crate::utils::zero_i64",
31576 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
31577 )]
31578 pub extension_number: i64,
31579 #[serde(
31583 default,
31584 skip_serializing_if = "String::is_empty",
31585 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31586 )]
31587 pub mac_address: String,
31588 #[serde(default, skip_serializing_if = "Option::is_none")]
31589 pub policy: Option<UpdateCommonAreaPhoneRequestPolicy>,
31590 #[serde(
31594 default,
31595 skip_serializing_if = "String::is_empty",
31596 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31597 )]
31598 pub provision_template_id: String,
31599 #[serde(
31603 default,
31604 skip_serializing_if = "String::is_empty",
31605 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31606 )]
31607 pub site_id: String,
31608}
31609
31610#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31611pub struct AssignPhoneNumbersCommonAreaRequest {
31612 #[serde(
31613 default,
31614 skip_serializing_if = "Vec::is_empty",
31615 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
31616 )]
31617 pub phone_numbers: Vec<PhoneUserResponseNumbers>,
31618}
31619
31620#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31621pub struct AssignPhoneNumbersCommonAreaResponse {
31622 #[serde(
31626 default,
31627 skip_serializing_if = "String::is_empty",
31628 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31629 )]
31630 pub id: String,
31631 #[serde(
31635 default,
31636 skip_serializing_if = "crate::utils::zero_i64",
31637 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
31638 )]
31639 pub number: i64,
31640}
31641
31642#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31643pub struct AssignPhoneNumbersCommonAreaResponseData {
31644 #[serde(
31645 default,
31646 skip_serializing_if = "Vec::is_empty",
31647 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
31648 )]
31649 pub phone_numbers: Vec<AssignPhoneNumbersCommonAreaResponse>,
31650}
31651
31652#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31653pub struct AssignCallingPlansCommonAreaPhoneRequest {
31654 #[serde(
31658 default,
31659 skip_serializing_if = "crate::utils::zero_i64",
31660 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
31661 rename = "type"
31662 )]
31663 pub type_: i64,
31664}
31665
31666#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31667pub struct AssignCallingPlansCommonAreaPhoneRequestData {
31668 #[serde(
31669 default,
31670 skip_serializing_if = "Vec::is_empty",
31671 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
31672 )]
31673 pub calling_plans: Vec<AssignCallingPlansCommonAreaPhoneRequest>,
31674}
31675
31676#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31677pub struct AssignCallingPlansCommonAreaPhoneResponse {
31678 #[serde(
31682 default,
31683 skip_serializing_if = "crate::utils::zero_i64",
31684 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
31685 )]
31686 pub name: i64,
31687 #[serde(
31691 default,
31692 skip_serializing_if = "crate::utils::zero_i64",
31693 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
31694 rename = "type"
31695 )]
31696 pub type_: i64,
31697}
31698
31699#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31700pub struct AssignCallingPlansCommonAreaPhoneResponseData {
31701 #[serde(
31702 default,
31703 skip_serializing_if = "Vec::is_empty",
31704 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
31705 )]
31706 pub calling_plans: Vec<AssignCallingPlansCommonAreaPhoneResponse>,
31707}
31708
31709#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
31715pub enum MatchType {
31716 #[serde(rename = "phoneNumber")]
31717 PhoneNumber,
31718 #[serde(rename = "prefix")]
31719 Prefix,
31720 #[serde(rename = "")]
31721 #[default]
31722 Noop,
31723 #[serde(other)]
31724 FallthroughString,
31725}
31726
31727impl std::fmt::Display for MatchType {
31728 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
31729 match self {
31730 MatchType::PhoneNumber => "phoneNumber",
31731 MatchType::Prefix => "prefix",
31732 MatchType::Noop => "",
31733 MatchType::FallthroughString => "*",
31734 }
31735 .fmt(f)
31736 }
31737}
31738
31739impl MatchType {
31740 pub fn is_noop(&self) -> bool {
31741 matches!(self, MatchType::Noop)
31742 }
31743}
31744
31745#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31746pub struct BlockedList {
31747 #[serde(default, skip_serializing_if = "Option::is_none")]
31751 pub block_type: Option<Direction>,
31752 #[serde(
31756 default,
31757 skip_serializing_if = "String::is_empty",
31758 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31759 )]
31760 pub comment: String,
31761 #[serde(
31765 default,
31766 skip_serializing_if = "String::is_empty",
31767 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31768 )]
31769 pub id: String,
31770 #[serde(default, skip_serializing_if = "Option::is_none")]
31776 pub match_type: Option<MatchType>,
31777 #[serde(
31781 default,
31782 skip_serializing_if = "String::is_empty",
31783 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31784 )]
31785 pub phone_number: String,
31786 #[serde(default, skip_serializing_if = "Option::is_none")]
31790 pub status: Option<ReportUsersType>,
31791}
31792
31793#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31794pub struct ListBlockedResponse {
31795 #[serde(
31796 default,
31797 skip_serializing_if = "Vec::is_empty",
31798 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
31799 )]
31800 pub blocked_list: Vec<BlockedList>,
31801 #[serde(
31805 default,
31806 skip_serializing_if = "String::is_empty",
31807 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31808 )]
31809 pub next_page_token: String,
31810 #[serde(
31814 default,
31815 skip_serializing_if = "crate::utils::zero_i64",
31816 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
31817 )]
31818 pub page_size: i64,
31819 #[serde(
31823 default,
31824 skip_serializing_if = "crate::utils::zero_i64",
31825 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
31826 )]
31827 pub total_records: i64,
31828}
31829
31830#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31831pub struct UpdateBlockedListRequest {
31832 #[serde(default, skip_serializing_if = "Option::is_none")]
31836 pub block_type: Option<Direction>,
31837 #[serde(
31841 default,
31842 skip_serializing_if = "String::is_empty",
31843 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31844 )]
31845 pub comment: String,
31846 #[serde(default, skip_serializing_if = "Option::is_none")]
31852 pub match_type: Option<MatchType>,
31853 #[serde(
31857 default,
31858 skip_serializing_if = "String::is_empty",
31859 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31860 )]
31861 pub phone_number: String,
31862 #[serde(default, skip_serializing_if = "Option::is_none")]
31866 pub status: Option<ReportUsersType>,
31867}
31868
31869#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31870pub struct BillingReports {
31871 #[serde(
31875 default,
31876 skip_serializing_if = "Option::is_none",
31877 deserialize_with = "crate::utils::date_format::deserialize"
31878 )]
31879 pub end_date: Option<chrono::NaiveDate>,
31880 #[serde(
31884 default,
31885 skip_serializing_if = "String::is_empty",
31886 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31887 )]
31888 pub id: String,
31889 #[serde(
31893 default,
31894 skip_serializing_if = "Option::is_none",
31895 deserialize_with = "crate::utils::date_format::deserialize"
31896 )]
31897 pub start_date: Option<chrono::NaiveDate>,
31898 #[serde(
31902 default,
31903 skip_serializing_if = "String::is_empty",
31904 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31905 )]
31906 pub tax_amount: String,
31907 #[serde(
31911 default,
31912 skip_serializing_if = "String::is_empty",
31913 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31914 )]
31915 pub total_amount: String,
31916 #[serde(
31920 default,
31921 skip_serializing_if = "crate::utils::zero_i64",
31922 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
31923 rename = "type"
31924 )]
31925 pub type_: i64,
31926}
31927
31928#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31929pub struct GetBillingReportResponse {
31930 #[serde(
31931 default,
31932 skip_serializing_if = "Vec::is_empty",
31933 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
31934 )]
31935 pub billing_reports: Vec<BillingReports>,
31936 #[serde(
31940 default,
31941 skip_serializing_if = "String::is_empty",
31942 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31943 )]
31944 pub currency: String,
31945}
31946
31947#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
31948pub struct Invoices {
31949 #[serde(
31953 default,
31954 skip_serializing_if = "Option::is_none",
31955 deserialize_with = "crate::utils::date_format::deserialize"
31956 )]
31957 pub end_date: Option<chrono::NaiveDate>,
31958 #[serde(
31962 default,
31963 skip_serializing_if = "String::is_empty",
31964 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31965 )]
31966 pub invoice_charge_name: String,
31967 #[serde(
31971 default,
31972 skip_serializing_if = "String::is_empty",
31973 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
31974 )]
31975 pub invoice_number: String,
31976 #[serde(
31980 default,
31981 skip_serializing_if = "crate::utils::zero_i64",
31982 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
31983 )]
31984 pub quantity: i64,
31985 #[serde(
31989 default,
31990 skip_serializing_if = "Option::is_none",
31991 deserialize_with = "crate::utils::date_format::deserialize"
31992 )]
31993 pub start_date: Option<chrono::NaiveDate>,
31994 #[serde(
31998 default,
31999 skip_serializing_if = "String::is_empty",
32000 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32001 )]
32002 pub tax_amount: String,
32003 #[serde(
32007 default,
32008 skip_serializing_if = "String::is_empty",
32009 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32010 )]
32011 pub total_amount: String,
32012}
32013
32014#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32015pub struct GetBillingInvoicesReportsResponse {
32016 #[serde(
32020 default,
32021 skip_serializing_if = "String::is_empty",
32022 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32023 )]
32024 pub currency: String,
32025 #[serde(
32026 default,
32027 skip_serializing_if = "Vec::is_empty",
32028 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
32029 )]
32030 pub invoices: Vec<Invoices>,
32031}
32032
32033#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32034pub struct ListSharedLineGroupsResponsePhoneNumbers {
32035 #[serde(
32039 default,
32040 skip_serializing_if = "String::is_empty",
32041 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32042 )]
32043 pub id: String,
32044 #[serde(
32048 default,
32049 skip_serializing_if = "String::is_empty",
32050 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32051 )]
32052 pub number: String,
32053 #[serde(default, skip_serializing_if = "Option::is_none")]
32057 pub status: Option<ListAccountPhoneNumbersResponseStatus>,
32058}
32059
32060#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32061pub struct SharedLineGroups {
32062 #[serde(
32066 default,
32067 skip_serializing_if = "String::is_empty",
32068 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32069 )]
32070 pub display_name: String,
32071 #[serde(
32075 default,
32076 skip_serializing_if = "crate::utils::zero_i64",
32077 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
32078 )]
32079 pub extension_number: i64,
32080 #[serde(
32084 default,
32085 skip_serializing_if = "String::is_empty",
32086 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32087 )]
32088 pub id: String,
32089 #[serde(
32093 default,
32094 skip_serializing_if = "Vec::is_empty",
32095 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
32096 )]
32097 pub phone_numbers: Vec<ListSharedLineGroupsResponsePhoneNumbers>,
32098 #[serde(default, skip_serializing_if = "Option::is_none")]
32099 pub site: Option<Site>,
32100 #[serde(default, skip_serializing_if = "Option::is_none")]
32104 pub status: Option<ReportUsersType>,
32105}
32106
32107#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32108pub struct ListSharedLineGroupsResponse {
32109 #[serde(
32113 default,
32114 skip_serializing_if = "String::is_empty",
32115 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32116 )]
32117 pub next_page_token: String,
32118 #[serde(
32122 default,
32123 skip_serializing_if = "crate::utils::zero_i64",
32124 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
32125 )]
32126 pub page_size: i64,
32127 #[serde(
32128 default,
32129 skip_serializing_if = "Vec::is_empty",
32130 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
32131 )]
32132 pub shared_line_groups: Vec<SharedLineGroups>,
32133 #[serde(
32137 default,
32138 skip_serializing_if = "crate::utils::zero_i64",
32139 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
32140 )]
32141 pub total_records: i64,
32142}
32143
32144#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32145pub struct CreateSharedLineGroupRequest {
32146 #[serde(
32150 default,
32151 skip_serializing_if = "String::is_empty",
32152 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32153 )]
32154 pub description: String,
32155 #[serde(
32159 default,
32160 skip_serializing_if = "String::is_empty",
32161 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32162 )]
32163 pub display_name: String,
32164 #[serde(
32168 default,
32169 skip_serializing_if = "crate::utils::zero_i64",
32170 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
32171 )]
32172 pub extension_number: i64,
32173 #[serde(
32177 default,
32178 skip_serializing_if = "String::is_empty",
32179 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32180 )]
32181 pub site_id: String,
32182}
32183
32184#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32186pub struct GetSharedLineGroupResponseSite {
32187 #[serde(
32191 default,
32192 skip_serializing_if = "String::is_empty",
32193 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32194 )]
32195 pub id: String,
32196 #[serde(
32200 default,
32201 skip_serializing_if = "String::is_empty",
32202 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32203 )]
32204 pub name: String,
32205}
32206
32207#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32209pub struct GetSharedLineGroupResponseMembers {
32210 #[serde(
32214 default,
32215 skip_serializing_if = "Vec::is_empty",
32216 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
32217 )]
32218 pub common_area_phones: Vec<Site>,
32219 #[serde(
32223 default,
32224 skip_serializing_if = "Vec::is_empty",
32225 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
32226 )]
32227 pub users: Vec<Site>,
32228}
32229
32230#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32231pub struct GetSharedLineGroupResponse {
32232 #[serde(
32236 default,
32237 skip_serializing_if = "String::is_empty",
32238 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32239 )]
32240 pub display_name: String,
32241 #[serde(
32245 default,
32246 skip_serializing_if = "crate::utils::zero_i64",
32247 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
32248 )]
32249 pub extension_number: i64,
32250 #[serde(
32254 default,
32255 skip_serializing_if = "String::is_empty",
32256 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32257 )]
32258 pub id: String,
32259 #[serde(default, skip_serializing_if = "Option::is_none")]
32263 pub members: Option<GetSharedLineGroupResponseMembers>,
32264 #[serde(
32265 default,
32266 skip_serializing_if = "Vec::is_empty",
32267 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
32268 )]
32269 pub phone_numbers: Vec<PhoneUserResponseNumbers>,
32270 #[serde(
32274 default,
32275 skip_serializing_if = "String::is_empty",
32276 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32277 )]
32278 pub primary_number: String,
32279 #[serde(default, skip_serializing_if = "Option::is_none")]
32283 pub site: Option<GetSharedLineGroupResponseSite>,
32284 #[serde(default, skip_serializing_if = "Option::is_none")]
32288 pub status: Option<ReportUsersType>,
32289 #[serde(
32293 default,
32294 skip_serializing_if = "String::is_empty",
32295 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32296 )]
32297 pub timezone: String,
32298}
32299
32300#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32302pub struct PrimaryNumber {
32303 #[serde(
32307 default,
32308 skip_serializing_if = "String::is_empty",
32309 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32310 )]
32311 pub id: String,
32312 #[serde(
32316 default,
32317 skip_serializing_if = "String::is_empty",
32318 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32319 )]
32320 pub number: String,
32321}
32322
32323#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32324pub struct UpdateSharedLineGroupRequest {
32325 #[serde(
32329 default,
32330 skip_serializing_if = "String::is_empty",
32331 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32332 )]
32333 pub display_name: String,
32334 #[serde(
32338 default,
32339 skip_serializing_if = "crate::utils::zero_i64",
32340 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
32341 )]
32342 pub extension_number: i64,
32343 #[serde(default, skip_serializing_if = "Option::is_none")]
32347 pub primary_number: Option<PrimaryNumber>,
32348 #[serde(default, skip_serializing_if = "Option::is_none")]
32352 pub status: Option<ReportUsersType>,
32353 #[serde(
32357 default,
32358 skip_serializing_if = "String::is_empty",
32359 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32360 )]
32361 pub timezone: String,
32362}
32363
32364#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32366pub struct AddMembersSharedLineGroupRequest {
32367 #[serde(
32371 default,
32372 skip_serializing_if = "Vec::is_empty",
32373 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
32374 )]
32375 pub common_area_phone_ids: Vec<String>,
32376 #[serde(
32380 default,
32381 skip_serializing_if = "Vec::is_empty",
32382 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
32383 )]
32384 pub users: Vec<Assistants>,
32385}
32386
32387#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32388pub struct AddMembersSharedLineGroupRequestData {
32389 #[serde(default, skip_serializing_if = "Option::is_none")]
32393 pub members: Option<AddMembersSharedLineGroupRequest>,
32394}
32395
32396#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32397pub struct AddAutoReceptionistRequest {
32398 #[serde(
32402 default,
32403 skip_serializing_if = "String::is_empty",
32404 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32405 )]
32406 pub name: String,
32407 #[serde(
32411 default,
32412 skip_serializing_if = "String::is_empty",
32413 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32414 )]
32415 pub site_id: String,
32416}
32417
32418#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32419pub struct GetCallQueueRecordingsResponse {
32420 #[serde(
32424 default,
32425 skip_serializing_if = "String::is_empty",
32426 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32427 )]
32428 pub callee_name: String,
32429 #[serde(
32433 default,
32434 skip_serializing_if = "String::is_empty",
32435 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32436 )]
32437 pub callee_number: String,
32438 #[serde(
32442 default,
32443 skip_serializing_if = "String::is_empty",
32444 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32445 )]
32446 pub callee_number_type: String,
32447 #[serde(
32451 default,
32452 skip_serializing_if = "String::is_empty",
32453 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32454 )]
32455 pub caller_name: String,
32456 #[serde(
32460 default,
32461 skip_serializing_if = "String::is_empty",
32462 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32463 )]
32464 pub caller_number: String,
32465 #[serde(
32469 default,
32470 skip_serializing_if = "String::is_empty",
32471 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32472 )]
32473 pub caller_number_type: String,
32474 #[serde(
32478 default,
32479 skip_serializing_if = "Option::is_none",
32480 deserialize_with = "crate::utils::date_format::deserialize"
32481 )]
32482 pub date_time: Option<chrono::NaiveDate>,
32483 #[serde(
32487 default,
32488 skip_serializing_if = "String::is_empty",
32489 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32490 )]
32491 pub direction: String,
32492 #[serde(
32496 default,
32497 skip_serializing_if = "String::is_empty",
32498 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32499 )]
32500 pub download_url: String,
32501 #[serde(
32505 default,
32506 skip_serializing_if = "crate::utils::zero_i64",
32507 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
32508 )]
32509 pub duration: i64,
32510 #[serde(
32514 default,
32515 skip_serializing_if = "String::is_empty",
32516 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32517 )]
32518 pub id: String,
32519}
32520
32521#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32522pub struct GetCallQueueRecordingsResponseData {
32523 #[serde(
32527 default,
32528 skip_serializing_if = "String::is_empty",
32529 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32530 )]
32531 pub from: String,
32532 #[serde(
32536 default,
32537 skip_serializing_if = "String::is_empty",
32538 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32539 )]
32540 pub next_page_token: String,
32541 #[serde(
32545 default,
32546 skip_serializing_if = "crate::utils::zero_i64",
32547 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
32548 )]
32549 pub page_size: i64,
32550 #[serde(
32551 default,
32552 skip_serializing_if = "Vec::is_empty",
32553 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
32554 )]
32555 pub recordings: Vec<GetCallQueueRecordingsResponse>,
32556 #[serde(
32560 default,
32561 skip_serializing_if = "String::is_empty",
32562 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32563 )]
32564 pub to: String,
32565 #[serde(
32569 default,
32570 skip_serializing_if = "String::is_empty",
32571 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32572 )]
32573 pub total_records: String,
32574}
32575
32576#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32577pub struct Params {
32578 #[serde(
32582 default,
32583 skip_serializing_if = "String::is_empty",
32584 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32585 )]
32586 pub calendar_id: String,
32587 #[serde(
32591 default,
32592 skip_serializing_if = "String::is_empty",
32593 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32594 )]
32595 pub change_key: String,
32596 #[serde(
32600 default,
32601 skip_serializing_if = "String::is_empty",
32602 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32603 )]
32604 pub event_id: String,
32605 #[serde(
32609 default,
32610 skip_serializing_if = "String::is_empty",
32611 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32612 )]
32613 pub resource_email: String,
32614}
32615
32616#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32617pub struct CheckInRoomsRequest {
32618 #[serde(
32622 default,
32623 skip_serializing_if = "String::is_empty",
32624 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32625 )]
32626 pub method: String,
32627 #[serde(default, skip_serializing_if = "Option::is_none")]
32628 pub params: Option<Params>,
32629}
32630
32631#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32632pub struct InMeetingRecordingControlRequest {
32633 #[serde(
32637 default,
32638 skip_serializing_if = "String::is_empty",
32639 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32640 )]
32641 pub method: String,
32642}
32643
32644#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32645pub struct ListSipTrunksResponse {
32646 #[serde(
32650 default,
32651 skip_serializing_if = "String::is_empty",
32652 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32653 )]
32654 pub dnis: String,
32655 #[serde(
32659 default,
32660 skip_serializing_if = "String::is_empty",
32661 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32662 )]
32663 pub id: String,
32664 #[serde(
32668 default,
32669 skip_serializing_if = "String::is_empty",
32670 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32671 )]
32672 pub name: String,
32673 #[serde(
32677 default,
32678 skip_serializing_if = "String::is_empty",
32679 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32680 )]
32681 pub number_prefix: String,
32682 #[serde(
32686 default,
32687 skip_serializing_if = "String::is_empty",
32688 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32689 )]
32690 pub outbound_caller_id: String,
32691 #[serde(
32695 default,
32696 skip_serializing_if = "String::is_empty",
32697 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32698 )]
32699 pub sip_server_address: String,
32700}
32701
32702#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32703pub struct ListSipTrunksResponseData {
32704 #[serde(
32705 default,
32706 skip_serializing_if = "Vec::is_empty",
32707 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
32708 )]
32709 pub sip_trunks: Vec<ListSipTrunksResponse>,
32710 #[serde(
32714 default,
32715 skip_serializing_if = "crate::utils::zero_i64",
32716 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
32717 )]
32718 pub total_records: i64,
32719}
32720
32721#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32722pub struct AssignSipTrunksRequest {
32723 #[serde(
32727 default,
32728 skip_serializing_if = "String::is_empty",
32729 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32730 )]
32731 pub dnis: String,
32732 #[serde(
32736 default,
32737 skip_serializing_if = "String::is_empty",
32738 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32739 )]
32740 pub id: String,
32741 #[serde(
32745 default,
32746 skip_serializing_if = "String::is_empty",
32747 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32748 )]
32749 pub outbound_caller_id: String,
32750}
32751
32752#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32753pub struct AssignSipTrunksRequestData {
32754 #[serde(
32758 default,
32759 skip_serializing_if = "Vec::is_empty",
32760 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
32761 )]
32762 pub sip_trunks: Vec<AssignSipTrunksRequest>,
32763}
32764
32765#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32766pub struct AssignSipTrunksResponse {
32767 #[serde(
32771 default,
32772 skip_serializing_if = "String::is_empty",
32773 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32774 )]
32775 pub dnis: String,
32776 #[serde(
32780 default,
32781 skip_serializing_if = "String::is_empty",
32782 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32783 )]
32784 pub id: String,
32785 #[serde(
32789 default,
32790 skip_serializing_if = "String::is_empty",
32791 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32792 )]
32793 pub name: String,
32794 #[serde(
32798 default,
32799 skip_serializing_if = "String::is_empty",
32800 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32801 )]
32802 pub number_prefix: String,
32803 #[serde(
32807 default,
32808 skip_serializing_if = "String::is_empty",
32809 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32810 )]
32811 pub sip_server_address: String,
32812}
32813
32814#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32815pub struct AssignSipTrunksResponseData {
32816 #[serde(
32817 default,
32818 skip_serializing_if = "Vec::is_empty",
32819 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
32820 )]
32821 pub sip_trunks: Vec<AssignSipTrunksResponse>,
32822}
32823
32824#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32825pub struct CalloutCountries {
32826 #[serde(
32830 default,
32831 skip_serializing_if = "String::is_empty",
32832 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32833 )]
32834 pub code: String,
32835 #[serde(
32839 default,
32840 skip_serializing_if = "String::is_empty",
32841 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32842 )]
32843 pub id: String,
32844 #[serde(
32848 default,
32849 skip_serializing_if = "String::is_empty",
32850 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32851 )]
32852 pub name: String,
32853}
32854
32855#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32856pub struct ListInternalCalloutCountriesResponse {
32857 #[serde(
32858 default,
32859 skip_serializing_if = "Vec::is_empty",
32860 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
32861 )]
32862 pub callout_countries: Vec<CalloutCountries>,
32863 #[serde(
32867 default,
32868 skip_serializing_if = "crate::utils::zero_i64",
32869 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
32870 )]
32871 pub total_records: i64,
32872}
32873
32874#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32875pub struct AddCalloutCountriesRequest {
32876 #[serde(
32880 default,
32881 skip_serializing_if = "String::is_empty",
32882 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32883 )]
32884 pub id: String,
32885}
32886
32887#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32888pub struct AddCalloutCountriesRequestData {
32889 #[serde(
32893 default,
32894 skip_serializing_if = "Vec::is_empty",
32895 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
32896 )]
32897 pub callout_countries: Vec<AddCalloutCountriesRequest>,
32898}
32899
32900#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32901pub struct AddCalloutCountriesResponse {
32902 #[serde(
32903 default,
32904 skip_serializing_if = "Vec::is_empty",
32905 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
32906 )]
32907 pub callout_countries: Vec<CalloutCountries>,
32908}
32909
32910#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
32914pub enum Languages {
32915 #[serde(rename = "de-DE")]
32916 De,
32917 #[serde(rename = "en-GB")]
32918 EnGb,
32919 #[serde(rename = "en-US")]
32920 EnUs,
32921 #[serde(rename = "")]
32922 #[default]
32923 Noop,
32924 #[serde(other)]
32925 FallthroughString,
32926}
32927
32928impl std::fmt::Display for Languages {
32929 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
32930 match self {
32931 Languages::De => "de-DE",
32932 Languages::EnGb => "en-GB",
32933 Languages::EnUs => "en-US",
32934 Languages::Noop => "",
32935 Languages::FallthroughString => "*",
32936 }
32937 .fmt(f)
32938 }
32939}
32940
32941impl Languages {
32942 pub fn is_noop(&self) -> bool {
32943 matches!(self, Languages::Noop)
32944 }
32945}
32946
32947#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
32948pub struct InternalNumbers {
32949 #[serde(
32953 default,
32954 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
32955 )]
32956 pub allow_for_external_meetings: bool,
32957 #[serde(
32961 default,
32962 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
32963 )]
32964 pub allow_join: bool,
32965 #[serde(
32969 default,
32970 skip_serializing_if = "String::is_empty",
32971 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32972 )]
32973 pub country: String,
32974 #[serde(
32978 default,
32979 skip_serializing_if = "String::is_empty",
32980 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32981 )]
32982 pub display_number: String,
32983 #[serde(
32987 default,
32988 skip_serializing_if = "String::is_empty",
32989 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
32990 )]
32991 pub labels: String,
32992 #[serde(default, skip_serializing_if = "Languages::is_noop")]
32996 pub languages: Languages,
32997 #[serde(
33001 default,
33002 skip_serializing_if = "String::is_empty",
33003 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33004 )]
33005 pub number: String,
33006 #[serde(
33010 default,
33011 skip_serializing_if = "crate::utils::zero_i64",
33012 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
33013 rename = "type"
33014 )]
33015 pub type_: i64,
33016 #[serde(
33020 default,
33021 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
33022 )]
33023 pub visible: bool,
33024}
33025
33026#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33027pub struct ListInternalNumbersResponse {
33028 #[serde(
33029 default,
33030 skip_serializing_if = "Vec::is_empty",
33031 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
33032 )]
33033 pub internal_numbers: Vec<InternalNumbers>,
33034 #[serde(
33038 default,
33039 skip_serializing_if = "String::is_empty",
33040 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33041 )]
33042 pub next_page_token: String,
33043 #[serde(
33047 default,
33048 skip_serializing_if = "crate::utils::zero_i64",
33049 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
33050 )]
33051 pub page_size: i64,
33052 #[serde(
33056 default,
33057 skip_serializing_if = "crate::utils::zero_i64",
33058 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
33059 )]
33060 pub total_records: i64,
33061}
33062
33063#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33064pub struct AddInternalNumbersRequest {
33065 #[serde(
33066 default,
33067 skip_serializing_if = "Vec::is_empty",
33068 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
33069 )]
33070 pub internal_numbers: Vec<InternalNumbers>,
33071}
33072
33073#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33074pub struct AddInternalNumbersResponse {
33075 #[serde(
33079 default,
33080 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
33081 )]
33082 pub allow_for_external_meetings: bool,
33083 #[serde(
33087 default,
33088 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
33089 )]
33090 pub allow_join: bool,
33091 #[serde(
33095 default,
33096 skip_serializing_if = "String::is_empty",
33097 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33098 )]
33099 pub country: String,
33100 #[serde(
33104 default,
33105 skip_serializing_if = "String::is_empty",
33106 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33107 )]
33108 pub display_number: String,
33109 #[serde(
33113 default,
33114 skip_serializing_if = "String::is_empty",
33115 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33116 )]
33117 pub id: String,
33118 #[serde(
33122 default,
33123 skip_serializing_if = "String::is_empty",
33124 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33125 )]
33126 pub labels: String,
33127 #[serde(default, skip_serializing_if = "Languages::is_noop")]
33131 pub languages: Languages,
33132 #[serde(
33136 default,
33137 skip_serializing_if = "String::is_empty",
33138 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33139 )]
33140 pub number: String,
33141 #[serde(
33145 default,
33146 skip_serializing_if = "crate::utils::zero_i64",
33147 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
33148 rename = "type"
33149 )]
33150 pub type_: i64,
33151 #[serde(
33155 default,
33156 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
33157 )]
33158 pub visible: bool,
33159}
33160
33161#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33162pub struct AddInternalNumbersResponseData {
33163 #[serde(
33164 default,
33165 skip_serializing_if = "Vec::is_empty",
33166 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
33167 )]
33168 pub internal_numbers: Vec<AddInternalNumbersResponse>,
33169}
33170
33171#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
33179pub enum ChangeZoomRoomsAppVersionRequestAction {
33180 #[serde(rename = "cancel")]
33181 Cancel,
33182 #[serde(rename = "downgrade")]
33183 Downgrade,
33184 #[serde(rename = "upgrade")]
33185 Upgrade,
33186 #[serde(rename = "")]
33187 #[default]
33188 Noop,
33189 #[serde(other)]
33190 FallthroughString,
33191}
33192
33193impl std::fmt::Display for ChangeZoomRoomsAppVersionRequestAction {
33194 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
33195 match self {
33196 ChangeZoomRoomsAppVersionRequestAction::Cancel => "cancel",
33197 ChangeZoomRoomsAppVersionRequestAction::Downgrade => "downgrade",
33198 ChangeZoomRoomsAppVersionRequestAction::Upgrade => "upgrade",
33199 ChangeZoomRoomsAppVersionRequestAction::Noop => "",
33200 ChangeZoomRoomsAppVersionRequestAction::FallthroughString => "*",
33201 }
33202 .fmt(f)
33203 }
33204}
33205
33206impl ChangeZoomRoomsAppVersionRequestAction {
33207 pub fn is_noop(&self) -> bool {
33208 matches!(self, ChangeZoomRoomsAppVersionRequestAction::Noop)
33209 }
33210}
33211
33212#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33213pub struct ChangeZoomRoomsAppVersionRequest {
33214 #[serde(default, skip_serializing_if = "Option::is_none")]
33222 pub action: Option<ChangeZoomRoomsAppVersionRequestAction>,
33223}
33224
33225#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33226pub struct ListDigitalSignageContentResponse {
33227 #[serde(
33228 default,
33229 skip_serializing_if = "Vec::is_empty",
33230 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
33231 )]
33232 pub contents: Vec<Site>,
33233 #[serde(
33237 default,
33238 skip_serializing_if = "String::is_empty",
33239 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33240 )]
33241 pub next_page_token: String,
33242 #[serde(
33246 default,
33247 skip_serializing_if = "crate::utils::zero_i64",
33248 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
33249 )]
33250 pub page_size: i64,
33251}
33252
33253#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33254pub struct ListWebinarTemplatesResponse {
33255 #[serde(
33256 default,
33257 skip_serializing_if = "Vec::is_empty",
33258 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
33259 )]
33260 pub templates: Vec<Site>,
33261 #[serde(
33265 default,
33266 skip_serializing_if = "crate::utils::zero_i64",
33267 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
33268 )]
33269 pub total_records: i64,
33270}
33271
33272#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
33293pub enum UpdatePresenceStatusRequest {
33294 #[serde(rename = "Available")]
33295 Available,
33296 #[serde(rename = "Away")]
33297 Away,
33298 #[serde(rename = "Do_No_Disturb")]
33299 DoNoDisturb,
33300 #[serde(rename = "In_A_Zoom_Meeting")]
33301 InAZoomMeeting,
33302 #[serde(rename = "In_Calendar_Event")]
33303 InCalendarEvent,
33304 #[serde(rename = "On_A_Call")]
33305 OnACall,
33306 #[serde(rename = "Presenting")]
33307 Presenting,
33308 #[serde(rename = "")]
33309 #[default]
33310 Noop,
33311 #[serde(other)]
33312 FallthroughString,
33313}
33314
33315impl std::fmt::Display for UpdatePresenceStatusRequest {
33316 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
33317 match self {
33318 UpdatePresenceStatusRequest::Available => "Available",
33319 UpdatePresenceStatusRequest::Away => "Away",
33320 UpdatePresenceStatusRequest::DoNoDisturb => "Do_No_Disturb",
33321 UpdatePresenceStatusRequest::InAZoomMeeting => "In_A_Zoom_Meeting",
33322 UpdatePresenceStatusRequest::InCalendarEvent => "In_Calendar_Event",
33323 UpdatePresenceStatusRequest::OnACall => "On_A_Call",
33324 UpdatePresenceStatusRequest::Presenting => "Presenting",
33325 UpdatePresenceStatusRequest::Noop => "",
33326 UpdatePresenceStatusRequest::FallthroughString => "*",
33327 }
33328 .fmt(f)
33329 }
33330}
33331
33332impl UpdatePresenceStatusRequest {
33333 pub fn is_noop(&self) -> bool {
33334 matches!(self, UpdatePresenceStatusRequest::Noop)
33335 }
33336}
33337
33338#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33339pub struct UpdatePresenceStatusRequestData {
33340 #[serde(
33344 default,
33345 skip_serializing_if = "crate::utils::zero_i64",
33346 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
33347 )]
33348 pub duration: i64,
33349 #[serde(default, skip_serializing_if = "Option::is_none")]
33370 pub status: Option<UpdatePresenceStatusRequest>,
33371}
33372
33373#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33375pub struct Caller {
33376 #[serde(
33380 default,
33381 skip_serializing_if = "String::is_empty",
33382 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33383 )]
33384 pub codec: String,
33385 #[serde(
33389 default,
33390 skip_serializing_if = "String::is_empty",
33391 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33392 )]
33393 pub device_private_ip: String,
33394 #[serde(
33398 default,
33399 skip_serializing_if = "String::is_empty",
33400 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33401 )]
33402 pub device_public_ip: String,
33403 #[serde(
33407 default,
33408 skip_serializing_if = "String::is_empty",
33409 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33410 )]
33411 pub device_type: String,
33412 #[serde(
33416 default,
33417 skip_serializing_if = "String::is_empty",
33418 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33419 )]
33420 pub extension_number: String,
33421 #[serde(
33425 default,
33426 skip_serializing_if = "String::is_empty",
33427 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33428 )]
33429 pub headset: String,
33430 #[serde(
33434 default,
33435 skip_serializing_if = "String::is_empty",
33436 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33437 )]
33438 pub isp: String,
33439 #[serde(
33443 default,
33444 skip_serializing_if = "String::is_empty",
33445 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33446 )]
33447 pub microphone: String,
33448 #[serde(
33452 default,
33453 skip_serializing_if = "String::is_empty",
33454 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33455 )]
33456 pub phone_number: String,
33457 #[serde(
33461 default,
33462 skip_serializing_if = "String::is_empty",
33463 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33464 )]
33465 pub site_id: String,
33466}
33467
33468#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33470pub struct Callee {
33471 #[serde(
33475 default,
33476 skip_serializing_if = "String::is_empty",
33477 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33478 )]
33479 pub codec: String,
33480 #[serde(
33484 default,
33485 skip_serializing_if = "String::is_empty",
33486 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33487 )]
33488 pub device_private_ip: String,
33489 #[serde(
33493 default,
33494 skip_serializing_if = "String::is_empty",
33495 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33496 )]
33497 pub device_public_ip: String,
33498 #[serde(
33502 default,
33503 skip_serializing_if = "String::is_empty",
33504 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33505 )]
33506 pub device_type: String,
33507 #[serde(
33511 default,
33512 skip_serializing_if = "String::is_empty",
33513 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33514 )]
33515 pub extension_number: String,
33516 #[serde(
33520 default,
33521 skip_serializing_if = "String::is_empty",
33522 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33523 )]
33524 pub headset: String,
33525 #[serde(
33529 default,
33530 skip_serializing_if = "String::is_empty",
33531 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33532 )]
33533 pub isp: String,
33534 #[serde(
33538 default,
33539 skip_serializing_if = "String::is_empty",
33540 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33541 )]
33542 pub microphone: String,
33543 #[serde(
33547 default,
33548 skip_serializing_if = "String::is_empty",
33549 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33550 )]
33551 pub phone_number: String,
33552 #[serde(
33556 default,
33557 skip_serializing_if = "String::is_empty",
33558 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33559 )]
33560 pub site_id: String,
33561}
33562
33563#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33564pub struct ListCallLogsMetricsResponse {
33565 #[serde(
33569 default,
33570 skip_serializing_if = "String::is_empty",
33571 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33572 )]
33573 pub call_id: String,
33574 #[serde(default, skip_serializing_if = "Option::is_none")]
33578 pub callee: Option<Callee>,
33579 #[serde(default, skip_serializing_if = "Option::is_none")]
33583 pub caller: Option<Caller>,
33584 #[serde(
33588 default,
33589 skip_serializing_if = "Option::is_none",
33590 deserialize_with = "crate::utils::date_format::deserialize"
33591 )]
33592 pub date_time: Option<chrono::NaiveDate>,
33593 #[serde(
33597 default,
33598 skip_serializing_if = "String::is_empty",
33599 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33600 )]
33601 pub direction: String,
33602 #[serde(
33606 default,
33607 skip_serializing_if = "crate::utils::zero_i64",
33608 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
33609 )]
33610 pub duration: i64,
33611 #[serde(
33615 default,
33616 skip_serializing_if = "String::is_empty",
33617 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33618 )]
33619 pub mos: String,
33620}
33621
33622#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33623pub struct ListCallLogsMetricsResponseData {
33624 #[serde(
33628 default,
33629 skip_serializing_if = "Vec::is_empty",
33630 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
33631 )]
33632 pub call_logs: Vec<ListCallLogsMetricsResponse>,
33633 #[serde(
33637 default,
33638 skip_serializing_if = "String::is_empty",
33639 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33640 )]
33641 pub from: String,
33642 #[serde(
33646 default,
33647 skip_serializing_if = "String::is_empty",
33648 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33649 )]
33650 pub next_page_token: String,
33651 #[serde(
33655 default,
33656 skip_serializing_if = "crate::utils::zero_i64",
33657 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
33658 )]
33659 pub page_size: i64,
33660 #[serde(
33664 default,
33665 skip_serializing_if = "String::is_empty",
33666 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33667 )]
33668 pub to: String,
33669 #[serde(
33673 default,
33674 skip_serializing_if = "crate::utils::zero_i64",
33675 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
33676 )]
33677 pub total_records: i64,
33678}
33679
33680#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33681pub struct Qos {
33682 #[serde(
33686 default,
33687 skip_serializing_if = "String::is_empty",
33688 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33689 )]
33690 pub avg_loss: String,
33691 #[serde(
33695 default,
33696 skip_serializing_if = "String::is_empty",
33697 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33698 )]
33699 pub bitrate: String,
33700 #[serde(
33704 default,
33705 skip_serializing_if = "String::is_empty",
33706 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33707 )]
33708 pub jitter: String,
33709 #[serde(
33713 default,
33714 skip_serializing_if = "String::is_empty",
33715 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33716 )]
33717 pub max_loss: String,
33718 #[serde(
33722 default,
33723 skip_serializing_if = "String::is_empty",
33724 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33725 )]
33726 pub mos: String,
33727 #[serde(
33731 default,
33732 skip_serializing_if = "String::is_empty",
33733 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33734 )]
33735 pub network_delay: String,
33736}
33737
33738#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33739pub struct Sending {
33740 #[serde(
33744 default,
33745 skip_serializing_if = "Option::is_none",
33746 deserialize_with = "crate::utils::date_time_format::deserialize"
33747 )]
33748 pub date_time: Option<chrono::DateTime<chrono::Utc>>,
33749 #[serde(default, skip_serializing_if = "Option::is_none")]
33750 pub qos: Option<Qos>,
33751}
33752
33753#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33755pub struct CallerQos {
33756 #[serde(
33760 default,
33761 skip_serializing_if = "String::is_empty",
33762 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33763 )]
33764 pub device_private_ip: String,
33765 #[serde(
33769 default,
33770 skip_serializing_if = "String::is_empty",
33771 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33772 )]
33773 pub device_public_ip: String,
33774 #[serde(
33778 default,
33779 skip_serializing_if = "Vec::is_empty",
33780 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
33781 )]
33782 pub receiving: Vec<Sending>,
33783 #[serde(
33787 default,
33788 skip_serializing_if = "Vec::is_empty",
33789 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
33790 )]
33791 pub sending: Vec<Sending>,
33792}
33793
33794#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33795pub struct CalleeQos {
33796 #[serde(
33800 default,
33801 skip_serializing_if = "String::is_empty",
33802 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33803 )]
33804 pub device_private_ip: String,
33805 #[serde(
33809 default,
33810 skip_serializing_if = "String::is_empty",
33811 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33812 )]
33813 pub device_public_ip: String,
33814 #[serde(
33818 default,
33819 skip_serializing_if = "Vec::is_empty",
33820 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
33821 )]
33822 pub receiving: Vec<Sending>,
33823 #[serde(
33827 default,
33828 skip_serializing_if = "Vec::is_empty",
33829 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
33830 )]
33831 pub sending: Vec<Sending>,
33832}
33833
33834#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33835pub struct GetCallQoSResponse {
33836 #[serde(
33840 default,
33841 skip_serializing_if = "String::is_empty",
33842 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33843 )]
33844 pub call_id: String,
33845 #[serde(default, skip_serializing_if = "Option::is_none")]
33846 pub callee_qos: Option<CalleeQos>,
33847 #[serde(default, skip_serializing_if = "Option::is_none")]
33851 pub caller_qos: Option<CallerQos>,
33852}
33853
33854#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33855pub struct CreateBatchPollsRequest {
33856 #[serde(
33860 default,
33861 skip_serializing_if = "Vec::is_empty",
33862 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
33863 )]
33864 pub questions: Vec<Questions>,
33865 #[serde(
33869 default,
33870 skip_serializing_if = "String::is_empty",
33871 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33872 )]
33873 pub title: String,
33874}
33875
33876#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33877pub struct Polls {
33878 #[serde(
33882 default,
33883 skip_serializing_if = "String::is_empty",
33884 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33885 )]
33886 pub id: String,
33887 #[serde(
33891 default,
33892 skip_serializing_if = "Vec::is_empty",
33893 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
33894 )]
33895 pub questions: Vec<Questions>,
33896 #[serde(default, skip_serializing_if = "Option::is_none")]
33900 pub status: Option<MeetingPollCreateResponseStatus>,
33901 #[serde(
33905 default,
33906 skip_serializing_if = "String::is_empty",
33907 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33908 )]
33909 pub title: String,
33910}
33911
33912#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33913pub struct CreateBatchPollsResponse {
33914 #[serde(
33915 default,
33916 skip_serializing_if = "Vec::is_empty",
33917 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
33918 )]
33919 pub polls: Vec<Polls>,
33920}
33921
33922#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33923pub struct ManageE911SignageResponse {
33924 #[serde(
33928 default,
33929 skip_serializing_if = "String::is_empty",
33930 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33931 )]
33932 pub event_id: String,
33933}
33934
33935#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
33936pub struct AccountBillingInvoicesResponse {
33937 #[serde(
33941 default,
33942 skip_serializing_if = "crate::utils::zero_f64",
33943 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
33944 )]
33945 pub balance: f64,
33946 #[serde(
33950 default,
33951 skip_serializing_if = "Option::is_none",
33952 deserialize_with = "crate::utils::date_format::deserialize"
33953 )]
33954 pub due_date: Option<chrono::NaiveDate>,
33955 #[serde(
33959 default,
33960 skip_serializing_if = "String::is_empty",
33961 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33962 )]
33963 pub id: String,
33964 #[serde(
33968 default,
33969 skip_serializing_if = "Option::is_none",
33970 deserialize_with = "crate::utils::date_format::deserialize"
33971 )]
33972 pub invoice_date: Option<chrono::NaiveDate>,
33973 #[serde(
33977 default,
33978 skip_serializing_if = "String::is_empty",
33979 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33980 )]
33981 pub invoice_number: String,
33982 #[serde(
33986 default,
33987 skip_serializing_if = "String::is_empty",
33988 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
33989 )]
33990 pub status: String,
33991 #[serde(
33995 default,
33996 skip_serializing_if = "Option::is_none",
33997 deserialize_with = "crate::utils::date_format::deserialize"
33998 )]
33999 pub target_date: Option<chrono::NaiveDate>,
34000 #[serde(
34004 default,
34005 skip_serializing_if = "crate::utils::zero_f64",
34006 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
34007 )]
34008 pub tax_amount: f64,
34009 #[serde(
34013 default,
34014 skip_serializing_if = "crate::utils::zero_f64",
34015 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
34016 )]
34017 pub total_amount: f64,
34018}
34019
34020#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
34021pub struct AccountBillingInvoicesResponseData {
34022 #[serde(
34026 default,
34027 skip_serializing_if = "String::is_empty",
34028 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34029 )]
34030 pub currency: String,
34031 #[serde(
34032 default,
34033 skip_serializing_if = "Vec::is_empty",
34034 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
34035 )]
34036 pub invoices: Vec<AccountBillingInvoicesResponse>,
34037}
34038
34039#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
34040pub struct InvoiceItems {
34041 #[serde(
34045 default,
34046 skip_serializing_if = "String::is_empty",
34047 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34048 )]
34049 pub charge_name: String,
34050 #[serde(
34054 default,
34055 skip_serializing_if = "String::is_empty",
34056 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34057 )]
34058 pub charge_number: String,
34059 #[serde(
34063 default,
34064 skip_serializing_if = "String::is_empty",
34065 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34066 )]
34067 pub charge_type: String,
34068 #[serde(
34072 default,
34073 skip_serializing_if = "Option::is_none",
34074 deserialize_with = "crate::utils::date_format::deserialize"
34075 )]
34076 pub end_date: Option<chrono::NaiveDate>,
34077 #[serde(
34081 default,
34082 skip_serializing_if = "crate::utils::zero_i64",
34083 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
34084 )]
34085 pub quantity: i64,
34086 #[serde(
34090 default,
34091 skip_serializing_if = "Option::is_none",
34092 deserialize_with = "crate::utils::date_format::deserialize"
34093 )]
34094 pub start_date: Option<chrono::NaiveDate>,
34095 #[serde(
34099 default,
34100 skip_serializing_if = "crate::utils::zero_f64",
34101 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
34102 )]
34103 pub tax_amount: f64,
34104 #[serde(
34108 default,
34109 skip_serializing_if = "crate::utils::zero_f64",
34110 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
34111 )]
34112 pub total_amount: f64,
34113}
34114
34115#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
34116pub struct GetAccountBillingInvoiceResponse {
34117 #[serde(
34121 default,
34122 skip_serializing_if = "crate::utils::zero_f64",
34123 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
34124 )]
34125 pub balance: f64,
34126 #[serde(
34130 default,
34131 skip_serializing_if = "String::is_empty",
34132 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34133 )]
34134 pub currency: String,
34135 #[serde(
34139 default,
34140 skip_serializing_if = "Option::is_none",
34141 deserialize_with = "crate::utils::date_format::deserialize"
34142 )]
34143 pub due_date: Option<chrono::NaiveDate>,
34144 #[serde(
34148 default,
34149 skip_serializing_if = "String::is_empty",
34150 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34151 )]
34152 pub id: String,
34153 #[serde(
34157 default,
34158 skip_serializing_if = "Option::is_none",
34159 deserialize_with = "crate::utils::date_format::deserialize"
34160 )]
34161 pub invoice_date: Option<chrono::NaiveDate>,
34162 #[serde(
34163 default,
34164 skip_serializing_if = "Vec::is_empty",
34165 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
34166 )]
34167 pub invoice_items: Vec<InvoiceItems>,
34168 #[serde(
34172 default,
34173 skip_serializing_if = "String::is_empty",
34174 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34175 )]
34176 pub invoice_number: String,
34177 #[serde(
34181 default,
34182 skip_serializing_if = "String::is_empty",
34183 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34184 )]
34185 pub status: String,
34186 #[serde(
34190 default,
34191 skip_serializing_if = "Option::is_none",
34192 deserialize_with = "crate::utils::date_format::deserialize"
34193 )]
34194 pub target_date: Option<chrono::NaiveDate>,
34195 #[serde(
34199 default,
34200 skip_serializing_if = "crate::utils::zero_f64",
34201 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
34202 )]
34203 pub tax_amount: f64,
34204 #[serde(
34208 default,
34209 skip_serializing_if = "crate::utils::zero_f64",
34210 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
34211 )]
34212 pub total_amount: f64,
34213}
34214
34215#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
34222pub enum Quality {
34223 #[serde(rename = "GOOD")]
34224 Good,
34225 #[serde(rename = "NOT GOOD")]
34226 NotGood,
34227 #[serde(rename = "")]
34228 #[default]
34229 Noop,
34230 #[serde(other)]
34231 FallthroughString,
34232}
34233
34234impl std::fmt::Display for Quality {
34235 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
34236 match self {
34237 Quality::Good => "GOOD",
34238 Quality::NotGood => "NOT GOOD",
34239 Quality::Noop => "",
34240 Quality::FallthroughString => "*",
34241 }
34242 .fmt(f)
34243 }
34244}
34245
34246impl Quality {
34247 pub fn is_noop(&self) -> bool {
34248 matches!(self, Quality::Noop)
34249 }
34250}
34251
34252#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
34253pub struct ParticipantFeedbackResponseParticipants {
34254 #[serde(
34258 default,
34259 skip_serializing_if = "Option::is_none",
34260 deserialize_with = "crate::utils::date_time_format::deserialize"
34261 )]
34262 pub date_time: Option<chrono::DateTime<chrono::Utc>>,
34263 #[serde(
34267 default,
34268 skip_serializing_if = "String::is_empty",
34269 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34270 )]
34271 pub email: String,
34272 #[serde(default, skip_serializing_if = "Option::is_none")]
34279 pub quality: Option<Quality>,
34280 #[serde(
34284 default,
34285 skip_serializing_if = "String::is_empty",
34286 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34287 )]
34288 pub user_id: String,
34289}
34290
34291#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
34292pub struct ParticipantFeedbackResponse {
34293 #[serde(
34297 default,
34298 skip_serializing_if = "String::is_empty",
34299 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34300 )]
34301 pub next_page_token: String,
34302 #[serde(
34306 default,
34307 skip_serializing_if = "crate::utils::zero_i64",
34308 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
34309 )]
34310 pub page_size: i64,
34311 #[serde(
34312 default,
34313 skip_serializing_if = "Vec::is_empty",
34314 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
34315 )]
34316 pub participants: Vec<ParticipantFeedbackResponseParticipants>,
34317}
34318
34319#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
34323pub enum Result {
34324 #[serde(rename = "call_connected")]
34325 CallConnected,
34326 #[serde(rename = "no_answer")]
34327 NoAnswer,
34328 #[serde(rename = "recorded")]
34329 Recorded,
34330 #[serde(rename = "")]
34331 #[default]
34332 Noop,
34333 #[serde(other)]
34334 FallthroughString,
34335}
34336
34337impl std::fmt::Display for Result {
34338 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
34339 match self {
34340 Result::CallConnected => "call_connected",
34341 Result::NoAnswer => "no_answer",
34342 Result::Recorded => "recorded",
34343 Result::Noop => "",
34344 Result::FallthroughString => "*",
34345 }
34346 .fmt(f)
34347 }
34348}
34349
34350impl Result {
34351 pub fn is_noop(&self) -> bool {
34352 matches!(self, Result::Noop)
34353 }
34354}
34355
34356#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
34357pub struct ForwardTo {
34358 #[serde(
34362 default,
34363 skip_serializing_if = "String::is_empty",
34364 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34365 )]
34366 pub extension_number: String,
34367 #[serde(
34371 default,
34372 skip_serializing_if = "String::is_empty",
34373 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34374 )]
34375 pub id: String,
34376 #[serde(
34380 default,
34381 skip_serializing_if = "String::is_empty",
34382 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34383 )]
34384 pub name: String,
34385 #[serde(
34389 default,
34390 skip_serializing_if = "String::is_empty",
34391 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
34392 rename = "type"
34393 )]
34394 pub type_: String,
34395}
34396
34397#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
34398pub struct LogDetails {
34399 #[serde(
34403 default,
34404 skip_serializing_if = "Option::is_none",
34405 deserialize_with = "crate::utils::date_format::deserialize"
34406 )]
34407 pub date_time: Option<chrono::NaiveDate>,
34408 #[serde(
34412 default,
34413 skip_serializing_if = "String::is_empty",
34414 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34415 )]
34416 pub device_private_ip: String,
34417 #[serde(
34421 default,
34422 skip_serializing_if = "String::is_empty",
34423 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34424 )]
34425 pub device_public_ip: String,
34426 #[serde(
34430 default,
34431 skip_serializing_if = "crate::utils::zero_i64",
34432 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
34433 )]
34434 pub duration: i64,
34435 #[serde(default, skip_serializing_if = "Option::is_none")]
34436 pub forward_to: Option<ForwardTo>,
34437 #[serde(
34441 default,
34442 skip_serializing_if = "String::is_empty",
34443 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34444 )]
34445 pub id: String,
34446 #[serde(
34450 default,
34451 skip_serializing_if = "String::is_empty",
34452 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34453 )]
34454 pub path: String,
34455 #[serde(default, skip_serializing_if = "Option::is_none")]
34459 pub result: Option<Result>,
34460 #[serde(default, skip_serializing_if = "Option::is_none")]
34461 pub site: Option<Site>,
34462}
34463
34464#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
34465pub struct GetCallLogDetailsResponse {
34466 #[serde(
34470 default,
34471 skip_serializing_if = "String::is_empty",
34472 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34473 )]
34474 pub call_id: String,
34475 #[serde(default, skip_serializing_if = "Option::is_none")]
34484 pub call_type: Option<CallType>,
34485 #[serde(
34489 default,
34490 skip_serializing_if = "String::is_empty",
34491 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34492 )]
34493 pub callee_name: String,
34494 #[serde(
34498 default,
34499 skip_serializing_if = "String::is_empty",
34500 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34501 )]
34502 pub callee_number: String,
34503 #[serde(default, skip_serializing_if = "Option::is_none")]
34508 pub callee_number_type: Option<serde_json::Value>,
34509 #[serde(
34513 default,
34514 skip_serializing_if = "String::is_empty",
34515 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34516 )]
34517 pub caller_name: String,
34518 #[serde(
34522 default,
34523 skip_serializing_if = "String::is_empty",
34524 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34525 )]
34526 pub caller_number: String,
34527 #[serde(
34531 default,
34532 skip_serializing_if = "String::is_empty",
34533 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34534 )]
34535 pub caller_number_type: String,
34536 #[serde(
34540 default,
34541 skip_serializing_if = "Option::is_none",
34542 deserialize_with = "crate::utils::date_format::deserialize"
34543 )]
34544 pub date_time: Option<chrono::NaiveDate>,
34545 #[serde(
34549 default,
34550 skip_serializing_if = "String::is_empty",
34551 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34552 )]
34553 pub device_private_ip: String,
34554 #[serde(
34558 default,
34559 skip_serializing_if = "String::is_empty",
34560 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34561 )]
34562 pub device_public_ip: String,
34563 #[serde(default, skip_serializing_if = "Option::is_none")]
34567 pub direction: Option<Direction>,
34568 #[serde(
34572 default,
34573 skip_serializing_if = "crate::utils::zero_i64",
34574 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
34575 )]
34576 pub duration: i64,
34577 #[serde(
34581 default,
34582 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
34583 )]
34584 pub has_recording: bool,
34585 #[serde(
34589 default,
34590 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
34591 )]
34592 pub has_voicemail: bool,
34593 #[serde(
34597 default,
34598 skip_serializing_if = "String::is_empty",
34599 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34600 )]
34601 pub id: String,
34602 #[serde(
34606 default,
34607 skip_serializing_if = "Vec::is_empty",
34608 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
34609 )]
34610 pub log_details: Vec<LogDetails>,
34611 #[serde(
34615 default,
34616 skip_serializing_if = "String::is_empty",
34617 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34618 )]
34619 pub path: String,
34620 #[serde(default, skip_serializing_if = "Option::is_none")]
34624 pub result: Option<Result>,
34625}
34626
34627#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
34628pub struct AddByocNumberRequest {
34629 #[serde(
34633 default,
34634 skip_serializing_if = "String::is_empty",
34635 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34636 )]
34637 pub carrier: String,
34638 #[serde(
34645 default,
34646 skip_serializing_if = "Vec::is_empty",
34647 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
34648 )]
34649 pub phone_numbers: Vec<String>,
34650 #[serde(
34654 default,
34655 skip_serializing_if = "String::is_empty",
34656 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34657 )]
34658 pub sip_group_id: String,
34659 #[serde(
34663 default,
34664 skip_serializing_if = "String::is_empty",
34665 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34666 )]
34667 pub site_id: String,
34668}
34669
34670#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
34671pub struct ListMeetingTemplatesResponse {
34672 #[serde(
34676 default,
34677 skip_serializing_if = "String::is_empty",
34678 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34679 )]
34680 pub id: String,
34681 #[serde(
34685 default,
34686 skip_serializing_if = "String::is_empty",
34687 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34688 )]
34689 pub name: String,
34690 #[serde(
34694 default,
34695 skip_serializing_if = "crate::utils::zero_i64",
34696 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
34697 rename = "type"
34698 )]
34699 pub type_: i64,
34700}
34701
34702#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
34703pub struct ListMeetingTemplatesResponseData {
34704 #[serde(
34705 default,
34706 skip_serializing_if = "Vec::is_empty",
34707 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
34708 )]
34709 pub templates: Vec<ListMeetingTemplatesResponse>,
34710 #[serde(
34714 default,
34715 skip_serializing_if = "crate::utils::zero_i64",
34716 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
34717 )]
34718 pub total_records: i64,
34719}
34720
34721#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
34725pub enum ListArchivedFilesQueryDateType {
34726 #[serde(rename = "archive_complete_time")]
34727 ArchiveCompleteTime,
34728 #[serde(rename = "meeting_start_time")]
34729 #[default]
34730 MeetingStartTime,
34731 #[serde(other)]
34732 FallthroughString,
34733}
34734
34735impl std::fmt::Display for ListArchivedFilesQueryDateType {
34736 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
34737 match self {
34738 ListArchivedFilesQueryDateType::ArchiveCompleteTime => "archive_complete_time",
34739 ListArchivedFilesQueryDateType::MeetingStartTime => "meeting_start_time",
34740 ListArchivedFilesQueryDateType::FallthroughString => "*",
34741 }
34742 .fmt(f)
34743 }
34744}
34745
34746#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
34748pub struct ListArchivedFilesResponseMeetingsArchive {
34749 #[serde(
34753 default,
34754 skip_serializing_if = "String::is_empty",
34755 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34756 )]
34757 pub download_url: String,
34758 #[serde(
34762 default,
34763 skip_serializing_if = "String::is_empty",
34764 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34765 )]
34766 pub file_extension: String,
34767 #[serde(
34771 default,
34772 skip_serializing_if = "crate::utils::zero_i64",
34773 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
34774 )]
34775 pub file_size: i64,
34776 #[serde(default, skip_serializing_if = "Option::is_none")]
34780 pub file_type: Option<FileType>,
34781 #[serde(
34785 default,
34786 skip_serializing_if = "String::is_empty",
34787 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34788 )]
34789 pub id: String,
34790 #[serde(default, skip_serializing_if = "Option::is_none")]
34794 pub recording_type: Option<RecordingType>,
34795 #[serde(
34799 default,
34800 skip_serializing_if = "String::is_empty",
34801 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34802 )]
34803 pub status: String,
34804}
34805
34806#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
34807pub struct ListArchivedFilesResponseMeetings {
34808 #[serde(
34809 default,
34810 skip_serializing_if = "Vec::is_empty",
34811 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
34812 )]
34813 pub archive_files: Vec<ListArchivedFilesResponseMeetingsArchive>,
34814 #[serde(
34818 default,
34819 skip_serializing_if = "crate::utils::zero_i64",
34820 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
34821 )]
34822 pub duration: i64,
34823 #[serde(
34827 default,
34828 skip_serializing_if = "String::is_empty",
34829 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34830 )]
34831 pub host_id: String,
34832 #[serde(
34836 default,
34837 skip_serializing_if = "crate::utils::zero_i64",
34838 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
34839 )]
34840 pub id: i64,
34841 #[serde(
34845 default,
34846 skip_serializing_if = "crate::utils::zero_i64",
34847 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
34848 )]
34849 pub recording_count: i64,
34850 #[serde(
34854 default,
34855 skip_serializing_if = "Option::is_none",
34856 deserialize_with = "crate::utils::date_time_format::deserialize"
34857 )]
34858 pub start_time: Option<chrono::DateTime<chrono::Utc>>,
34859 #[serde(
34863 default,
34864 skip_serializing_if = "String::is_empty",
34865 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34866 )]
34867 pub timezone: String,
34868 #[serde(
34872 default,
34873 skip_serializing_if = "String::is_empty",
34874 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34875 )]
34876 pub topic: String,
34877 #[serde(
34881 default,
34882 skip_serializing_if = "crate::utils::zero_i64",
34883 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
34884 )]
34885 pub total_size: i64,
34886 #[serde(
34890 default,
34891 skip_serializing_if = "crate::utils::zero_i64",
34892 deserialize_with = "crate::utils::deserialize_null_i64::deserialize",
34893 rename = "type"
34894 )]
34895 pub type_: i64,
34896 #[serde(
34900 default,
34901 skip_serializing_if = "String::is_empty",
34902 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34903 )]
34904 pub uuid: String,
34905}
34906
34907#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
34908pub struct ListArchivedFilesResponse {
34909 #[serde(
34913 default,
34914 skip_serializing_if = "String::is_empty",
34915 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34916 )]
34917 pub from: String,
34918 #[serde(
34919 default,
34920 skip_serializing_if = "Vec::is_empty",
34921 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
34922 )]
34923 pub meetings: Vec<ListArchivedFilesResponseMeetings>,
34924 #[serde(
34928 default,
34929 skip_serializing_if = "String::is_empty",
34930 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34931 )]
34932 pub next_page_token: String,
34933 #[serde(
34937 default,
34938 skip_serializing_if = "crate::utils::zero_i64",
34939 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
34940 )]
34941 pub page_size: i64,
34942 #[serde(
34946 default,
34947 skip_serializing_if = "String::is_empty",
34948 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
34949 )]
34950 pub to: String,
34951}