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