1use crate::enumtypes::*;
2
3#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
4pub struct AlternativeSecurityId {
5 #[serde(rename = "type")]
6 pub _type: i32,
7 #[serde(rename = "identityProvider")]
8 pub identity_provider: String,
9 #[serde(rename = "key")]
10 pub key: Vec<u8>,
11}
12
13#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
14pub struct DomainState {
15 #[serde(rename = "status")]
16 pub status: String,
17 #[serde(rename = "operation")]
18 pub operation: String,
19 #[serde(rename = "lastActionDateTime")]
20 pub last_action_date_time: String,
21}
22
23#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
24pub struct ServicePlanInfo {
25 #[serde(rename = "servicePlanId")]
26 pub service_plan_id: String,
27 #[serde(rename = "servicePlanName")]
28 pub service_plan_name: String,
29 #[serde(rename = "provisioningStatus")]
30 pub provisioning_status: String,
31 #[serde(rename = "appliesTo")]
32 pub applies_to: String,
33}
34
35#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
36pub struct AssignedLicense {
37 #[serde(rename = "disabledPlans")]
38 pub disabled_plans: Vec<String>,
39 #[serde(rename = "skuId")]
40 pub sku_id: String,
41}
42
43#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
44pub struct LicenseProcessingState {
45 #[serde(rename = "state")]
46 pub state: String,
47}
48
49#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
50pub struct OnPremisesProvisioningError {
51 #[serde(rename = "value")]
52 pub value: String,
53 #[serde(rename = "category")]
54 pub category: String,
55 #[serde(rename = "propertyCausingError")]
56 pub property_causing_error: String,
57 #[serde(rename = "occurredDateTime")]
58 pub occurred_date_time: String,
59}
60
61#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
62pub struct LicenseUnitsDetail {
63 #[serde(rename = "enabled")]
64 pub enabled: i32,
65 #[serde(rename = "suspended")]
66 pub suspended: i32,
67 #[serde(rename = "warning")]
68 pub warning: i32,
69}
70
71#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
72pub struct AssignedPlan {
73 #[serde(rename = "assignedDateTime")]
74 pub assigned_date_time: String,
75 #[serde(rename = "capabilityStatus")]
76 pub capability_status: String,
77 #[serde(rename = "service")]
78 pub service: String,
79 #[serde(rename = "servicePlanId")]
80 pub service_plan_id: String,
81}
82
83#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
84pub struct PrivacyProfile {
85 #[serde(rename = "contactEmail")]
86 pub contact_email: String,
87 #[serde(rename = "statementUrl")]
88 pub statement_url: String,
89}
90
91#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
92pub struct ProvisionedPlan {
93 #[serde(rename = "capabilityStatus")]
94 pub capability_status: String,
95 #[serde(rename = "provisioningStatus")]
96 pub provisioning_status: String,
97 #[serde(rename = "service")]
98 pub service: String,
99}
100
101#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
102pub struct VerifiedDomain {
103 #[serde(rename = "capabilities")]
104 pub capabilities: String,
105 #[serde(rename = "isDefault")]
106 pub is_default: bool,
107 #[serde(rename = "isInitial")]
108 pub is_initial: bool,
109 #[serde(rename = "name")]
110 pub name: String,
111 #[serde(rename = "type")]
112 pub _type: String,
113}
114
115#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
116pub struct LicenseAssignmentState {
117 #[serde(rename = "skuId")]
118 pub sku_id: String,
119 #[serde(rename = "disabledPlans")]
120 pub disabled_plans: Vec<String>,
121 #[serde(rename = "assignedByGroup")]
122 pub assigned_by_group: String,
123 #[serde(rename = "state")]
124 pub state: String,
125 #[serde(rename = "error")]
126 pub error: String,
127}
128
129#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
130pub struct OnPremisesExtensionAttributes {
131 #[serde(rename = "extensionAttribute1")]
132 pub extension_attribute1: String,
133 #[serde(rename = "extensionAttribute2")]
134 pub extension_attribute2: String,
135 #[serde(rename = "extensionAttribute3")]
136 pub extension_attribute3: String,
137 #[serde(rename = "extensionAttribute4")]
138 pub extension_attribute4: String,
139 #[serde(rename = "extensionAttribute5")]
140 pub extension_attribute5: String,
141 #[serde(rename = "extensionAttribute6")]
142 pub extension_attribute6: String,
143 #[serde(rename = "extensionAttribute7")]
144 pub extension_attribute7: String,
145 #[serde(rename = "extensionAttribute8")]
146 pub extension_attribute8: String,
147 #[serde(rename = "extensionAttribute9")]
148 pub extension_attribute9: String,
149 #[serde(rename = "extensionAttribute10")]
150 pub extension_attribute10: String,
151 #[serde(rename = "extensionAttribute11")]
152 pub extension_attribute11: String,
153 #[serde(rename = "extensionAttribute12")]
154 pub extension_attribute12: String,
155 #[serde(rename = "extensionAttribute13")]
156 pub extension_attribute13: String,
157 #[serde(rename = "extensionAttribute14")]
158 pub extension_attribute14: String,
159 #[serde(rename = "extensionAttribute15")]
160 pub extension_attribute15: String,
161}
162
163#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
164pub struct PasswordProfile {
165 #[serde(rename = "password")]
166 pub password: String,
167 #[serde(rename = "forceChangePasswordNextSignIn")]
168 pub force_change_password_next_sign_in: bool,
169 #[serde(rename = "forceChangePasswordNextSignInWithMfa")]
170 pub force_change_password_next_sign_in_with_mfa: bool,
171}
172
173#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
174pub struct MailboxSettings {
175 #[serde(rename = "automaticRepliesSetting")]
176 pub automatic_replies_setting: AutomaticRepliesSetting,
177 #[serde(rename = "archiveFolder")]
178 pub archive_folder: String,
179 #[serde(rename = "timeZone")]
180 pub time_zone: String,
181 #[serde(rename = "language")]
182 pub language: LocaleInfo,
183 #[serde(rename = "workingHours")]
184 pub working_hours: WorkingHours,
185}
186
187#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
188pub struct AutomaticRepliesSetting {
189 #[serde(rename = "status")]
190 pub status: AutomaticRepliesStatus,
191 #[serde(rename = "externalAudience")]
192 pub external_audience: ExternalAudienceScope,
193 #[serde(rename = "scheduledStartDateTime")]
194 pub scheduled_start_date_time: String,
195 #[serde(rename = "scheduledEndDateTime")]
196 pub scheduled_end_date_time: String,
197 #[serde(rename = "internalReplyMessage")]
198 pub internal_reply_message: String,
199 #[serde(rename = "externalReplyMessage")]
200 pub external_reply_message: String,
201}
202
203#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
204pub struct DateTimeTimeZone {
205 #[serde(rename = "dateTime")]
206 pub date_time: String,
207 #[serde(rename = "timeZone")]
208 pub time_zone: String,
209}
210
211#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
212pub struct LocaleInfo {
213 #[serde(rename = "locale")]
214 pub locale: String,
215 #[serde(rename = "displayName")]
216 pub display_name: String,
217}
218
219#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
220pub struct WorkingHours {
221 #[serde(rename = "daysOfWeek")]
222 pub days_of_week: Vec<DayOfWeek>,
223 #[serde(rename = "startTime")]
224 pub start_time: String,
225 #[serde(rename = "endTime")]
226 pub end_time: String,
227 #[serde(rename = "timeZone")]
228 pub time_zone: TimeZoneBase,
229}
230
231#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
232pub struct TimeZoneBase {
233 #[serde(rename = "name")]
234 pub name: String,
235}
236
237#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
238pub struct SettingValue {
239 #[serde(rename = "name")]
240 pub name: String,
241 #[serde(rename = "value")]
242 pub value: String,
243}
244
245#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
246pub struct SettingTemplateValue {
247 #[serde(rename = "name")]
248 pub name: String,
249 #[serde(rename = "type")]
250 pub _type: String,
251 #[serde(rename = "defaultValue")]
252 pub default_value: String,
253 #[serde(rename = "description")]
254 pub description: String,
255}
256
257#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
258pub struct ComplexExtensionValue {}
259
260#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
261pub struct ExtensionSchemaProperty {
262 #[serde(rename = "name")]
263 pub name: String,
264 #[serde(rename = "type")]
265 pub _type: String,
266}
267
268#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
269pub struct CustomTimeZone {
270 #[serde(rename = "bias")]
271 pub bias: i32,
272 #[serde(rename = "standardOffset")]
273 pub standard_offset: StandardTimeZoneOffset,
274 #[serde(rename = "daylightOffset")]
275 pub daylight_offset: DaylightTimeZoneOffset,
276}
277
278#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
279pub struct StandardTimeZoneOffset {
280 #[serde(rename = "time")]
281 pub time: String,
282 #[serde(rename = "dayOccurrence")]
283 pub day_occurrence: i32,
284 #[serde(rename = "dayOfWeek")]
285 pub day_of_week: DayOfWeek,
286 #[serde(rename = "month")]
287 pub month: i32,
288 #[serde(rename = "year")]
289 pub year: i32,
290}
291
292#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
293pub struct DaylightTimeZoneOffset {
294 #[serde(rename = "daylightBias")]
295 pub daylight_bias: i32,
296}
297
298#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
299pub struct Recipient {
300 #[serde(rename = "emailAddress")]
301 pub email_address: EmailAddress,
302}
303
304#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
305pub struct EmailAddress {
306 #[serde(rename = "name")]
307 pub name: String,
308 #[serde(rename = "address")]
309 pub address: String,
310}
311
312#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
313pub struct AttendeeBase {
314 #[serde(rename = "type")]
315 pub _type: AttendeeType,
316}
317
318#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
319pub struct Location {
320 #[serde(rename = "displayName")]
321 pub display_name: String,
322 #[serde(rename = "locationEmailAddress")]
323 pub location_email_address: String,
324 #[serde(rename = "address")]
325 pub address: PhysicalAddress,
326 #[serde(rename = "coordinates")]
327 pub coordinates: OutlookGeoCoordinates,
328 #[serde(rename = "locationUri")]
329 pub location_uri: String,
330 #[serde(rename = "locationType")]
331 pub location_type: LocationType,
332 #[serde(rename = "uniqueId")]
333 pub unique_id: String,
334 #[serde(rename = "uniqueIdType")]
335 pub unique_id_type: LocationUniqueIdType,
336}
337
338#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
339pub struct PhysicalAddress {
340 #[serde(rename = "street")]
341 pub street: String,
342 #[serde(rename = "city")]
343 pub city: String,
344 #[serde(rename = "state")]
345 pub state: String,
346 #[serde(rename = "countryOrRegion")]
347 pub country_or_region: String,
348 #[serde(rename = "postalCode")]
349 pub postal_code: String,
350}
351
352#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
353pub struct OutlookGeoCoordinates {
354 #[serde(rename = "altitude")]
355 pub altitude: i64,
356 #[serde(rename = "latitude")]
357 pub latitude: i64,
358 #[serde(rename = "longitude")]
359 pub longitude: i64,
360 #[serde(rename = "accuracy")]
361 pub accuracy: i64,
362 #[serde(rename = "altitudeAccuracy")]
363 pub altitude_accuracy: i64,
364}
365
366#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
367pub struct Reminder {
368 #[serde(rename = "eventId")]
369 pub event_id: String,
370 #[serde(rename = "eventStartTime")]
371 pub event_start_time: String,
372 #[serde(rename = "eventEndTime")]
373 pub event_end_time: String,
374 #[serde(rename = "changeKey")]
375 pub change_key: String,
376 #[serde(rename = "eventSubject")]
377 pub event_subject: String,
378 #[serde(rename = "eventLocation")]
379 pub event_location: Location,
380 #[serde(rename = "eventWebLink")]
381 pub event_web_link: String,
382 #[serde(rename = "reminderFireTime")]
383 pub reminder_fire_time: String,
384}
385
386#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
387pub struct MailTips {
388 #[serde(rename = "emailAddress")]
389 pub email_address: EmailAddress,
390 #[serde(rename = "automaticReplies")]
391 pub automatic_replies: AutomaticRepliesMailTips,
392 #[serde(rename = "mailboxFull")]
393 pub mailbox_full: bool,
394 #[serde(rename = "customMailTip")]
395 pub custom_mail_tip: String,
396 #[serde(rename = "externalMemberCount")]
397 pub external_member_count: i32,
398 #[serde(rename = "totalMemberCount")]
399 pub total_member_count: i32,
400 #[serde(rename = "deliveryRestricted")]
401 pub delivery_restricted: bool,
402 #[serde(rename = "isModerated")]
403 pub is_moderated: bool,
404 #[serde(rename = "recipientScope")]
405 pub recipient_scope: RecipientScopeType,
406 #[serde(rename = "recipientSuggestions")]
407 pub recipient_suggestions: Vec<Recipient>,
408 #[serde(rename = "maxMessageSize")]
409 pub max_message_size: i32,
410 #[serde(rename = "error")]
411 pub error: MailTipsError,
412}
413
414#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
415pub struct AutomaticRepliesMailTips {
416 #[serde(rename = "message")]
417 pub message: String,
418 #[serde(rename = "messageLanguage")]
419 pub message_language: LocaleInfo,
420 #[serde(rename = "scheduledStartTime")]
421 pub scheduled_start_time: String,
422 #[serde(rename = "scheduledEndTime")]
423 pub scheduled_end_time: String,
424}
425
426#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
427pub struct MailTipsError {
428 #[serde(rename = "message")]
429 pub message: String,
430 #[serde(rename = "code")]
431 pub code: String,
432}
433
434#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
435pub struct TimeZoneInformation {
436 #[serde(rename = "alias")]
437 pub alias: String,
438 #[serde(rename = "displayName")]
439 pub display_name: String,
440}
441
442#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
443pub struct InternetMessageHeader {
444 #[serde(rename = "name")]
445 pub name: String,
446 #[serde(rename = "value")]
447 pub value: String,
448}
449
450#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
451pub struct ItemBody {
452 #[serde(rename = "contentType")]
453 pub content_type: BodyType,
454 #[serde(rename = "content")]
455 pub content: String,
456}
457
458#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
459pub struct FollowupFlag {
460 #[serde(rename = "completedDateTime")]
461 pub completed_date_time: String,
462 #[serde(rename = "dueDateTime")]
463 pub due_date_time: String,
464 #[serde(rename = "startDateTime")]
465 pub start_date_time: String,
466 #[serde(rename = "flagStatus")]
467 pub flag_status: FollowupFlagStatus,
468}
469
470#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
471pub struct ScheduleInformation {
472 #[serde(rename = "scheduleId")]
473 pub schedule_id: String,
474 #[serde(rename = "scheduleItems")]
475 pub schedule_items: Vec<ScheduleItem>,
476 #[serde(rename = "availabilityView")]
477 pub availability_view: String,
478 #[serde(rename = "error")]
479 pub error: FreeBusyError,
480 #[serde(rename = "workingHours")]
481 pub working_hours: WorkingHours,
482}
483
484#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
485pub struct ScheduleItem {
486 #[serde(rename = "start")]
487 pub start: String,
488 #[serde(rename = "end")]
489 pub end: String,
490 #[serde(rename = "isPrivate")]
491 pub is_private: bool,
492 #[serde(rename = "status")]
493 pub status: FreeBusyStatus,
494 #[serde(rename = "subject")]
495 pub subject: String,
496 #[serde(rename = "location")]
497 pub location: String,
498}
499
500#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
501pub struct FreeBusyError {
502 #[serde(rename = "message")]
503 pub message: String,
504 #[serde(rename = "responseCode")]
505 pub response_code: String,
506}
507
508#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
509pub struct ResponseStatus {
510 #[serde(rename = "response")]
511 pub response: ResponseType,
512 #[serde(rename = "time")]
513 pub time: String,
514}
515
516#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
517pub struct PatternedRecurrence {
518 #[serde(rename = "pattern")]
519 pub pattern: RecurrencePattern,
520 #[serde(rename = "range")]
521 pub range: RecurrenceRange,
522}
523
524#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
525pub struct RecurrencePattern {
526 #[serde(rename = "type")]
527 pub _type: RecurrencePatternType,
528 #[serde(rename = "interval")]
529 pub interval: i32,
530 #[serde(rename = "month")]
531 pub month: i32,
532 #[serde(rename = "dayOfMonth")]
533 pub day_of_month: i32,
534 #[serde(rename = "daysOfWeek")]
535 pub days_of_week: Vec<DayOfWeek>,
536 #[serde(rename = "firstDayOfWeek")]
537 pub first_day_of_week: DayOfWeek,
538 #[serde(rename = "index")]
539 pub index: WeekIndex,
540}
541
542#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
543pub struct RecurrenceRange {
544 #[serde(rename = "type")]
545 pub _type: RecurrenceRangeType,
546 #[serde(rename = "startDate")]
547 pub start_date: String,
548 #[serde(rename = "endDate")]
549 pub end_date: String,
550 #[serde(rename = "recurrenceTimeZone")]
551 pub recurrence_time_zone: String,
552 #[serde(rename = "numberOfOccurrences")]
553 pub number_of_occurrences: i32,
554}
555
556#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
557pub struct Attendee {
558 #[serde(rename = "status")]
559 pub status: ResponseStatus,
560}
561
562#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
563pub struct MessageRulePredicates {
564 #[serde(rename = "categories")]
565 pub categories: Vec<String>,
566 #[serde(rename = "subjectContains")]
567 pub subject_contains: Vec<String>,
568 #[serde(rename = "bodyContains")]
569 pub body_contains: Vec<String>,
570 #[serde(rename = "bodyOrSubjectContains")]
571 pub body_or_subject_contains: Vec<String>,
572 #[serde(rename = "senderContains")]
573 pub sender_contains: Vec<String>,
574 #[serde(rename = "recipientContains")]
575 pub recipient_contains: Vec<String>,
576 #[serde(rename = "headerContains")]
577 pub header_contains: Vec<String>,
578 #[serde(rename = "messageActionFlag")]
579 pub message_action_flag: MessageActionFlag,
580 #[serde(rename = "importance")]
581 pub importance: Importance,
582 #[serde(rename = "sensitivity")]
583 pub sensitivity: Sensitivity,
584 #[serde(rename = "fromAddresses")]
585 pub from_addresses: Vec<Recipient>,
586 #[serde(rename = "sentToAddresses")]
587 pub sent_to_addresses: Vec<Recipient>,
588 #[serde(rename = "sentToMe")]
589 pub sent_to_me: bool,
590 #[serde(rename = "sentOnlyToMe")]
591 pub sent_only_to_me: bool,
592 #[serde(rename = "sentCcMe")]
593 pub sent_cc_me: bool,
594 #[serde(rename = "sentToOrCcMe")]
595 pub sent_to_or_cc_me: bool,
596 #[serde(rename = "notSentToMe")]
597 pub not_sent_to_me: bool,
598 #[serde(rename = "hasAttachments")]
599 pub has_attachments: bool,
600 #[serde(rename = "isApprovalRequest")]
601 pub is_approval_request: bool,
602 #[serde(rename = "isAutomaticForward")]
603 pub is_automatic_forward: bool,
604 #[serde(rename = "isAutomaticReply")]
605 pub is_automatic_reply: bool,
606 #[serde(rename = "isEncrypted")]
607 pub is_encrypted: bool,
608 #[serde(rename = "isMeetingRequest")]
609 pub is_meeting_request: bool,
610 #[serde(rename = "isMeetingResponse")]
611 pub is_meeting_response: bool,
612 #[serde(rename = "isNonDeliveryReport")]
613 pub is_non_delivery_report: bool,
614 #[serde(rename = "isPermissionControlled")]
615 pub is_permission_controlled: bool,
616 #[serde(rename = "isReadReceipt")]
617 pub is_read_receipt: bool,
618 #[serde(rename = "isSigned")]
619 pub is_signed: bool,
620 #[serde(rename = "isVoicemail")]
621 pub is_voicemail: bool,
622 #[serde(rename = "withinSizeRange")]
623 pub within_size_range: SizeRange,
624}
625
626#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
627pub struct SizeRange {
628 #[serde(rename = "minimumSize")]
629 pub minimum_size: i32,
630 #[serde(rename = "maximumSize")]
631 pub maximum_size: i32,
632}
633
634#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
635pub struct MessageRuleActions {
636 #[serde(rename = "moveToFolder")]
637 pub move_to_folder: String,
638 #[serde(rename = "copyToFolder")]
639 pub copy_to_folder: String,
640 #[serde(rename = "delete")]
641 pub delete: bool,
642 #[serde(rename = "permanentDelete")]
643 pub permanent_delete: bool,
644 #[serde(rename = "markAsRead")]
645 pub mark_as_read: bool,
646 #[serde(rename = "markImportance")]
647 pub mark_importance: Importance,
648 #[serde(rename = "forwardTo")]
649 pub forward_to: Vec<Recipient>,
650 #[serde(rename = "forwardAsAttachmentTo")]
651 pub forward_as_attachment_to: Vec<Recipient>,
652 #[serde(rename = "redirectTo")]
653 pub redirect_to: Vec<Recipient>,
654 #[serde(rename = "assignCategories")]
655 pub assign_categories: Vec<String>,
656 #[serde(rename = "stopProcessingRules")]
657 pub stop_processing_rules: bool,
658}
659
660#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
661pub struct ScoredEmailAddress {
662 #[serde(rename = "address")]
663 pub address: String,
664 #[serde(rename = "relevanceScore")]
665 pub relevance_score: i64,
666 #[serde(rename = "selectionLikelihood")]
667 pub selection_likelihood: SelectionLikelihoodInfo,
668 #[serde(rename = "ItemId")]
669 pub _item_id: String,
670}
671
672#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
673pub struct Phone {
674 #[serde(rename = "type")]
675 pub _type: PhoneType,
676 #[serde(rename = "number")]
677 pub number: String,
678 #[serde(rename = "region")]
679 pub region: String,
680 #[serde(rename = "language")]
681 pub language: String,
682}
683
684#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
685pub struct Website {
686 #[serde(rename = "type")]
687 pub _type: WebsiteType,
688 #[serde(rename = "address")]
689 pub address: String,
690 #[serde(rename = "displayName")]
691 pub display_name: String,
692}
693
694#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
695pub struct PersonType {
696 #[serde(rename = "class")]
697 pub class: String,
698 #[serde(rename = "subclass")]
699 pub subclass: String,
700}
701
702#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
703pub struct LocationConstraint {
704 #[serde(rename = "locations")]
705 pub locations: Vec<LocationConstraintItem>,
706 #[serde(rename = "isRequired")]
707 pub is_required: bool,
708 #[serde(rename = "suggestLocation")]
709 pub suggest_location: bool,
710}
711
712#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
713pub struct LocationConstraintItem {
714 #[serde(rename = "resolveAvailability")]
715 pub resolve_availability: bool,
716}
717
718#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
719pub struct MeetingTimeSuggestionsResult {
720 #[serde(rename = "meetingTimeSuggestions")]
721 pub meeting_time_suggestions: Vec<MeetingTimeSuggestion>,
722 #[serde(rename = "emptySuggestionsReason")]
723 pub empty_suggestions_reason: String,
724}
725
726#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
727pub struct MeetingTimeSuggestion {
728 #[serde(rename = "confidence")]
729 pub confidence: i64,
730 #[serde(rename = "order")]
731 pub order: i32,
732 #[serde(rename = "organizerAvailability")]
733 pub organizer_availability: FreeBusyStatus,
734 #[serde(rename = "attendeeAvailability")]
735 pub attendee_availability: Vec<AttendeeAvailability>,
736 #[serde(rename = "locations")]
737 pub locations: Vec<Location>,
738 #[serde(rename = "suggestionReason")]
739 pub suggestion_reason: String,
740 #[serde(rename = "meetingTimeSlot")]
741 pub meeting_time_slot: TimeSlot,
742}
743
744#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
745pub struct AttendeeAvailability {
746 #[serde(rename = "attendee")]
747 pub attendee: AttendeeBase,
748 #[serde(rename = "availability")]
749 pub availability: FreeBusyStatus,
750}
751
752#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
753pub struct TimeSlot {
754 #[serde(rename = "start")]
755 pub start: String,
756 #[serde(rename = "end")]
757 pub end: String,
758}
759
760#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
761pub struct TimeConstraint {
762 #[serde(rename = "activityDomain")]
763 pub activity_domain: ActivityDomain,
764 #[serde(rename = "timeSlots")]
765 pub time_slots: Vec<TimeSlot>,
766}
767
768#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
769pub struct IdentitySet {
770 #[serde(rename = "application")]
771 pub application: Identity,
772 #[serde(rename = "device")]
773 pub device: Identity,
774 #[serde(rename = "user")]
775 pub user: Identity,
776}
777
778#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
779pub struct Identity {
780 #[serde(rename = "displayName")]
781 pub display_name: String,
782 #[serde(rename = "id")]
783 pub id: String,
784}
785
786#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
787pub struct ItemReference {
788 #[serde(rename = "driveId")]
789 pub drive_id: String,
790 #[serde(rename = "driveType")]
791 pub drive_type: String,
792 #[serde(rename = "id")]
793 pub id: String,
794 #[serde(rename = "name")]
795 pub name: String,
796 #[serde(rename = "path")]
797 pub path: String,
798 #[serde(rename = "shareId")]
799 pub share_id: String,
800 #[serde(rename = "sharepointIds")]
801 pub sharepoint_ids: SharepointIds,
802 #[serde(rename = "siteId")]
803 pub site_id: String,
804}
805
806#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
807pub struct SharepointIds {
808 #[serde(rename = "listId")]
809 pub list_id: String,
810 #[serde(rename = "listItemId")]
811 pub list_item_id: String,
812 #[serde(rename = "listItemUniqueId")]
813 pub list_item_unique_id: String,
814 #[serde(rename = "siteId")]
815 pub site_id: String,
816 #[serde(rename = "siteUrl")]
817 pub site_url: String,
818 #[serde(rename = "webId")]
819 pub web_id: String,
820}
821
822#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
823pub struct PublicationFacet {
824 #[serde(rename = "level")]
825 pub level: String,
826 #[serde(rename = "versionId")]
827 pub version_id: String,
828}
829
830#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
831pub struct BooleanColumn {}
832
833#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
834pub struct CalculatedColumn {
835 #[serde(rename = "format")]
836 pub format: String,
837 #[serde(rename = "formula")]
838 pub formula: String,
839 #[serde(rename = "outputType")]
840 pub output_type: String,
841}
842
843#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
844pub struct ChoiceColumn {
845 #[serde(rename = "allowTextEntry")]
846 pub allow_text_entry: bool,
847 #[serde(rename = "choices")]
848 pub choices: Vec<String>,
849 #[serde(rename = "displayAs")]
850 pub display_as: String,
851}
852
853#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
854pub struct CurrencyColumn {
855 #[serde(rename = "locale")]
856 pub locale: String,
857}
858
859#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
860pub struct DateTimeColumn {
861 #[serde(rename = "displayAs")]
862 pub display_as: String,
863 #[serde(rename = "format")]
864 pub format: String,
865}
866
867#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
868pub struct DefaultColumnValue {
869 #[serde(rename = "formula")]
870 pub formula: String,
871 #[serde(rename = "value")]
872 pub value: String,
873}
874
875#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
876pub struct LookupColumn {
877 #[serde(rename = "allowMultipleValues")]
878 pub allow_multiple_values: bool,
879 #[serde(rename = "allowUnlimitedLength")]
880 pub allow_unlimited_length: bool,
881 #[serde(rename = "columnName")]
882 pub column_name: String,
883 #[serde(rename = "listId")]
884 pub list_id: String,
885 #[serde(rename = "primaryLookupColumnId")]
886 pub primary_lookup_column_id: String,
887}
888
889#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
890pub struct NumberColumn {
891 #[serde(rename = "decimalPlaces")]
892 pub decimal_places: String,
893 #[serde(rename = "displayAs")]
894 pub display_as: String,
895 #[serde(rename = "maximum")]
896 pub maximum: i64,
897 #[serde(rename = "minimum")]
898 pub minimum: i64,
899}
900
901#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
902pub struct PersonOrGroupColumn {
903 #[serde(rename = "allowMultipleSelection")]
904 pub allow_multiple_selection: bool,
905 #[serde(rename = "chooseFromType")]
906 pub choose_from_type: String,
907 #[serde(rename = "displayAs")]
908 pub display_as: String,
909}
910
911#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
912pub struct TextColumn {
913 #[serde(rename = "allowMultipleLines")]
914 pub allow_multiple_lines: bool,
915 #[serde(rename = "appendChangesToExistingText")]
916 pub append_changes_to_existing_text: bool,
917 #[serde(rename = "linesForEditing")]
918 pub lines_for_editing: i32,
919 #[serde(rename = "maxLength")]
920 pub max_length: i32,
921 #[serde(rename = "textType")]
922 pub text_type: String,
923}
924
925#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
926pub struct ContentTypeOrder {
927 #[serde(rename = "default")]
928 pub default: bool,
929 #[serde(rename = "position")]
930 pub position: i32,
931}
932
933#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
934pub struct Quota {
935 #[serde(rename = "deleted")]
936 pub deleted: i64,
937 #[serde(rename = "remaining")]
938 pub remaining: i64,
939 #[serde(rename = "state")]
940 pub state: String,
941 #[serde(rename = "total")]
942 pub total: i64,
943 #[serde(rename = "used")]
944 pub used: i64,
945}
946
947#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
948pub struct SystemFacet {}
949
950#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
951pub struct Audio {
952 #[serde(rename = "album")]
953 pub album: String,
954 #[serde(rename = "albumArtist")]
955 pub album_artist: String,
956 #[serde(rename = "artist")]
957 pub artist: String,
958 #[serde(rename = "bitrate")]
959 pub bitrate: i64,
960 #[serde(rename = "composers")]
961 pub composers: String,
962 #[serde(rename = "copyright")]
963 pub copyright: String,
964 #[serde(rename = "disc")]
965 pub disc: i16,
966 #[serde(rename = "discCount")]
967 pub disc_count: i16,
968 #[serde(rename = "duration")]
969 pub duration: i64,
970 #[serde(rename = "genre")]
971 pub genre: String,
972 #[serde(rename = "hasDrm")]
973 pub has_drm: bool,
974 #[serde(rename = "isVariableBitrate")]
975 pub is_variable_bitrate: bool,
976 #[serde(rename = "title")]
977 pub title: String,
978 #[serde(rename = "track")]
979 pub track: i32,
980 #[serde(rename = "trackCount")]
981 pub track_count: i32,
982 #[serde(rename = "year")]
983 pub year: i32,
984}
985
986#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
987pub struct Deleted {
988 #[serde(rename = "state")]
989 pub state: String,
990}
991
992#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
993pub struct File {
994 #[serde(rename = "hashes")]
995 pub hashes: Hashes,
996 #[serde(rename = "mimeType")]
997 pub mime_type: String,
998 #[serde(rename = "processingMetadata")]
999 pub processing_metadata: bool,
1000}
1001
1002#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1003pub struct Hashes {
1004 #[serde(rename = "crc32Hash")]
1005 pub crc32_hash: String,
1006 #[serde(rename = "quickXorHash")]
1007 pub quick_xor_hash: String,
1008 #[serde(rename = "sha1Hash")]
1009 pub sha1_hash: String,
1010}
1011
1012#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1013pub struct FileSystemInfo {
1014 #[serde(rename = "createdDateTime")]
1015 pub created_date_time: String,
1016 #[serde(rename = "lastAccessedDateTime")]
1017 pub last_accessed_date_time: String,
1018 #[serde(rename = "lastModifiedDateTime")]
1019 pub last_modified_date_time: String,
1020}
1021
1022#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1023pub struct Folder {
1024 #[serde(rename = "childCount")]
1025 pub child_count: i32,
1026 #[serde(rename = "view")]
1027 pub view: FolderView,
1028}
1029
1030#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1031pub struct FolderView {
1032 #[serde(rename = "sortBy")]
1033 pub sort_by: String,
1034 #[serde(rename = "sortOrder")]
1035 pub sort_order: String,
1036 #[serde(rename = "viewType")]
1037 pub view_type: String,
1038}
1039
1040#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1041pub struct Image {
1042 #[serde(rename = "height")]
1043 pub height: i32,
1044 #[serde(rename = "width")]
1045 pub width: i32,
1046}
1047
1048#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1049pub struct GeoCoordinates {
1050 #[serde(rename = "altitude")]
1051 pub altitude: i64,
1052 #[serde(rename = "latitude")]
1053 pub latitude: i64,
1054 #[serde(rename = "longitude")]
1055 pub longitude: i64,
1056}
1057
1058#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1059pub struct Package {
1060 #[serde(rename = "type")]
1061 pub _type: String,
1062}
1063
1064#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1065pub struct Photo {
1066 #[serde(rename = "cameraMake")]
1067 pub camera_make: String,
1068 #[serde(rename = "cameraModel")]
1069 pub camera_model: String,
1070 #[serde(rename = "exposureDenominator")]
1071 pub exposure_denominator: i64,
1072 #[serde(rename = "exposureNumerator")]
1073 pub exposure_numerator: i64,
1074 #[serde(rename = "fNumber")]
1075 pub f_number: i64,
1076 #[serde(rename = "focalLength")]
1077 pub focal_length: i64,
1078 #[serde(rename = "iso")]
1079 pub iso: i32,
1080 #[serde(rename = "takenDateTime")]
1081 pub taken_date_time: String,
1082}
1083
1084#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1085pub struct RemoteItem {
1086 #[serde(rename = "createdBy")]
1087 pub created_by: IdentitySet,
1088 #[serde(rename = "createdDateTime")]
1089 pub created_date_time: String,
1090 #[serde(rename = "file")]
1091 pub file: File,
1092 #[serde(rename = "fileSystemInfo")]
1093 pub file_system_info: FileSystemInfo,
1094 #[serde(rename = "folder")]
1095 pub folder: Folder,
1096 #[serde(rename = "id")]
1097 pub id: String,
1098 #[serde(rename = "lastModifiedBy")]
1099 pub last_modified_by: IdentitySet,
1100 #[serde(rename = "lastModifiedDateTime")]
1101 pub last_modified_date_time: String,
1102 #[serde(rename = "name")]
1103 pub name: String,
1104 #[serde(rename = "package")]
1105 pub package: Package,
1106 #[serde(rename = "parentReference")]
1107 pub parent_reference: ItemReference,
1108 #[serde(rename = "shared")]
1109 pub shared: Shared,
1110 #[serde(rename = "sharepointIds")]
1111 pub sharepoint_ids: SharepointIds,
1112 #[serde(rename = "size")]
1113 pub size: i64,
1114 #[serde(rename = "specialFolder")]
1115 pub special_folder: SpecialFolder,
1116 #[serde(rename = "webDavUrl")]
1117 pub web_dav_url: String,
1118 #[serde(rename = "webUrl")]
1119 pub web_url: String,
1120}
1121
1122#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1123pub struct Shared {
1124 #[serde(rename = "owner")]
1125 pub owner: IdentitySet,
1126 #[serde(rename = "scope")]
1127 pub scope: String,
1128 #[serde(rename = "sharedBy")]
1129 pub shared_by: IdentitySet,
1130 #[serde(rename = "sharedDateTime")]
1131 pub shared_date_time: String,
1132}
1133
1134#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1135pub struct SpecialFolder {
1136 #[serde(rename = "name")]
1137 pub name: String,
1138}
1139
1140#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1141pub struct Root {}
1142
1143#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1144pub struct SearchResult {
1145 #[serde(rename = "onClickTelemetryUrl")]
1146 pub on_click_telemetry_url: String,
1147}
1148
1149#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1150pub struct Video {
1151 #[serde(rename = "audioBitsPerSample")]
1152 pub audio_bits_per_sample: i32,
1153 #[serde(rename = "audioChannels")]
1154 pub audio_channels: i32,
1155 #[serde(rename = "audioFormat")]
1156 pub audio_format: String,
1157 #[serde(rename = "audioSamplesPerSecond")]
1158 pub audio_samples_per_second: i32,
1159 #[serde(rename = "bitrate")]
1160 pub bitrate: i32,
1161 #[serde(rename = "duration")]
1162 pub duration: i64,
1163 #[serde(rename = "fourCC")]
1164 pub four_c_c: String,
1165 #[serde(rename = "frameRate")]
1166 pub frame_rate: i64,
1167 #[serde(rename = "height")]
1168 pub height: i32,
1169 #[serde(rename = "width")]
1170 pub width: i32,
1171}
1172
1173#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1174pub struct AccessAction {}
1175
1176#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1177pub struct ItemActionStat {
1178 #[serde(rename = "actionCount")]
1179 pub action_count: i32,
1180 #[serde(rename = "actorCount")]
1181 pub actor_count: i32,
1182}
1183
1184#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1185pub struct IncompleteData {
1186 #[serde(rename = "missingDataBeforeDateTime")]
1187 pub missing_data_before_date_time: String,
1188 #[serde(rename = "wasThrottled")]
1189 pub was_throttled: bool,
1190}
1191
1192#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1193pub struct ListInfo {
1194 #[serde(rename = "contentTypesEnabled")]
1195 pub content_types_enabled: bool,
1196 #[serde(rename = "hidden")]
1197 pub hidden: bool,
1198 #[serde(rename = "template")]
1199 pub template: String,
1200}
1201
1202#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1203pub struct ContentTypeInfo {
1204 #[serde(rename = "id")]
1205 pub id: String,
1206}
1207
1208#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1209pub struct SharingInvitation {
1210 #[serde(rename = "email")]
1211 pub email: String,
1212 #[serde(rename = "invitedBy")]
1213 pub invited_by: IdentitySet,
1214 #[serde(rename = "redeemedBy")]
1215 pub redeemed_by: String,
1216 #[serde(rename = "signInRequired")]
1217 pub sign_in_required: bool,
1218}
1219
1220#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1221pub struct SharingLink {
1222 #[serde(rename = "application")]
1223 pub application: Identity,
1224 #[serde(rename = "scope")]
1225 pub scope: String,
1226 #[serde(rename = "type")]
1227 pub _type: String,
1228 #[serde(rename = "webUrl")]
1229 pub web_url: String,
1230}
1231
1232#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1233pub struct SiteCollection {
1234 #[serde(rename = "hostname")]
1235 pub hostname: String,
1236 #[serde(rename = "root")]
1237 pub root: Root,
1238}
1239
1240#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1241pub struct Thumbnail {
1242 #[serde(rename = "content")]
1243 pub content: String,
1244 #[serde(rename = "height")]
1245 pub height: i32,
1246 #[serde(rename = "sourceItemId")]
1247 pub source_item_id: String,
1248 #[serde(rename = "url")]
1249 pub url: String,
1250 #[serde(rename = "width")]
1251 pub width: i32,
1252}
1253
1254#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1255pub struct DriveItemUploadableProperties {
1256 #[serde(rename = "description")]
1257 pub description: String,
1258 #[serde(rename = "fileSystemInfo")]
1259 pub file_system_info: FileSystemInfo,
1260 #[serde(rename = "name")]
1261 pub name: String,
1262}
1263
1264#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1265pub struct DriveRecipient {
1266 #[serde(rename = "alias")]
1267 pub alias: String,
1268 #[serde(rename = "email")]
1269 pub email: String,
1270 #[serde(rename = "objectId")]
1271 pub object_id: String,
1272}
1273
1274#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1275pub struct ItemPreviewInfo {
1276 #[serde(rename = "getUrl")]
1277 pub get_url: String,
1278 #[serde(rename = "postParameters")]
1279 pub post_parameters: String,
1280 #[serde(rename = "postUrl")]
1281 pub post_url: String,
1282}
1283
1284#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1285pub struct UploadSession {
1286 #[serde(rename = "expirationDateTime")]
1287 pub expiration_date_time: String,
1288 #[serde(rename = "nextExpectedRanges")]
1289 pub next_expected_ranges: Vec<String>,
1290 #[serde(rename = "uploadUrl")]
1291 pub upload_url: String,
1292}
1293
1294#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1295pub struct WorkbookSessionInfo {
1296 #[serde(rename = "id")]
1297 pub id: String,
1298 #[serde(rename = "persistChanges")]
1299 pub persist_changes: bool,
1300}
1301
1302#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1303pub struct Json {}
1304
1305#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1306pub struct WorkbookFilterCriteria {
1307 #[serde(rename = "color")]
1308 pub color: String,
1309 #[serde(rename = "criterion1")]
1310 pub criterion1: String,
1311 #[serde(rename = "criterion2")]
1312 pub criterion2: String,
1313 #[serde(rename = "dynamicCriteria")]
1314 pub dynamic_criteria: String,
1315 #[serde(rename = "filterOn")]
1316 pub filter_on: String,
1317 #[serde(rename = "icon")]
1318 pub icon: WorkbookIcon,
1319 #[serde(rename = "operator")]
1320 pub operator: String,
1321 #[serde(rename = "values")]
1322 pub values: Json,
1323}
1324
1325#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1326pub struct WorkbookIcon {
1327 #[serde(rename = "index")]
1328 pub index: i32,
1329 #[serde(rename = "set")]
1330 pub set: String,
1331}
1332
1333#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1334pub struct WorkbookSortField {
1335 #[serde(rename = "ascending")]
1336 pub ascending: bool,
1337 #[serde(rename = "color")]
1338 pub color: String,
1339 #[serde(rename = "dataOption")]
1340 pub data_option: String,
1341 #[serde(rename = "icon")]
1342 pub icon: WorkbookIcon,
1343 #[serde(rename = "key")]
1344 pub key: i32,
1345 #[serde(rename = "sortOn")]
1346 pub sort_on: String,
1347}
1348
1349#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1350pub struct WorkbookWorksheetProtectionOptions {
1351 #[serde(rename = "allowAutoFilter")]
1352 pub allow_auto_filter: bool,
1353 #[serde(rename = "allowDeleteColumns")]
1354 pub allow_delete_columns: bool,
1355 #[serde(rename = "allowDeleteRows")]
1356 pub allow_delete_rows: bool,
1357 #[serde(rename = "allowFormatCells")]
1358 pub allow_format_cells: bool,
1359 #[serde(rename = "allowFormatColumns")]
1360 pub allow_format_columns: bool,
1361 #[serde(rename = "allowFormatRows")]
1362 pub allow_format_rows: bool,
1363 #[serde(rename = "allowInsertColumns")]
1364 pub allow_insert_columns: bool,
1365 #[serde(rename = "allowInsertHyperlinks")]
1366 pub allow_insert_hyperlinks: bool,
1367 #[serde(rename = "allowInsertRows")]
1368 pub allow_insert_rows: bool,
1369 #[serde(rename = "allowPivotTables")]
1370 pub allow_pivot_tables: bool,
1371 #[serde(rename = "allowSort")]
1372 pub allow_sort: bool,
1373}
1374
1375#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1376pub struct WorkbookFilterDatetime {
1377 #[serde(rename = "date")]
1378 pub date: String,
1379 #[serde(rename = "specificity")]
1380 pub specificity: String,
1381}
1382
1383#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1384pub struct WorkbookRangeReference {
1385 #[serde(rename = "address")]
1386 pub address: String,
1387}
1388
1389#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1390pub struct InvitedUserMessageInfo {
1391 #[serde(rename = "ccRecipients")]
1392 pub cc_recipients: Vec<Recipient>,
1393 #[serde(rename = "messageLanguage")]
1394 pub message_language: String,
1395 #[serde(rename = "customizedMessageBody")]
1396 pub customized_message_body: String,
1397}
1398
1399#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1400pub struct PlannerAppliedCategories {}
1401
1402#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1403pub struct PlannerAssignments {}
1404
1405#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1406pub struct PlannerExternalReference {
1407 #[serde(rename = "alias")]
1408 pub alias: String,
1409 #[serde(rename = "type")]
1410 pub _type: String,
1411 #[serde(rename = "previewPriority")]
1412 pub preview_priority: String,
1413 #[serde(rename = "lastModifiedBy")]
1414 pub last_modified_by: IdentitySet,
1415 #[serde(rename = "lastModifiedDateTime")]
1416 pub last_modified_date_time: String,
1417}
1418
1419#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1420pub struct PlannerChecklistItem {
1421 #[serde(rename = "isChecked")]
1422 pub is_checked: bool,
1423 #[serde(rename = "title")]
1424 pub title: String,
1425 #[serde(rename = "orderHint")]
1426 pub order_hint: String,
1427 #[serde(rename = "lastModifiedBy")]
1428 pub last_modified_by: IdentitySet,
1429 #[serde(rename = "lastModifiedDateTime")]
1430 pub last_modified_date_time: String,
1431}
1432
1433#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1434pub struct PlannerAssignment {
1435 #[serde(rename = "assignedBy")]
1436 pub assigned_by: IdentitySet,
1437 #[serde(rename = "assignedDateTime")]
1438 pub assigned_date_time: String,
1439 #[serde(rename = "orderHint")]
1440 pub order_hint: String,
1441}
1442
1443#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1444pub struct PlannerExternalReferences {}
1445
1446#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1447pub struct PlannerChecklistItems {}
1448
1449#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1450pub struct PlannerOrderHintsByAssignee {}
1451
1452#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1453pub struct PlannerUserIds {}
1454
1455#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1456pub struct PlannerCategoryDescriptions {
1457 #[serde(rename = "category1")]
1458 pub category1: String,
1459 #[serde(rename = "category2")]
1460 pub category2: String,
1461 #[serde(rename = "category3")]
1462 pub category3: String,
1463 #[serde(rename = "category4")]
1464 pub category4: String,
1465 #[serde(rename = "category5")]
1466 pub category5: String,
1467 #[serde(rename = "category6")]
1468 pub category6: String,
1469}
1470
1471#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1472pub struct NotebookLinks {
1473 #[serde(rename = "oneNoteClientUrl")]
1474 pub one_note_client_url: ExternalLink,
1475 #[serde(rename = "oneNoteWebUrl")]
1476 pub one_note_web_url: ExternalLink,
1477}
1478
1479#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1480pub struct ExternalLink {
1481 #[serde(rename = "href")]
1482 pub href: String,
1483}
1484
1485#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1486pub struct SectionLinks {
1487 #[serde(rename = "oneNoteClientUrl")]
1488 pub one_note_client_url: ExternalLink,
1489 #[serde(rename = "oneNoteWebUrl")]
1490 pub one_note_web_url: ExternalLink,
1491}
1492
1493#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1494pub struct PageLinks {
1495 #[serde(rename = "oneNoteClientUrl")]
1496 pub one_note_client_url: ExternalLink,
1497 #[serde(rename = "oneNoteWebUrl")]
1498 pub one_note_web_url: ExternalLink,
1499}
1500
1501#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1502pub struct OnenoteOperationError {
1503 #[serde(rename = "code")]
1504 pub code: String,
1505 #[serde(rename = "message")]
1506 pub message: String,
1507}
1508
1509#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1510pub struct Diagnostic {
1511 #[serde(rename = "message")]
1512 pub message: String,
1513 #[serde(rename = "url")]
1514 pub url: String,
1515}
1516
1517#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1518pub struct OnenotePatchContentCommand {
1519 #[serde(rename = "action")]
1520 pub action: OnenotePatchActionType,
1521 #[serde(rename = "target")]
1522 pub target: String,
1523 #[serde(rename = "content")]
1524 pub content: String,
1525 #[serde(rename = "position")]
1526 pub position: OnenotePatchInsertPosition,
1527}
1528
1529#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1530pub struct OnenotePagePreview {
1531 #[serde(rename = "previewText")]
1532 pub preview_text: String,
1533 #[serde(rename = "links")]
1534 pub links: OnenotePagePreviewLinks,
1535}
1536
1537#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1538pub struct OnenotePagePreviewLinks {
1539 #[serde(rename = "previewImageUrl")]
1540 pub preview_image_url: ExternalLink,
1541}
1542
1543#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1544pub struct RecentNotebook {
1545 #[serde(rename = "displayName")]
1546 pub display_name: String,
1547 #[serde(rename = "lastAccessedTime")]
1548 pub last_accessed_time: String,
1549 #[serde(rename = "links")]
1550 pub links: RecentNotebookLinks,
1551 #[serde(rename = "sourceService")]
1552 pub source_service: OnenoteSourceService,
1553}
1554
1555#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1556pub struct RecentNotebookLinks {
1557 #[serde(rename = "oneNoteClientUrl")]
1558 pub one_note_client_url: ExternalLink,
1559 #[serde(rename = "oneNoteWebUrl")]
1560 pub one_note_web_url: ExternalLink,
1561}
1562
1563#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1564pub struct CopyNotebookModel {
1565 #[serde(rename = "isDefault")]
1566 pub is_default: bool,
1567 #[serde(rename = "userRole")]
1568 pub user_role: OnenoteUserRole,
1569 #[serde(rename = "isShared")]
1570 pub is_shared: bool,
1571 #[serde(rename = "sectionsUrl")]
1572 pub sections_url: String,
1573 #[serde(rename = "sectionGroupsUrl")]
1574 pub section_groups_url: String,
1575 #[serde(rename = "links")]
1576 pub links: NotebookLinks,
1577 #[serde(rename = "name")]
1578 pub name: String,
1579 #[serde(rename = "createdBy")]
1580 pub created_by: String,
1581 #[serde(rename = "createdByIdentity")]
1582 pub created_by_identity: IdentitySet,
1583 #[serde(rename = "lastModifiedBy")]
1584 pub last_modified_by: String,
1585 #[serde(rename = "lastModifiedByIdentity")]
1586 pub last_modified_by_identity: IdentitySet,
1587 #[serde(rename = "lastModifiedTime")]
1588 pub last_modified_time: String,
1589 #[serde(rename = "id")]
1590 pub id: String,
1591 #[serde(rename = "self")]
1592 pub _self: String,
1593 #[serde(rename = "createdTime")]
1594 pub created_time: String,
1595}
1596
1597#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1598pub struct Report {
1599 #[serde(rename = "content")]
1600 pub content: String,
1601}
1602
1603#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1604pub struct EducationStudent {
1605 #[serde(rename = "graduationYear")]
1606 pub graduation_year: String,
1607 #[serde(rename = "grade")]
1608 pub grade: String,
1609 #[serde(rename = "birthDate")]
1610 pub birth_date: String,
1611 #[serde(rename = "gender")]
1612 pub gender: EducationGender,
1613 #[serde(rename = "studentNumber")]
1614 pub student_number: String,
1615 #[serde(rename = "externalId")]
1616 pub external_id: String,
1617}
1618
1619#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1620pub struct EducationTeacher {
1621 #[serde(rename = "teacherNumber")]
1622 pub teacher_number: String,
1623 #[serde(rename = "externalId")]
1624 pub external_id: String,
1625}
1626
1627#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1628pub struct EducationTerm {
1629 #[serde(rename = "externalId")]
1630 pub external_id: String,
1631 #[serde(rename = "startDate")]
1632 pub start_date: String,
1633 #[serde(rename = "endDate")]
1634 pub end_date: String,
1635 #[serde(rename = "displayName")]
1636 pub display_name: String,
1637}
1638
1639#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1640pub struct DeviceAndAppManagementAssignmentTarget {}
1641
1642#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1643pub struct MobileAppAssignmentSettings {}
1644
1645#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1646pub struct MimeContent {
1647 #[serde(rename = "type")]
1648 pub _type: String,
1649 #[serde(rename = "value")]
1650 pub value: Vec<u8>,
1651}
1652
1653#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1654pub struct FileEncryptionInfo {
1655 #[serde(rename = "encryptionKey")]
1656 pub encryption_key: Vec<u8>,
1657 #[serde(rename = "initializationVector")]
1658 pub initialization_vector: Vec<u8>,
1659 #[serde(rename = "mac")]
1660 pub mac: Vec<u8>,
1661 #[serde(rename = "macKey")]
1662 pub mac_key: Vec<u8>,
1663 #[serde(rename = "profileIdentifier")]
1664 pub profile_identifier: String,
1665 #[serde(rename = "fileDigest")]
1666 pub file_digest: Vec<u8>,
1667 #[serde(rename = "fileDigestAlgorithm")]
1668 pub file_digest_algorithm: String,
1669}
1670
1671#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1672pub struct AllLicensedUsersAssignmentTarget {}
1673
1674#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1675pub struct GroupAssignmentTarget {
1676 #[serde(rename = "groupId")]
1677 pub group_id: String,
1678}
1679
1680#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1681pub struct ExclusionGroupAssignmentTarget {}
1682
1683#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1684pub struct AllDevicesAssignmentTarget {}
1685
1686#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1687pub struct IosLobAppAssignmentSettings {
1688 #[serde(rename = "vpnConfigurationId")]
1689 pub vpn_configuration_id: String,
1690}
1691
1692#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1693pub struct IosStoreAppAssignmentSettings {
1694 #[serde(rename = "vpnConfigurationId")]
1695 pub vpn_configuration_id: String,
1696}
1697
1698#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1699pub struct IosVppAppAssignmentSettings {
1700 #[serde(rename = "useDeviceLicensing")]
1701 pub use_device_licensing: bool,
1702 #[serde(rename = "vpnConfigurationId")]
1703 pub vpn_configuration_id: String,
1704}
1705
1706#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1707pub struct MicrosoftStoreForBusinessAppAssignmentSettings {
1708 #[serde(rename = "useDeviceContext")]
1709 pub use_device_context: bool,
1710}
1711
1712#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1713pub struct AndroidMinimumOperatingSystem {
1714 #[serde(rename = "v4_0")]
1715 pub v4_0: bool,
1716 #[serde(rename = "v4_0_3")]
1717 pub v4_0_3: bool,
1718 #[serde(rename = "v4_1")]
1719 pub v4_1: bool,
1720 #[serde(rename = "v4_2")]
1721 pub v4_2: bool,
1722 #[serde(rename = "v4_3")]
1723 pub v4_3: bool,
1724 #[serde(rename = "v4_4")]
1725 pub v4_4: bool,
1726 #[serde(rename = "v5_0")]
1727 pub v5_0: bool,
1728 #[serde(rename = "v5_1")]
1729 pub v5_1: bool,
1730}
1731
1732#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1733pub struct IosDeviceType {
1734 #[serde(rename = "iPad")]
1735 pub i_pad: bool,
1736 #[serde(rename = "iPhoneAndIPod")]
1737 pub i_phone_and_i_pod: bool,
1738}
1739
1740#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1741pub struct IosMinimumOperatingSystem {
1742 #[serde(rename = "v8_0")]
1743 pub v8_0: bool,
1744 #[serde(rename = "v9_0")]
1745 pub v9_0: bool,
1746 #[serde(rename = "v10_0")]
1747 pub v10_0: bool,
1748 #[serde(rename = "v11_0")]
1749 pub v11_0: bool,
1750 #[serde(rename = "v12_0")]
1751 pub v12_0: bool,
1752}
1753
1754#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1755pub struct WindowsMinimumOperatingSystem {
1756 #[serde(rename = "v8_0")]
1757 pub v8_0: bool,
1758 #[serde(rename = "v8_1")]
1759 pub v8_1: bool,
1760 #[serde(rename = "v10_0")]
1761 pub v10_0: bool,
1762}
1763
1764#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1765pub struct VppLicensingType {
1766 #[serde(rename = "supportsUserLicensing")]
1767 pub supports_user_licensing: bool,
1768 #[serde(rename = "supportsDeviceLicensing")]
1769 pub supports_device_licensing: bool,
1770}
1771
1772#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1773pub struct AppConfigurationSettingItem {
1774 #[serde(rename = "appConfigKey")]
1775 pub app_config_key: String,
1776 #[serde(rename = "appConfigKeyType")]
1777 pub app_config_key_type: MdmAppConfigKeyType,
1778 #[serde(rename = "appConfigKeyValue")]
1779 pub app_config_key_value: String,
1780}
1781
1782#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1783pub struct DeviceManagementSettings {
1784 #[serde(rename = "deviceComplianceCheckinThresholdDays")]
1785 pub device_compliance_checkin_threshold_days: i32,
1786 #[serde(rename = "isScheduledActionEnabled")]
1787 pub is_scheduled_action_enabled: bool,
1788 #[serde(rename = "secureByDefault")]
1789 pub secure_by_default: bool,
1790}
1791
1792#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1793pub struct IntuneBrand {
1794 #[serde(rename = "displayName")]
1795 pub display_name: String,
1796 #[serde(rename = "contactITName")]
1797 pub contact_i_t_name: String,
1798 #[serde(rename = "contactITPhoneNumber")]
1799 pub contact_i_t_phone_number: String,
1800 #[serde(rename = "contactITEmailAddress")]
1801 pub contact_i_t_email_address: String,
1802 #[serde(rename = "contactITNotes")]
1803 pub contact_i_t_notes: String,
1804 #[serde(rename = "privacyUrl")]
1805 pub privacy_url: String,
1806 #[serde(rename = "onlineSupportSiteUrl")]
1807 pub online_support_site_url: String,
1808 #[serde(rename = "onlineSupportSiteName")]
1809 pub online_support_site_name: String,
1810 #[serde(rename = "themeColor")]
1811 pub theme_color: RgbColor,
1812 #[serde(rename = "showLogo")]
1813 pub show_logo: bool,
1814 #[serde(rename = "lightBackgroundLogo")]
1815 pub light_background_logo: MimeContent,
1816 #[serde(rename = "darkBackgroundLogo")]
1817 pub dark_background_logo: MimeContent,
1818 #[serde(rename = "showNameNextToLogo")]
1819 pub show_name_next_to_logo: bool,
1820 #[serde(rename = "showDisplayNameNextToLogo")]
1821 pub show_display_name_next_to_logo: bool,
1822}
1823
1824#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1825pub struct RgbColor {
1826 #[serde(rename = "r")]
1827 pub r: u8,
1828 #[serde(rename = "g")]
1829 pub g: u8,
1830 #[serde(rename = "b")]
1831 pub b: u8,
1832}
1833
1834#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1835pub struct DeviceActionResult {
1836 #[serde(rename = "actionName")]
1837 pub action_name: String,
1838 #[serde(rename = "actionState")]
1839 pub action_state: ActionState,
1840 #[serde(rename = "startDateTime")]
1841 pub start_date_time: String,
1842 #[serde(rename = "lastUpdatedDateTime")]
1843 pub last_updated_date_time: String,
1844}
1845
1846#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1847pub struct ConfigurationManagerClientEnabledFeatures {
1848 #[serde(rename = "inventory")]
1849 pub inventory: bool,
1850 #[serde(rename = "modernApps")]
1851 pub modern_apps: bool,
1852 #[serde(rename = "resourceAccess")]
1853 pub resource_access: bool,
1854 #[serde(rename = "deviceConfiguration")]
1855 pub device_configuration: bool,
1856 #[serde(rename = "compliancePolicy")]
1857 pub compliance_policy: bool,
1858 #[serde(rename = "windowsUpdateForBusiness")]
1859 pub windows_update_for_business: bool,
1860}
1861
1862#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1863pub struct DeviceHealthAttestationState {
1864 #[serde(rename = "lastUpdateDateTime")]
1865 pub last_update_date_time: String,
1866 #[serde(rename = "contentNamespaceUrl")]
1867 pub content_namespace_url: String,
1868 #[serde(rename = "deviceHealthAttestationStatus")]
1869 pub device_health_attestation_status: String,
1870 #[serde(rename = "contentVersion")]
1871 pub content_version: String,
1872 #[serde(rename = "issuedDateTime")]
1873 pub issued_date_time: String,
1874 #[serde(rename = "attestationIdentityKey")]
1875 pub attestation_identity_key: String,
1876 #[serde(rename = "resetCount")]
1877 pub reset_count: i64,
1878 #[serde(rename = "restartCount")]
1879 pub restart_count: i64,
1880 #[serde(rename = "dataExcutionPolicy")]
1881 pub data_excution_policy: String,
1882 #[serde(rename = "bitLockerStatus")]
1883 pub bit_locker_status: String,
1884 #[serde(rename = "bootManagerVersion")]
1885 pub boot_manager_version: String,
1886 #[serde(rename = "codeIntegrityCheckVersion")]
1887 pub code_integrity_check_version: String,
1888 #[serde(rename = "secureBoot")]
1889 pub secure_boot: String,
1890 #[serde(rename = "bootDebugging")]
1891 pub boot_debugging: String,
1892 #[serde(rename = "operatingSystemKernelDebugging")]
1893 pub operating_system_kernel_debugging: String,
1894 #[serde(rename = "codeIntegrity")]
1895 pub code_integrity: String,
1896 #[serde(rename = "testSigning")]
1897 pub test_signing: String,
1898 #[serde(rename = "safeMode")]
1899 pub safe_mode: String,
1900 #[serde(rename = "windowsPE")]
1901 pub windows_p_e: String,
1902 #[serde(rename = "earlyLaunchAntiMalwareDriverProtection")]
1903 pub early_launch_anti_malware_driver_protection: String,
1904 #[serde(rename = "virtualSecureMode")]
1905 pub virtual_secure_mode: String,
1906 #[serde(rename = "pcrHashAlgorithm")]
1907 pub pcr_hash_algorithm: String,
1908 #[serde(rename = "bootAppSecurityVersion")]
1909 pub boot_app_security_version: String,
1910 #[serde(rename = "bootManagerSecurityVersion")]
1911 pub boot_manager_security_version: String,
1912 #[serde(rename = "tpmVersion")]
1913 pub tpm_version: String,
1914 #[serde(rename = "pcr0")]
1915 pub pcr0: String,
1916 #[serde(rename = "secureBootConfigurationPolicyFingerPrint")]
1917 pub secure_boot_configuration_policy_finger_print: String,
1918 #[serde(rename = "codeIntegrityPolicy")]
1919 pub code_integrity_policy: String,
1920 #[serde(rename = "bootRevisionListInfo")]
1921 pub boot_revision_list_info: String,
1922 #[serde(rename = "operatingSystemRevListInfo")]
1923 pub operating_system_rev_list_info: String,
1924 #[serde(rename = "healthStatusMismatchInfo")]
1925 pub health_status_mismatch_info: String,
1926 #[serde(rename = "healthAttestationSupportedStatus")]
1927 pub health_attestation_supported_status: String,
1928}
1929
1930#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1931pub struct UpdateWindowsDeviceAccountActionParameter {
1932 #[serde(rename = "deviceAccount")]
1933 pub device_account: WindowsDeviceAccount,
1934 #[serde(rename = "passwordRotationEnabled")]
1935 pub password_rotation_enabled: bool,
1936 #[serde(rename = "calendarSyncEnabled")]
1937 pub calendar_sync_enabled: bool,
1938 #[serde(rename = "deviceAccountEmail")]
1939 pub device_account_email: String,
1940 #[serde(rename = "exchangeServer")]
1941 pub exchange_server: String,
1942 #[serde(rename = "sessionInitiationProtocalAddress")]
1943 pub session_initiation_protocal_address: String,
1944}
1945
1946#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1947pub struct WindowsDeviceAccount {
1948 #[serde(rename = "password")]
1949 pub password: String,
1950}
1951
1952#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1953pub struct WindowsDefenderScanActionResult {
1954 #[serde(rename = "scanType")]
1955 pub scan_type: String,
1956}
1957
1958#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1959pub struct DeleteUserFromSharedAppleDeviceActionResult {
1960 #[serde(rename = "userPrincipalName")]
1961 pub user_principal_name: String,
1962}
1963
1964#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1965pub struct DeviceGeoLocation {
1966 #[serde(rename = "lastCollectedDateTime")]
1967 pub last_collected_date_time: String,
1968 #[serde(rename = "longitude")]
1969 pub longitude: i64,
1970 #[serde(rename = "latitude")]
1971 pub latitude: i64,
1972 #[serde(rename = "altitude")]
1973 pub altitude: i64,
1974 #[serde(rename = "horizontalAccuracy")]
1975 pub horizontal_accuracy: i64,
1976 #[serde(rename = "verticalAccuracy")]
1977 pub vertical_accuracy: i64,
1978 #[serde(rename = "heading")]
1979 pub heading: i64,
1980 #[serde(rename = "speed")]
1981 pub speed: i64,
1982}
1983
1984#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1985pub struct LocateDeviceActionResult {
1986 #[serde(rename = "deviceLocation")]
1987 pub device_location: DeviceGeoLocation,
1988}
1989
1990#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1991pub struct RemoteLockActionResult {
1992 #[serde(rename = "unlockPin")]
1993 pub unlock_pin: String,
1994}
1995
1996#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
1997pub struct ResetPasscodeActionResult {
1998 #[serde(rename = "passcode")]
1999 pub passcode: String,
2000}
2001
2002#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2003pub struct DeviceOperatingSystemSummary {
2004 #[serde(rename = "androidCount")]
2005 pub android_count: i32,
2006 #[serde(rename = "iosCount")]
2007 pub ios_count: i32,
2008 #[serde(rename = "macOSCount")]
2009 pub mac_o_s_count: i32,
2010 #[serde(rename = "windowsMobileCount")]
2011 pub windows_mobile_count: i32,
2012 #[serde(rename = "windowsCount")]
2013 pub windows_count: i32,
2014 #[serde(rename = "unknownCount")]
2015 pub unknown_count: i32,
2016}
2017
2018#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2019pub struct DeviceExchangeAccessStateSummary {
2020 #[serde(rename = "allowedDeviceCount")]
2021 pub allowed_device_count: i32,
2022 #[serde(rename = "blockedDeviceCount")]
2023 pub blocked_device_count: i32,
2024 #[serde(rename = "quarantinedDeviceCount")]
2025 pub quarantined_device_count: i32,
2026 #[serde(rename = "unknownDeviceCount")]
2027 pub unknown_device_count: i32,
2028 #[serde(rename = "unavailableDeviceCount")]
2029 pub unavailable_device_count: i32,
2030}
2031
2032#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2033pub struct WindowsDeviceADAccount {
2034 #[serde(rename = "domainName")]
2035 pub domain_name: String,
2036 #[serde(rename = "userName")]
2037 pub user_name: String,
2038}
2039
2040#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2041pub struct WindowsDeviceAzureADAccount {
2042 #[serde(rename = "userPrincipalName")]
2043 pub user_principal_name: String,
2044}
2045
2046#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2047pub struct AppListItem {
2048 #[serde(rename = "name")]
2049 pub name: String,
2050 #[serde(rename = "publisher")]
2051 pub publisher: String,
2052 #[serde(rename = "appStoreUrl")]
2053 pub app_store_url: String,
2054 #[serde(rename = "appId")]
2055 pub app_id: String,
2056}
2057
2058#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2059pub struct OmaSetting {
2060 #[serde(rename = "displayName")]
2061 pub display_name: String,
2062 #[serde(rename = "description")]
2063 pub description: String,
2064 #[serde(rename = "omaUri")]
2065 pub oma_uri: String,
2066}
2067
2068#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2069pub struct OmaSettingInteger {
2070 #[serde(rename = "value")]
2071 pub value: i32,
2072}
2073
2074#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2075pub struct OmaSettingFloatingPoint {
2076 #[serde(rename = "value")]
2077 pub value: String,
2078}
2079
2080#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2081pub struct OmaSettingString {
2082 #[serde(rename = "value")]
2083 pub value: String,
2084}
2085
2086#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2087pub struct OmaSettingDateTime {
2088 #[serde(rename = "value")]
2089 pub value: String,
2090}
2091
2092#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2093pub struct OmaSettingStringXml {
2094 #[serde(rename = "fileName")]
2095 pub file_name: String,
2096 #[serde(rename = "value")]
2097 pub value: Vec<u8>,
2098}
2099
2100#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2101pub struct OmaSettingBoolean {
2102 #[serde(rename = "value")]
2103 pub value: bool,
2104}
2105
2106#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2107pub struct OmaSettingBase64 {
2108 #[serde(rename = "fileName")]
2109 pub file_name: String,
2110 #[serde(rename = "value")]
2111 pub value: String,
2112}
2113
2114#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2115pub struct MediaContentRatingAustralia {
2116 #[serde(rename = "movieRating")]
2117 pub movie_rating: RatingAustraliaMoviesType,
2118 #[serde(rename = "tvRating")]
2119 pub tv_rating: RatingAustraliaTelevisionType,
2120}
2121
2122#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2123pub struct MediaContentRatingCanada {
2124 #[serde(rename = "movieRating")]
2125 pub movie_rating: RatingCanadaMoviesType,
2126 #[serde(rename = "tvRating")]
2127 pub tv_rating: RatingCanadaTelevisionType,
2128}
2129
2130#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2131pub struct MediaContentRatingFrance {
2132 #[serde(rename = "movieRating")]
2133 pub movie_rating: RatingFranceMoviesType,
2134 #[serde(rename = "tvRating")]
2135 pub tv_rating: RatingFranceTelevisionType,
2136}
2137
2138#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2139pub struct MediaContentRatingGermany {
2140 #[serde(rename = "movieRating")]
2141 pub movie_rating: RatingGermanyMoviesType,
2142 #[serde(rename = "tvRating")]
2143 pub tv_rating: RatingGermanyTelevisionType,
2144}
2145
2146#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2147pub struct MediaContentRatingIreland {
2148 #[serde(rename = "movieRating")]
2149 pub movie_rating: RatingIrelandMoviesType,
2150 #[serde(rename = "tvRating")]
2151 pub tv_rating: RatingIrelandTelevisionType,
2152}
2153
2154#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2155pub struct MediaContentRatingJapan {
2156 #[serde(rename = "movieRating")]
2157 pub movie_rating: RatingJapanMoviesType,
2158 #[serde(rename = "tvRating")]
2159 pub tv_rating: RatingJapanTelevisionType,
2160}
2161
2162#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2163pub struct MediaContentRatingNewZealand {
2164 #[serde(rename = "movieRating")]
2165 pub movie_rating: RatingNewZealandMoviesType,
2166 #[serde(rename = "tvRating")]
2167 pub tv_rating: RatingNewZealandTelevisionType,
2168}
2169
2170#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2171pub struct MediaContentRatingUnitedKingdom {
2172 #[serde(rename = "movieRating")]
2173 pub movie_rating: RatingUnitedKingdomMoviesType,
2174 #[serde(rename = "tvRating")]
2175 pub tv_rating: RatingUnitedKingdomTelevisionType,
2176}
2177
2178#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2179pub struct MediaContentRatingUnitedStates {
2180 #[serde(rename = "movieRating")]
2181 pub movie_rating: RatingUnitedStatesMoviesType,
2182 #[serde(rename = "tvRating")]
2183 pub tv_rating: RatingUnitedStatesTelevisionType,
2184}
2185
2186#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2187pub struct IosNetworkUsageRule {
2188 #[serde(rename = "managedApps")]
2189 pub managed_apps: Vec<AppListItem>,
2190 #[serde(rename = "cellularDataBlockWhenRoaming")]
2191 pub cellular_data_block_when_roaming: bool,
2192 #[serde(rename = "cellularDataBlocked")]
2193 pub cellular_data_blocked: bool,
2194}
2195
2196#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2197pub struct IosHomeScreenItem {
2198 #[serde(rename = "displayName")]
2199 pub display_name: String,
2200}
2201
2202#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2203pub struct IosHomeScreenPage {
2204 #[serde(rename = "displayName")]
2205 pub display_name: String,
2206 #[serde(rename = "icons")]
2207 pub icons: Vec<IosHomeScreenItem>,
2208}
2209
2210#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2211pub struct IosNotificationSettings {
2212 #[serde(rename = "bundleID")]
2213 pub bundle_i_d: String,
2214 #[serde(rename = "appName")]
2215 pub app_name: String,
2216 #[serde(rename = "publisher")]
2217 pub publisher: String,
2218 #[serde(rename = "enabled")]
2219 pub enabled: bool,
2220 #[serde(rename = "showInNotificationCenter")]
2221 pub show_in_notification_center: bool,
2222 #[serde(rename = "showOnLockScreen")]
2223 pub show_on_lock_screen: bool,
2224 #[serde(rename = "alertType")]
2225 pub alert_type: IosNotificationAlertType,
2226 #[serde(rename = "badgesEnabled")]
2227 pub badges_enabled: bool,
2228 #[serde(rename = "soundsEnabled")]
2229 pub sounds_enabled: bool,
2230}
2231
2232#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2233pub struct IosHomeScreenFolder {
2234 #[serde(rename = "pages")]
2235 pub pages: Vec<IosHomeScreenFolderPage>,
2236}
2237
2238#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2239pub struct IosHomeScreenFolderPage {
2240 #[serde(rename = "displayName")]
2241 pub display_name: String,
2242 #[serde(rename = "apps")]
2243 pub apps: Vec<IosHomeScreenApp>,
2244}
2245
2246#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2247pub struct IosHomeScreenApp {
2248 #[serde(rename = "bundleID")]
2249 pub bundle_i_d: String,
2250}
2251
2252#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2253pub struct WindowsFirewallNetworkProfile {
2254 #[serde(rename = "firewallEnabled")]
2255 pub firewall_enabled: StateManagementSetting,
2256 #[serde(rename = "stealthModeBlocked")]
2257 pub stealth_mode_blocked: bool,
2258 #[serde(rename = "incomingTrafficBlocked")]
2259 pub incoming_traffic_blocked: bool,
2260 #[serde(rename = "unicastResponsesToMulticastBroadcastsBlocked")]
2261 pub unicast_responses_to_multicast_broadcasts_blocked: bool,
2262 #[serde(rename = "inboundNotificationsBlocked")]
2263 pub inbound_notifications_blocked: bool,
2264 #[serde(rename = "authorizedApplicationRulesFromGroupPolicyMerged")]
2265 pub authorized_application_rules_from_group_policy_merged: bool,
2266 #[serde(rename = "globalPortRulesFromGroupPolicyMerged")]
2267 pub global_port_rules_from_group_policy_merged: bool,
2268 #[serde(rename = "connectionSecurityRulesFromGroupPolicyMerged")]
2269 pub connection_security_rules_from_group_policy_merged: bool,
2270 #[serde(rename = "outboundConnectionsBlocked")]
2271 pub outbound_connections_blocked: bool,
2272 #[serde(rename = "inboundConnectionsBlocked")]
2273 pub inbound_connections_blocked: bool,
2274 #[serde(rename = "securedPacketExemptionAllowed")]
2275 pub secured_packet_exemption_allowed: bool,
2276 #[serde(rename = "policyRulesFromGroupPolicyMerged")]
2277 pub policy_rules_from_group_policy_merged: bool,
2278}
2279
2280#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2281pub struct BitLockerRemovableDrivePolicy {
2282 #[serde(rename = "encryptionMethod")]
2283 pub encryption_method: BitLockerEncryptionMethod,
2284 #[serde(rename = "requireEncryptionForWriteAccess")]
2285 pub require_encryption_for_write_access: bool,
2286 #[serde(rename = "blockCrossOrganizationWriteAccess")]
2287 pub block_cross_organization_write_access: bool,
2288}
2289
2290#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2291pub struct DefenderDetectedMalwareActions {
2292 #[serde(rename = "lowSeverity")]
2293 pub low_severity: DefenderThreatAction,
2294 #[serde(rename = "moderateSeverity")]
2295 pub moderate_severity: DefenderThreatAction,
2296 #[serde(rename = "highSeverity")]
2297 pub high_severity: DefenderThreatAction,
2298 #[serde(rename = "severeSeverity")]
2299 pub severe_severity: DefenderThreatAction,
2300}
2301
2302#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2303pub struct Windows10NetworkProxyServer {
2304 #[serde(rename = "address")]
2305 pub address: String,
2306 #[serde(rename = "exceptions")]
2307 pub exceptions: Vec<String>,
2308 #[serde(rename = "useForLocalAddresses")]
2309 pub use_for_local_addresses: bool,
2310}
2311
2312#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2313pub struct EdgeSearchEngineBase {}
2314
2315#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2316pub struct EdgeSearchEngineCustom {
2317 #[serde(rename = "edgeSearchEngineOpenSearchXmlUrl")]
2318 pub edge_search_engine_open_search_xml_url: String,
2319}
2320
2321#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2322pub struct EdgeSearchEngine {
2323 #[serde(rename = "edgeSearchEngineType")]
2324 pub edge_search_engine_type: EdgeSearchEngineType,
2325}
2326
2327#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2328pub struct SharedPCAccountManagerPolicy {
2329 #[serde(rename = "accountDeletionPolicy")]
2330 pub account_deletion_policy: SharedPCAccountDeletionPolicyType,
2331 #[serde(rename = "cacheAccountsAboveDiskFreePercentage")]
2332 pub cache_accounts_above_disk_free_percentage: i32,
2333 #[serde(rename = "inactiveThresholdDays")]
2334 pub inactive_threshold_days: i32,
2335 #[serde(rename = "removeAccountsBelowDiskFreePercentage")]
2336 pub remove_accounts_below_disk_free_percentage: i32,
2337}
2338
2339#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2340pub struct WindowsUpdateInstallScheduleType {}
2341
2342#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2343pub struct WindowsUpdateScheduledInstall {
2344 #[serde(rename = "scheduledInstallDay")]
2345 pub scheduled_install_day: WeeklySchedule,
2346 #[serde(rename = "scheduledInstallTime")]
2347 pub scheduled_install_time: String,
2348}
2349
2350#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2351pub struct WindowsUpdateActiveHoursInstall {
2352 #[serde(rename = "activeHoursStart")]
2353 pub active_hours_start: String,
2354 #[serde(rename = "activeHoursEnd")]
2355 pub active_hours_end: String,
2356}
2357
2358#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2359pub struct DeviceConfigurationSettingState {
2360 #[serde(rename = "setting")]
2361 pub setting: String,
2362 #[serde(rename = "settingName")]
2363 pub setting_name: String,
2364 #[serde(rename = "instanceDisplayName")]
2365 pub instance_display_name: String,
2366 #[serde(rename = "state")]
2367 pub state: ComplianceStatus,
2368 #[serde(rename = "errorCode")]
2369 pub error_code: i64,
2370 #[serde(rename = "errorDescription")]
2371 pub error_description: String,
2372 #[serde(rename = "userId")]
2373 pub user_id: String,
2374 #[serde(rename = "userName")]
2375 pub user_name: String,
2376 #[serde(rename = "userEmail")]
2377 pub user_email: String,
2378 #[serde(rename = "userPrincipalName")]
2379 pub user_principal_name: String,
2380 #[serde(rename = "sources")]
2381 pub sources: Vec<SettingSource>,
2382 #[serde(rename = "currentValue")]
2383 pub current_value: String,
2384}
2385
2386#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2387pub struct SettingSource {
2388 #[serde(rename = "id")]
2389 pub id: String,
2390 #[serde(rename = "displayName")]
2391 pub display_name: String,
2392}
2393
2394#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2395pub struct DeviceCompliancePolicySettingState {
2396 #[serde(rename = "setting")]
2397 pub setting: String,
2398 #[serde(rename = "settingName")]
2399 pub setting_name: String,
2400 #[serde(rename = "instanceDisplayName")]
2401 pub instance_display_name: String,
2402 #[serde(rename = "state")]
2403 pub state: ComplianceStatus,
2404 #[serde(rename = "errorCode")]
2405 pub error_code: i64,
2406 #[serde(rename = "errorDescription")]
2407 pub error_description: String,
2408 #[serde(rename = "userId")]
2409 pub user_id: String,
2410 #[serde(rename = "userName")]
2411 pub user_name: String,
2412 #[serde(rename = "userEmail")]
2413 pub user_email: String,
2414 #[serde(rename = "userPrincipalName")]
2415 pub user_principal_name: String,
2416 #[serde(rename = "sources")]
2417 pub sources: Vec<SettingSource>,
2418 #[serde(rename = "currentValue")]
2419 pub current_value: String,
2420}
2421
2422#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2423pub struct DeviceEnrollmentPlatformRestriction {
2424 #[serde(rename = "platformBlocked")]
2425 pub platform_blocked: bool,
2426 #[serde(rename = "personalDeviceEnrollmentBlocked")]
2427 pub personal_device_enrollment_blocked: bool,
2428 #[serde(rename = "osMinimumVersion")]
2429 pub os_minimum_version: String,
2430 #[serde(rename = "osMaximumVersion")]
2431 pub os_maximum_version: String,
2432}
2433
2434#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2435pub struct MobileAppIdentifier {}
2436
2437#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2438pub struct ManagedAppDiagnosticStatus {
2439 #[serde(rename = "validationName")]
2440 pub validation_name: String,
2441 #[serde(rename = "state")]
2442 pub state: String,
2443 #[serde(rename = "mitigationInstruction")]
2444 pub mitigation_instruction: String,
2445}
2446
2447#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2448pub struct KeyValuePair {
2449 #[serde(rename = "name")]
2450 pub name: String,
2451 #[serde(rename = "value")]
2452 pub value: String,
2453}
2454
2455#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2456pub struct WindowsInformationProtectionResourceCollection {
2457 #[serde(rename = "displayName")]
2458 pub display_name: String,
2459 #[serde(rename = "resources")]
2460 pub resources: Vec<String>,
2461}
2462
2463#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2464pub struct WindowsInformationProtectionDataRecoveryCertificate {
2465 #[serde(rename = "subjectName")]
2466 pub subject_name: String,
2467 #[serde(rename = "description")]
2468 pub description: String,
2469 #[serde(rename = "expirationDateTime")]
2470 pub expiration_date_time: String,
2471 #[serde(rename = "certificate")]
2472 pub certificate: Vec<u8>,
2473}
2474
2475#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2476pub struct WindowsInformationProtectionApp {
2477 #[serde(rename = "displayName")]
2478 pub display_name: String,
2479 #[serde(rename = "description")]
2480 pub description: String,
2481 #[serde(rename = "publisherName")]
2482 pub publisher_name: String,
2483 #[serde(rename = "productName")]
2484 pub product_name: String,
2485 #[serde(rename = "denied")]
2486 pub denied: bool,
2487}
2488
2489#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2490pub struct WindowsInformationProtectionProxiedDomainCollection {
2491 #[serde(rename = "displayName")]
2492 pub display_name: String,
2493 #[serde(rename = "proxiedDomains")]
2494 pub proxied_domains: Vec<ProxiedDomain>,
2495}
2496
2497#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2498pub struct ProxiedDomain {
2499 #[serde(rename = "ipAddressOrFQDN")]
2500 pub ip_address_or_f_q_d_n: String,
2501 #[serde(rename = "proxy")]
2502 pub proxy: String,
2503}
2504
2505#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2506pub struct WindowsInformationProtectionIPRangeCollection {
2507 #[serde(rename = "displayName")]
2508 pub display_name: String,
2509 #[serde(rename = "ranges")]
2510 pub ranges: Vec<IpRange>,
2511}
2512
2513#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2514pub struct IpRange {}
2515
2516#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2517pub struct AndroidMobileAppIdentifier {
2518 #[serde(rename = "packageId")]
2519 pub package_id: String,
2520}
2521
2522#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2523pub struct IosMobileAppIdentifier {
2524 #[serde(rename = "bundleId")]
2525 pub bundle_id: String,
2526}
2527
2528#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2529pub struct ManagedAppPolicyDeploymentSummaryPerApp {
2530 #[serde(rename = "mobileAppIdentifier")]
2531 pub mobile_app_identifier: MobileAppIdentifier,
2532 #[serde(rename = "configurationAppliedUserCount")]
2533 pub configuration_applied_user_count: i32,
2534}
2535
2536#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2537pub struct WindowsInformationProtectionStoreApp {}
2538
2539#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2540pub struct WindowsInformationProtectionDesktopApp {
2541 #[serde(rename = "binaryName")]
2542 pub binary_name: String,
2543 #[serde(rename = "binaryVersionLow")]
2544 pub binary_version_low: String,
2545 #[serde(rename = "binaryVersionHigh")]
2546 pub binary_version_high: String,
2547}
2548
2549#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2550pub struct IPv6Range {
2551 #[serde(rename = "lowerAddress")]
2552 pub lower_address: String,
2553 #[serde(rename = "upperAddress")]
2554 pub upper_address: String,
2555}
2556
2557#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2558pub struct IPv4Range {
2559 #[serde(rename = "lowerAddress")]
2560 pub lower_address: String,
2561 #[serde(rename = "upperAddress")]
2562 pub upper_address: String,
2563}
2564
2565#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2566pub struct RolePermission {
2567 #[serde(rename = "resourceActions")]
2568 pub resource_actions: Vec<ResourceAction>,
2569}
2570
2571#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2572pub struct ResourceAction {
2573 #[serde(rename = "allowedResourceActions")]
2574 pub allowed_resource_actions: Vec<String>,
2575 #[serde(rename = "notAllowedResourceActions")]
2576 pub not_allowed_resource_actions: Vec<String>,
2577}
2578
2579#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2580pub struct ImageInfo {
2581 #[serde(rename = "iconUrl")]
2582 pub icon_url: String,
2583 #[serde(rename = "alternativeText")]
2584 pub alternative_text: String,
2585 #[serde(rename = "alternateText")]
2586 pub alternate_text: String,
2587 #[serde(rename = "addImageQuery")]
2588 pub add_image_query: bool,
2589}
2590
2591#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2592pub struct VisualInfo {
2593 #[serde(rename = "attribution")]
2594 pub attribution: ImageInfo,
2595 #[serde(rename = "backgroundColor")]
2596 pub background_color: String,
2597 #[serde(rename = "description")]
2598 pub description: String,
2599 #[serde(rename = "displayText")]
2600 pub display_text: String,
2601 #[serde(rename = "content")]
2602 pub content: Json,
2603}
2604
2605#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2606pub struct CloudAppSecurityState {
2607 #[serde(rename = "destinationServiceIp")]
2608 pub destination_service_ip: String,
2609 #[serde(rename = "destinationServiceName")]
2610 pub destination_service_name: String,
2611 #[serde(rename = "riskScore")]
2612 pub risk_score: String,
2613}
2614
2615#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2616pub struct FileSecurityState {
2617 #[serde(rename = "fileHash")]
2618 pub file_hash: FileHash,
2619 #[serde(rename = "name")]
2620 pub name: String,
2621 #[serde(rename = "path")]
2622 pub path: String,
2623 #[serde(rename = "riskScore")]
2624 pub risk_score: String,
2625}
2626
2627#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2628pub struct FileHash {
2629 #[serde(rename = "hashType")]
2630 pub hash_type: FileHashType,
2631 #[serde(rename = "hashValue")]
2632 pub hash_value: String,
2633}
2634
2635#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2636pub struct AlertHistoryState {
2637 #[serde(rename = "appId")]
2638 pub app_id: String,
2639 #[serde(rename = "assignedTo")]
2640 pub assigned_to: String,
2641 #[serde(rename = "comments")]
2642 pub comments: Vec<String>,
2643 #[serde(rename = "feedback")]
2644 pub feedback: AlertFeedback,
2645 #[serde(rename = "status")]
2646 pub status: AlertStatus,
2647 #[serde(rename = "updatedDateTime")]
2648 pub updated_date_time: String,
2649 #[serde(rename = "user")]
2650 pub user: String,
2651}
2652
2653#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2654pub struct HostSecurityState {
2655 #[serde(rename = "fqdn")]
2656 pub fqdn: String,
2657 #[serde(rename = "isAzureAdJoined")]
2658 pub is_azure_ad_joined: bool,
2659 #[serde(rename = "isAzureAdRegistered")]
2660 pub is_azure_ad_registered: bool,
2661 #[serde(rename = "isHybridAzureDomainJoined")]
2662 pub is_hybrid_azure_domain_joined: bool,
2663 #[serde(rename = "netBiosName")]
2664 pub net_bios_name: String,
2665 #[serde(rename = "os")]
2666 pub os: String,
2667 #[serde(rename = "privateIpAddress")]
2668 pub private_ip_address: String,
2669 #[serde(rename = "publicIpAddress")]
2670 pub public_ip_address: String,
2671 #[serde(rename = "riskScore")]
2672 pub risk_score: String,
2673}
2674
2675#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2676pub struct MalwareState {
2677 #[serde(rename = "category")]
2678 pub category: String,
2679 #[serde(rename = "family")]
2680 pub family: String,
2681 #[serde(rename = "name")]
2682 pub name: String,
2683 #[serde(rename = "severity")]
2684 pub severity: String,
2685 #[serde(rename = "wasRunning")]
2686 pub was_running: bool,
2687}
2688
2689#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2690pub struct NetworkConnection {
2691 #[serde(rename = "applicationName")]
2692 pub application_name: String,
2693 #[serde(rename = "destinationAddress")]
2694 pub destination_address: String,
2695 #[serde(rename = "destinationDomain")]
2696 pub destination_domain: String,
2697 #[serde(rename = "destinationPort")]
2698 pub destination_port: String,
2699 #[serde(rename = "destinationUrl")]
2700 pub destination_url: String,
2701 #[serde(rename = "direction")]
2702 pub direction: ConnectionDirection,
2703 #[serde(rename = "domainRegisteredDateTime")]
2704 pub domain_registered_date_time: String,
2705 #[serde(rename = "localDnsName")]
2706 pub local_dns_name: String,
2707 #[serde(rename = "natDestinationAddress")]
2708 pub nat_destination_address: String,
2709 #[serde(rename = "natDestinationPort")]
2710 pub nat_destination_port: String,
2711 #[serde(rename = "natSourceAddress")]
2712 pub nat_source_address: String,
2713 #[serde(rename = "natSourcePort")]
2714 pub nat_source_port: String,
2715 #[serde(rename = "protocol")]
2716 pub protocol: SecurityNetworkProtocol,
2717 #[serde(rename = "riskScore")]
2718 pub risk_score: String,
2719 #[serde(rename = "sourceAddress")]
2720 pub source_address: String,
2721 #[serde(rename = "sourcePort")]
2722 pub source_port: String,
2723 #[serde(rename = "status")]
2724 pub status: ConnectionStatus,
2725 #[serde(rename = "urlParameters")]
2726 pub url_parameters: String,
2727}
2728
2729#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2730pub struct Process {
2731 #[serde(rename = "accountName")]
2732 pub account_name: String,
2733 #[serde(rename = "commandLine")]
2734 pub command_line: String,
2735 #[serde(rename = "createdDateTime")]
2736 pub created_date_time: String,
2737 #[serde(rename = "fileHash")]
2738 pub file_hash: FileHash,
2739 #[serde(rename = "integrityLevel")]
2740 pub integrity_level: ProcessIntegrityLevel,
2741 #[serde(rename = "isElevated")]
2742 pub is_elevated: bool,
2743 #[serde(rename = "name")]
2744 pub name: String,
2745 #[serde(rename = "parentProcessCreatedDateTime")]
2746 pub parent_process_created_date_time: String,
2747 #[serde(rename = "parentProcessId")]
2748 pub parent_process_id: i32,
2749 #[serde(rename = "parentProcessName")]
2750 pub parent_process_name: String,
2751 #[serde(rename = "path")]
2752 pub path: String,
2753 #[serde(rename = "processId")]
2754 pub process_id: i32,
2755}
2756
2757#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2758pub struct RegistryKeyState {
2759 #[serde(rename = "hive")]
2760 pub hive: RegistryHive,
2761 #[serde(rename = "key")]
2762 pub key: String,
2763 #[serde(rename = "oldKey")]
2764 pub old_key: String,
2765 #[serde(rename = "oldValueData")]
2766 pub old_value_data: String,
2767 #[serde(rename = "oldValueName")]
2768 pub old_value_name: String,
2769 #[serde(rename = "operation")]
2770 pub operation: RegistryOperation,
2771 #[serde(rename = "processId")]
2772 pub process_id: i32,
2773 #[serde(rename = "valueData")]
2774 pub value_data: String,
2775 #[serde(rename = "valueName")]
2776 pub value_name: String,
2777 #[serde(rename = "valueType")]
2778 pub value_type: RegistryValueType,
2779}
2780
2781#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2782pub struct AlertTrigger {
2783 #[serde(rename = "name")]
2784 pub name: String,
2785 #[serde(rename = "type")]
2786 pub _type: String,
2787 #[serde(rename = "value")]
2788 pub value: String,
2789}
2790
2791#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2792pub struct UserSecurityState {
2793 #[serde(rename = "aadUserId")]
2794 pub aad_user_id: String,
2795 #[serde(rename = "accountName")]
2796 pub account_name: String,
2797 #[serde(rename = "domainName")]
2798 pub domain_name: String,
2799 #[serde(rename = "emailRole")]
2800 pub email_role: EmailRole,
2801 #[serde(rename = "isVpn")]
2802 pub is_vpn: bool,
2803 #[serde(rename = "logonDateTime")]
2804 pub logon_date_time: String,
2805 #[serde(rename = "logonId")]
2806 pub logon_id: String,
2807 #[serde(rename = "logonIp")]
2808 pub logon_ip: String,
2809 #[serde(rename = "logonLocation")]
2810 pub logon_location: String,
2811 #[serde(rename = "logonType")]
2812 pub logon_type: LogonType,
2813 #[serde(rename = "onPremisesSecurityIdentifier")]
2814 pub on_premises_security_identifier: String,
2815 #[serde(rename = "riskScore")]
2816 pub risk_score: String,
2817 #[serde(rename = "userAccountType")]
2818 pub user_account_type: UserAccountSecurityType,
2819 #[serde(rename = "userPrincipalName")]
2820 pub user_principal_name: String,
2821}
2822
2823#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2824pub struct SecurityVendorInformation {
2825 #[serde(rename = "provider")]
2826 pub provider: String,
2827 #[serde(rename = "providerVersion")]
2828 pub provider_version: String,
2829 #[serde(rename = "subProvider")]
2830 pub sub_provider: String,
2831 #[serde(rename = "vendor")]
2832 pub vendor: String,
2833}
2834
2835#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2836pub struct VulnerabilityState {
2837 #[serde(rename = "cve")]
2838 pub cve: String,
2839 #[serde(rename = "severity")]
2840 pub severity: String,
2841 #[serde(rename = "wasRunning")]
2842 pub was_running: bool,
2843}
2844
2845#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2846pub struct AverageComparativeScore {
2847 #[serde(rename = "averageScore")]
2848 pub average_score: i64,
2849 #[serde(rename = "basis")]
2850 pub basis: String,
2851}
2852
2853#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2854pub struct ControlScore {
2855 #[serde(rename = "controlCategory")]
2856 pub control_category: String,
2857 #[serde(rename = "controlName")]
2858 pub control_name: String,
2859 #[serde(rename = "description")]
2860 pub description: String,
2861 #[serde(rename = "score")]
2862 pub score: i64,
2863}
2864
2865#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2866pub struct ComplianceInformation {
2867 #[serde(rename = "certificationControls")]
2868 pub certification_controls: Vec<CertificationControl>,
2869 #[serde(rename = "certificationName")]
2870 pub certification_name: String,
2871}
2872
2873#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2874pub struct CertificationControl {
2875 #[serde(rename = "name")]
2876 pub name: String,
2877 #[serde(rename = "url")]
2878 pub url: String,
2879}
2880
2881#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2882pub struct SecureScoreControlStateUpdate {
2883 #[serde(rename = "assignedTo")]
2884 pub assigned_to: String,
2885 #[serde(rename = "comment")]
2886 pub comment: String,
2887 #[serde(rename = "state")]
2888 pub state: String,
2889 #[serde(rename = "updatedBy")]
2890 pub updated_by: String,
2891 #[serde(rename = "updatedDateTime")]
2892 pub updated_date_time: String,
2893}
2894
2895#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2896pub struct ResourceVisualization {
2897 #[serde(rename = "title")]
2898 pub title: String,
2899 #[serde(rename = "type")]
2900 pub _type: String,
2901 #[serde(rename = "mediaType")]
2902 pub media_type: String,
2903 #[serde(rename = "previewImageUrl")]
2904 pub preview_image_url: String,
2905 #[serde(rename = "previewText")]
2906 pub preview_text: String,
2907 #[serde(rename = "containerWebUrl")]
2908 pub container_web_url: String,
2909 #[serde(rename = "containerDisplayName")]
2910 pub container_display_name: String,
2911 #[serde(rename = "containerType")]
2912 pub container_type: String,
2913}
2914
2915#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2916pub struct ResourceReference {
2917 #[serde(rename = "webUrl")]
2918 pub web_url: String,
2919 #[serde(rename = "id")]
2920 pub id: String,
2921 #[serde(rename = "type")]
2922 pub _type: String,
2923}
2924
2925#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2926pub struct SharingDetail {
2927 #[serde(rename = "sharedBy")]
2928 pub shared_by: InsightIdentity,
2929 #[serde(rename = "sharedDateTime")]
2930 pub shared_date_time: String,
2931 #[serde(rename = "sharingSubject")]
2932 pub sharing_subject: String,
2933 #[serde(rename = "sharingType")]
2934 pub sharing_type: String,
2935 #[serde(rename = "sharingReference")]
2936 pub sharing_reference: ResourceReference,
2937}
2938
2939#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2940pub struct InsightIdentity {
2941 #[serde(rename = "displayName")]
2942 pub display_name: String,
2943 #[serde(rename = "id")]
2944 pub id: String,
2945 #[serde(rename = "address")]
2946 pub address: String,
2947}
2948
2949#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2950pub struct UsageDetails {
2951 #[serde(rename = "lastAccessedDateTime")]
2952 pub last_accessed_date_time: String,
2953 #[serde(rename = "lastModifiedDateTime")]
2954 pub last_modified_date_time: String,
2955}
2956
2957#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2958pub struct TeamMemberSettings {
2959 #[serde(rename = "allowCreateUpdateChannels")]
2960 pub allow_create_update_channels: bool,
2961 #[serde(rename = "allowDeleteChannels")]
2962 pub allow_delete_channels: bool,
2963 #[serde(rename = "allowAddRemoveApps")]
2964 pub allow_add_remove_apps: bool,
2965 #[serde(rename = "allowCreateUpdateRemoveTabs")]
2966 pub allow_create_update_remove_tabs: bool,
2967 #[serde(rename = "allowCreateUpdateRemoveConnectors")]
2968 pub allow_create_update_remove_connectors: bool,
2969}
2970
2971#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2972pub struct TeamGuestSettings {
2973 #[serde(rename = "allowCreateUpdateChannels")]
2974 pub allow_create_update_channels: bool,
2975 #[serde(rename = "allowDeleteChannels")]
2976 pub allow_delete_channels: bool,
2977}
2978
2979#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2980pub struct TeamMessagingSettings {
2981 #[serde(rename = "allowUserEditMessages")]
2982 pub allow_user_edit_messages: bool,
2983 #[serde(rename = "allowUserDeleteMessages")]
2984 pub allow_user_delete_messages: bool,
2985 #[serde(rename = "allowOwnerDeleteMessages")]
2986 pub allow_owner_delete_messages: bool,
2987 #[serde(rename = "allowTeamMentions")]
2988 pub allow_team_mentions: bool,
2989 #[serde(rename = "allowChannelMentions")]
2990 pub allow_channel_mentions: bool,
2991}
2992
2993#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
2994pub struct TeamFunSettings {
2995 #[serde(rename = "allowGiphy")]
2996 pub allow_giphy: bool,
2997 #[serde(rename = "giphyContentRating")]
2998 pub giphy_content_rating: GiphyRatingType,
2999 #[serde(rename = "allowStickersAndMemes")]
3000 pub allow_stickers_and_memes: bool,
3001 #[serde(rename = "allowCustomMemes")]
3002 pub allow_custom_memes: bool,
3003}
3004
3005#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
3006pub struct TeamClassSettings {
3007 #[serde(rename = "notifyGuardiansAboutAssignments")]
3008 pub notify_guardians_about_assignments: bool,
3009}
3010
3011#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
3012pub struct TeamsTabConfiguration {
3013 #[serde(rename = "entityId")]
3014 pub entity_id: String,
3015 #[serde(rename = "contentUrl")]
3016 pub content_url: String,
3017 #[serde(rename = "removeUrl")]
3018 pub remove_url: String,
3019 #[serde(rename = "websiteUrl")]
3020 pub website_url: String,
3021}
3022
3023#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
3024pub struct OperationError {
3025 #[serde(rename = "code")]
3026 pub code: String,
3027 #[serde(rename = "message")]
3028 pub message: String,
3029}
3030
3031#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
3032pub struct AuditActivityInitiator {
3033 #[serde(rename = "user")]
3034 pub user: UserIdentity,
3035 #[serde(rename = "app")]
3036 pub app: AppIdentity,
3037}
3038
3039#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
3040pub struct UserIdentity {
3041 #[serde(rename = "id")]
3042 pub id: String,
3043 #[serde(rename = "displayName")]
3044 pub display_name: String,
3045 #[serde(rename = "ipAddress")]
3046 pub ip_address: String,
3047 #[serde(rename = "userPrincipalName")]
3048 pub user_principal_name: String,
3049}
3050
3051#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
3052pub struct AppIdentity {
3053 #[serde(rename = "appId")]
3054 pub app_id: String,
3055 #[serde(rename = "displayName")]
3056 pub display_name: String,
3057 #[serde(rename = "servicePrincipalId")]
3058 pub service_principal_id: String,
3059 #[serde(rename = "servicePrincipalName")]
3060 pub service_principal_name: String,
3061}
3062
3063#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
3064pub struct TargetResource {
3065 #[serde(rename = "id")]
3066 pub id: String,
3067 #[serde(rename = "displayName")]
3068 pub display_name: String,
3069 #[serde(rename = "type")]
3070 pub _type: String,
3071 #[serde(rename = "userPrincipalName")]
3072 pub user_principal_name: String,
3073 #[serde(rename = "groupType")]
3074 pub group_type: GroupType,
3075 #[serde(rename = "modifiedProperties")]
3076 pub modified_properties: Vec<ModifiedProperty>,
3077}
3078
3079#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
3080pub struct ModifiedProperty {
3081 #[serde(rename = "displayName")]
3082 pub display_name: String,
3083 #[serde(rename = "oldValue")]
3084 pub old_value: String,
3085 #[serde(rename = "newValue")]
3086 pub new_value: String,
3087}
3088
3089#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
3090pub struct KeyValue {
3091 #[serde(rename = "key")]
3092 pub key: String,
3093 #[serde(rename = "value")]
3094 pub value: String,
3095}
3096
3097#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
3098pub struct SignInStatus {
3099 #[serde(rename = "errorCode")]
3100 pub error_code: i32,
3101 #[serde(rename = "failureReason")]
3102 pub failure_reason: String,
3103 #[serde(rename = "additionalDetails")]
3104 pub additional_details: String,
3105}
3106
3107#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
3108pub struct DeviceDetail {
3109 #[serde(rename = "deviceId")]
3110 pub device_id: String,
3111 #[serde(rename = "displayName")]
3112 pub display_name: String,
3113 #[serde(rename = "operatingSystem")]
3114 pub operating_system: String,
3115 #[serde(rename = "browser")]
3116 pub browser: String,
3117 #[serde(rename = "isCompliant")]
3118 pub is_compliant: bool,
3119 #[serde(rename = "isManaged")]
3120 pub is_managed: bool,
3121 #[serde(rename = "trustType")]
3122 pub trust_type: String,
3123}
3124
3125#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
3126pub struct SignInLocation {
3127 #[serde(rename = "city")]
3128 pub city: String,
3129 #[serde(rename = "state")]
3130 pub state: String,
3131 #[serde(rename = "countryOrRegion")]
3132 pub country_or_region: String,
3133 #[serde(rename = "geoCoordinates")]
3134 pub geo_coordinates: GeoCoordinates,
3135}
3136
3137#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
3138pub struct AppliedConditionalAccessPolicy {
3139 #[serde(rename = "id")]
3140 pub id: String,
3141 #[serde(rename = "displayName")]
3142 pub display_name: String,
3143 #[serde(rename = "enforcedGrantControls")]
3144 pub enforced_grant_controls: Vec<String>,
3145 #[serde(rename = "enforcedSessionControls")]
3146 pub enforced_session_controls: Vec<String>,
3147 #[serde(rename = "result")]
3148 pub result: AppliedConditionalAccessPolicyResult,
3149}