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