1use crate::messaging::{ConversationAudience, ExternalActor, MessagingAddress};
2use serde::{Deserialize, Serialize};
3use serde_json::Value;
4
5#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
6#[serde(rename_all = "lowercase")]
7pub enum Placement {
8 Local,
9 Cloud,
10}
11
12impl Placement {
13 #[must_use]
14 pub const fn as_str(self) -> &'static str {
15 match self {
16 Self::Local => "local",
17 Self::Cloud => "cloud",
18 }
19 }
20}
21
22#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
23#[serde(rename_all = "camelCase", deny_unknown_fields)]
24pub struct FrontendProvider {
25 pub provider: String,
26 pub deprecated: bool,
27 pub supported_placements: Vec<Placement>,
28}
29
30#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
31#[serde(rename_all = "camelCase", deny_unknown_fields)]
32pub struct ProviderListRequest {
33 pub placement: Placement,
34 pub frontend_providers: Vec<FrontendProvider>,
35}
36
37#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
38#[serde(rename_all = "camelCase", deny_unknown_fields)]
39pub struct ProviderMetadata {
40 pub provider: String,
41 pub display_name: String,
42 pub placement: Placement,
43 pub deprecated: bool,
44 pub available: bool,
45 #[serde(default, skip_serializing_if = "Option::is_none")]
46 pub disabled_reason: Option<String>,
47 pub setup_flow: String,
48 pub audiences: Vec<ConversationAudience>,
49 pub inbound_capabilities: Vec<ContentCapability>,
50 pub outbound_capabilities: Vec<ContentCapability>,
51 pub delivery_mode: DeliveryMode,
52 pub projections: ProjectionCapabilities,
53 pub management_operations: Vec<ManagementOperation>,
54 pub provider_data: Value,
55}
56
57#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
58#[serde(rename_all = "camelCase", deny_unknown_fields)]
59pub struct ProjectionCapabilities {
60 pub notification: ProjectionCapability,
61 pub dialog: ProjectionCapability,
62}
63
64#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
65#[serde(rename_all = "camelCase", deny_unknown_fields)]
66pub struct ProjectionCapability {
67 pub supported: bool,
68 #[serde(default, skip_serializing_if = "Option::is_none")]
69 pub reason: Option<ProjectionUnsupportedReason>,
70}
71
72#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
73#[serde(rename_all = "snake_case")]
74pub enum ProjectionUnsupportedReason {
75 NoProactiveDelivery,
76 NoInteractiveActions,
77 SessionWindowOnly,
78 ProviderUnconfigured,
79}
80
81#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
82#[serde(rename_all = "camelCase", deny_unknown_fields)]
83pub struct RouteProjectionSettings {
84 pub notification: NotificationProjectionSetting,
85 pub dialog: DialogProjectionSetting,
86}
87
88#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
89#[serde(rename_all = "camelCase", deny_unknown_fields)]
90pub struct NotificationProjectionSetting {
91 pub enabled: bool,
92 pub levels: Vec<NotificationProjectionLevel>,
93}
94
95#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
96#[serde(rename_all = "snake_case")]
97pub enum NotificationProjectionLevel {
98 Alert,
99 Notify,
100 Chat,
101}
102
103#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
104#[serde(rename_all = "camelCase", deny_unknown_fields)]
105pub struct DialogProjectionSetting {
106 pub enabled: bool,
107}
108
109#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
110#[serde(rename_all = "camelCase", deny_unknown_fields)]
111pub struct RouteProjectionSettingsUpdate {
112 #[serde(default, skip_serializing_if = "Option::is_none")]
113 pub notification: Option<NotificationProjectionSettingUpdate>,
114 #[serde(default, skip_serializing_if = "Option::is_none")]
115 pub dialog: Option<DialogProjectionSettingUpdate>,
116}
117
118#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
119#[serde(rename_all = "camelCase", deny_unknown_fields)]
120pub struct NotificationProjectionSettingUpdate {
121 #[serde(default, skip_serializing_if = "Option::is_none")]
122 pub enabled: Option<bool>,
123 #[serde(default, skip_serializing_if = "Option::is_none")]
124 pub levels: Option<Vec<NotificationProjectionLevel>>,
125}
126
127#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
128#[serde(rename_all = "camelCase", deny_unknown_fields)]
129pub struct DialogProjectionSettingUpdate {
130 #[serde(default, skip_serializing_if = "Option::is_none")]
131 pub enabled: Option<bool>,
132}
133
134#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
135#[serde(rename_all = "snake_case")]
136pub enum ContentCapability {
137 Text,
138 Markdown,
139 Image,
140 Audio,
141 Video,
142 File,
143 Action,
144}
145
146#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
147#[serde(rename_all = "snake_case")]
148pub enum DeliveryMode {
149 Unrestricted,
150 SessionWindow,
151}
152
153#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
154pub enum ManagementOperation {
155 #[serde(rename = "provider_account.list")]
156 ProviderAccountList,
157 #[serde(rename = "provider_account.update")]
158 ProviderAccountUpdate,
159 #[serde(rename = "provider_account.delete")]
160 ProviderAccountDelete,
161 #[serde(rename = "provider_account.test")]
162 ProviderAccountTest,
163 #[serde(rename = "provider_account.status")]
164 ProviderAccountStatus,
165 #[serde(rename = "shared_account_grant.create")]
166 SharedAccountGrantCreate,
167 #[serde(rename = "shared_account_grant.delete")]
168 SharedAccountGrantDelete,
169 #[serde(rename = "shared_account_grant.list")]
170 SharedAccountGrantList,
171 #[serde(rename = "route.list")]
172 RouteList,
173 #[serde(rename = "route.update")]
174 RouteUpdate,
175 #[serde(rename = "route.delete")]
176 RouteDelete,
177 #[serde(rename = "setup.options")]
178 SetupOptions,
179 #[serde(rename = "setup.start")]
180 SetupStart,
181 #[serde(rename = "setup.status")]
182 SetupStatus,
183 #[serde(rename = "surface.list")]
184 SurfaceList,
185 #[serde(rename = "surface.dismiss")]
186 SurfaceDismiss,
187 #[serde(rename = "surface.bind_code.create")]
188 SurfaceBindCodeCreate,
189 #[serde(rename = "actor.link_code.create")]
190 ActorLinkCodeCreate,
191 #[serde(rename = "identity_code.status")]
192 IdentityCodeStatus,
193 #[serde(rename = "actor.link.list")]
194 ActorLinkList,
195 #[serde(rename = "actor.link.delete")]
196 ActorLinkDelete,
197}
198
199#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
200#[serde(rename_all = "camelCase", deny_unknown_fields)]
201pub struct ProviderListResponse {
202 pub providers: Vec<ProviderMetadata>,
203}
204
205#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
206#[serde(rename_all = "camelCase", deny_unknown_fields)]
207pub struct ProviderPlacementRequest {
208 pub provider: String,
209 pub placement: Placement,
210}
211
212#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
213#[serde(rename_all = "camelCase", deny_unknown_fields)]
214pub struct ProviderAccountUpdateRequest {
215 pub provider: String,
216 pub placement: Placement,
217 pub account_id: String,
218 pub data: Value,
219}
220
221#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
222#[serde(rename_all = "camelCase", deny_unknown_fields)]
223pub struct ProviderAccountRequest {
224 pub provider: String,
225 pub placement: Placement,
226 pub account_id: String,
227}
228
229#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
230#[serde(rename_all = "camelCase", deny_unknown_fields)]
231pub struct ProviderAccountTestRequest {
232 pub provider: String,
233 pub placement: Placement,
234 pub data: Value,
235}
236
237#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
238#[serde(rename_all = "snake_case")]
239pub enum ProviderAccountOwnership {
240 System,
241 User,
242}
243
244#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
245#[serde(rename_all = "camelCase", deny_unknown_fields)]
246pub struct ProviderAccount {
247 pub provider: String,
248 pub placement: Placement,
249 pub account_id: String,
250 pub ownership: ProviderAccountOwnership,
251 #[serde(default, skip_serializing_if = "Option::is_none")]
252 pub display_name: Option<String>,
253 pub enabled: bool,
254 pub status: String,
255 #[serde(default, skip_serializing_if = "Option::is_none")]
256 pub status_message: Option<String>,
257 pub provider_data: Value,
258}
259
260#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
261#[serde(rename_all = "camelCase", deny_unknown_fields)]
262pub struct ProviderAccountListResponse {
263 pub accounts: Vec<ProviderAccount>,
264}
265
266#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
267#[serde(rename_all = "camelCase", deny_unknown_fields)]
268pub struct ProviderAccountUpdateResponse {
269 pub account: ProviderAccount,
270}
271
272#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
273#[serde(rename_all = "camelCase", deny_unknown_fields)]
274pub struct ProviderAccountTestResponse {
275 pub result: Value,
276}
277
278#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
279#[serde(rename_all = "camelCase", deny_unknown_fields)]
280pub struct ProviderStatus {
281 pub provider: String,
282 pub placement: Placement,
283 pub enabled: bool,
284 pub provider_data: Value,
285}
286
287#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
288#[serde(rename_all = "camelCase", deny_unknown_fields)]
289pub struct ProviderAccountStatusResponse {
290 pub status: ProviderStatus,
291}
292
293#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
294#[serde(rename_all = "camelCase", deny_unknown_fields)]
295pub struct MutationResponse {
296 pub success: bool,
297}
298
299#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
300#[serde(rename_all = "camelCase", deny_unknown_fields)]
301pub struct SharedAccountGrantRequest {
302 pub provider: String,
303 pub placement: Placement,
304 pub account_id: String,
305}
306
307#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
308#[serde(rename_all = "camelCase", deny_unknown_fields)]
309pub struct SharedAccountGrantListRequest {
310 pub provider: String,
311 pub placement: Placement,
312 #[serde(default, skip_serializing_if = "Option::is_none")]
313 pub account_id: Option<String>,
314}
315
316#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
317#[serde(rename_all = "camelCase", deny_unknown_fields)]
318pub struct SharedAccountGrant {
319 pub provider: String,
320 pub placement: Placement,
321 pub account_id: String,
322 pub tenant_id: String,
323 pub scope_id: String,
324 pub granted_by_user_id: String,
325 pub created_at_ms: i64,
326 pub updated_at_ms: i64,
327}
328
329#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
330#[serde(rename_all = "camelCase", deny_unknown_fields)]
331pub struct SharedAccountGrantListResponse {
332 pub grants: Vec<SharedAccountGrant>,
333}
334
335#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
336#[serde(rename_all = "camelCase", deny_unknown_fields)]
337pub struct RouteListRequest {
338 pub provider: String,
339 pub placement: Placement,
340 #[serde(default, skip_serializing_if = "Option::is_none")]
341 pub account_id: Option<String>,
342 #[serde(default, skip_serializing_if = "Option::is_none")]
343 pub audience: Option<ConversationAudience>,
344}
345
346#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
347#[serde(rename_all = "camelCase", deny_unknown_fields)]
348pub struct RouteRequest {
349 pub provider: String,
350 pub placement: Placement,
351 pub route_id: String,
352}
353
354#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
355#[serde(
356 tag = "audience",
357 rename_all = "lowercase",
358 rename_all_fields = "camelCase",
359 deny_unknown_fields
360)]
361pub enum RouteUpdateRequest {
362 Personal {
363 provider: String,
364 placement: Placement,
365 route_id: String,
366 #[serde(default, skip_serializing_if = "Option::is_none")]
367 scope_id: Option<String>,
368 #[serde(default, skip_serializing_if = "Option::is_none")]
369 enabled: Option<bool>,
370 #[serde(default, skip_serializing_if = "Option::is_none")]
371 projections: Option<RouteProjectionSettingsUpdate>,
372 },
373 Shared {
374 provider: String,
375 placement: Placement,
376 route_id: String,
377 #[serde(default, skip_serializing_if = "Option::is_none")]
378 enabled: Option<bool>,
379 #[serde(default, skip_serializing_if = "Option::is_none")]
380 projections: Option<RouteProjectionSettingsUpdate>,
381 },
382}
383
384#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
385#[serde(
386 tag = "audience",
387 rename_all = "lowercase",
388 rename_all_fields = "camelCase",
389 deny_unknown_fields
390)]
391pub enum MessagingRoute {
392 Personal {
393 provider: String,
394 placement: Placement,
395 route_id: String,
396 account_id: String,
397 conversation_id: String,
398 external_actor_id: String,
399 tenant_id: String,
400 user_id: String,
401 scope_id: String,
402 #[serde(default, skip_serializing_if = "Option::is_none")]
403 display_name: Option<String>,
404 enabled: bool,
405 projections: RouteProjectionSettings,
406 provider_data: Value,
407 },
408 Shared {
409 provider: String,
410 placement: Placement,
411 route_id: String,
412 account_id: String,
413 conversation_id: String,
414 tenant_id: String,
415 scope_id: String,
416 bound_by_user_id: String,
417 #[serde(default, skip_serializing_if = "Option::is_none")]
418 display_name: Option<String>,
419 enabled: bool,
420 projections: RouteProjectionSettings,
421 provider_data: Value,
422 },
423}
424
425#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
426#[serde(rename_all = "camelCase", deny_unknown_fields)]
427pub struct RouteListResponse {
428 pub routes: Vec<MessagingRoute>,
429}
430
431#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
432#[serde(rename_all = "camelCase", deny_unknown_fields)]
433pub struct RouteUpdateResponse {
434 pub route: MessagingRoute,
435}
436
437#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
438#[serde(rename_all = "camelCase", deny_unknown_fields)]
439pub struct SetupStartRequest {
440 pub provider: String,
441 pub placement: Placement,
442 pub data: Value,
443}
444
445#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
446#[serde(rename_all = "camelCase", deny_unknown_fields)]
447pub struct SetupOptionsResponse {
448 pub options: Value,
449}
450
451#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
452#[serde(rename_all = "camelCase", deny_unknown_fields)]
453pub struct SetupStatusRequest {
454 pub provider: String,
455 pub placement: Placement,
456 pub setup_id: String,
457}
458
459#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
460#[serde(rename_all = "camelCase", deny_unknown_fields)]
461pub struct SetupAction {
462 #[serde(rename = "type")]
463 pub kind: String,
464 #[serde(default, skip_serializing_if = "Option::is_none")]
465 pub url: Option<String>,
466}
467
468#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
469#[serde(rename_all = "camelCase", deny_unknown_fields)]
470pub struct SetupState {
471 #[serde(default, skip_serializing_if = "Option::is_none")]
472 pub setup_id: Option<String>,
473 pub status: String,
474 #[serde(default, skip_serializing_if = "Option::is_none")]
475 pub expires_at_ms: Option<i64>,
476 #[serde(default, skip_serializing_if = "Option::is_none")]
477 pub action: Option<SetupAction>,
478 pub provider_data: Value,
479 #[serde(default, skip_serializing_if = "Option::is_none")]
480 pub account_id: Option<String>,
481 #[serde(default, skip_serializing_if = "Option::is_none")]
482 pub route_id: Option<String>,
483 #[serde(default, skip_serializing_if = "Option::is_none")]
484 pub message: Option<String>,
485}
486
487#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
488#[serde(rename_all = "camelCase", deny_unknown_fields)]
489pub struct SetupResponse {
490 pub setup: SetupState,
491}
492
493#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
494#[serde(rename_all = "lowercase")]
495pub enum SurfaceState {
496 Pending,
497 Bound,
498 Dismissed,
499}
500
501#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
502#[serde(rename_all = "camelCase", deny_unknown_fields)]
503pub struct SurfaceListRequest {
504 pub provider: String,
505 pub placement: Placement,
506 #[serde(default, skip_serializing_if = "Option::is_none")]
507 pub account_id: Option<String>,
508 #[serde(default, skip_serializing_if = "Option::is_none")]
509 pub state: Option<SurfaceState>,
510}
511
512#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
513#[serde(rename_all = "camelCase", deny_unknown_fields)]
514pub struct MessagingSurface {
515 pub provider: String,
516 pub placement: Placement,
517 pub account_id: String,
518 pub surface_id: String,
519 #[serde(default, skip_serializing_if = "Option::is_none")]
520 pub display_name: Option<String>,
521 pub state: SurfaceState,
522 #[serde(default, skip_serializing_if = "Option::is_none")]
523 pub scope_id: Option<String>,
524 pub first_seen_at_ms: i64,
525 pub last_seen_at_ms: i64,
526}
527
528#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
529#[serde(rename_all = "camelCase", deny_unknown_fields)]
530pub struct SurfaceListResponse {
531 pub surfaces: Vec<MessagingSurface>,
532}
533
534#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
535#[serde(rename_all = "camelCase", deny_unknown_fields)]
536pub struct SurfaceRequest {
537 pub provider: String,
538 pub placement: Placement,
539 pub surface_id: String,
540}
541
542#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
543#[serde(rename_all = "camelCase", deny_unknown_fields)]
544pub struct SurfaceBindCodeCreateRequest {
545 pub provider: String,
546 pub placement: Placement,
547 pub scope_id: String,
548}
549
550#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
551#[serde(rename_all = "camelCase", deny_unknown_fields)]
552pub struct ActorLinkCodeCreateRequest {
553 pub provider: String,
554 pub placement: Placement,
555}
556
557#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
558#[serde(rename_all = "camelCase", deny_unknown_fields)]
559pub struct ChallengeCode {
560 pub challenge_id: String,
561 pub code: String,
562 pub command: String,
563 pub expires_at_ms: i64,
564}
565
566#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
567#[serde(rename_all = "camelCase", deny_unknown_fields)]
568pub struct ActorLinkChallenge {
569 pub challenge_id: String,
570 pub code: String,
571 pub command: String,
572 pub expires_at_ms: i64,
573}
574
575#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
576#[serde(rename_all = "camelCase", deny_unknown_fields)]
577pub struct ActorLinkChallengeResponse {
578 pub challenge: ActorLinkChallenge,
579}
580
581#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
582#[serde(rename_all = "camelCase", deny_unknown_fields)]
583pub struct IdentityCodeReceipt {
584 pub actor: ExternalActor,
585 pub address: MessagingAddress,
586 pub event_id: String,
587}
588
589#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
590#[serde(rename_all = "lowercase")]
591pub enum IdentityChallengeKind {
592 #[default]
593 Link,
594 Bind,
595}
596
597#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
598#[serde(rename_all = "camelCase", deny_unknown_fields)]
599pub struct IdentityCodeStatus {
600 pub kind: IdentityChallengeKind,
601 pub challenge_id: String,
602 pub provider: String,
603 pub placement: Placement,
604 #[serde(default, skip_serializing_if = "Option::is_none")]
605 pub account_id: Option<String>,
606 pub expires_at_ms: i64,
607 pub lifecycle: IdentityCodeLifecycle,
608}
609
610#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
611#[serde(
612 tag = "state",
613 rename_all = "snake_case",
614 rename_all_fields = "camelCase",
615 deny_unknown_fields
616)]
617pub enum IdentityCodeLifecycle {
618 Issued,
619 Processing {
620 receipt: IdentityCodeReceipt,
621 },
622 Failed {
623 receipt: IdentityCodeReceipt,
624 },
625 Completed {
626 receipt: IdentityCodeReceipt,
627 #[serde(default, skip_serializing_if = "Option::is_none")]
628 link_id: Option<String>,
629 },
630 Superseded,
631 Expired,
632}
633
634#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
635#[serde(rename_all = "camelCase", deny_unknown_fields)]
636pub struct IdentityCodeStatusRequest {
637 pub provider: String,
638 pub placement: Placement,
639 pub challenge_id: String,
640}
641
642#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
643#[serde(rename_all = "camelCase", deny_unknown_fields)]
644pub struct IdentityCodeStatusResponse {
645 pub status: IdentityCodeStatus,
646}
647
648#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
649#[serde(rename_all = "camelCase", deny_unknown_fields)]
650pub struct IdentityCodeStatusEvent {
651 pub status: IdentityCodeStatus,
652}
653
654#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
655#[serde(rename_all = "camelCase", deny_unknown_fields)]
656pub struct ChallengeCodeResponse {
657 pub challenge: ChallengeCode,
658}
659
660#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
661#[serde(rename_all = "camelCase", deny_unknown_fields)]
662pub struct ActorLinkListRequest {
663 pub provider: String,
664 pub placement: Placement,
665 #[serde(default, skip_serializing_if = "Option::is_none")]
666 pub account_id: Option<String>,
667}
668
669#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
670#[serde(rename_all = "camelCase", deny_unknown_fields)]
671pub struct ActorLinkView {
672 pub link_id: String,
673 pub provider: String,
674 pub placement: Placement,
675 pub account_id: String,
676 pub external_user_id: String,
677 #[serde(default, skip_serializing_if = "Option::is_none")]
678 pub display_name: Option<String>,
679 pub created_at_ms: i64,
680 pub updated_at_ms: i64,
681}
682
683#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
684#[serde(rename_all = "camelCase", deny_unknown_fields)]
685pub struct ActorLinkListResponse {
686 pub links: Vec<ActorLinkView>,
687}
688
689#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
690#[serde(rename_all = "camelCase", deny_unknown_fields)]
691pub struct ActorLinkDeleteRequest {
692 pub provider: String,
693 pub placement: Placement,
694 pub link_id: String,
695}