1use crate::ConversationAudience;
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 = "account_grant.create")]
78 AccountGrantCreate,
79 #[serde(rename = "account_grant.delete")]
80 AccountGrantDelete,
81 #[serde(rename = "account_grant.list")]
82 AccountGrantList,
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.list")]
104 ActorLinkList,
105 #[serde(rename = "actor.link.delete")]
106 ActorLinkDelete,
107}
108
109#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
110#[serde(rename_all = "camelCase", deny_unknown_fields)]
111pub struct ProviderListResponse {
112 pub providers: Vec<ProviderMetadata>,
113}
114
115#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
116#[serde(rename_all = "camelCase", deny_unknown_fields)]
117pub struct ProviderPlacementRequest {
118 pub provider: String,
119 pub placement: Placement,
120}
121
122#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
123#[serde(rename_all = "camelCase", deny_unknown_fields)]
124pub struct ProviderAccountUpdateRequest {
125 pub provider: String,
126 pub placement: Placement,
127 pub account_id: String,
128 pub data: Value,
129}
130
131#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
132#[serde(rename_all = "camelCase", deny_unknown_fields)]
133pub struct ProviderAccountRequest {
134 pub provider: String,
135 pub placement: Placement,
136 pub account_id: String,
137}
138
139#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
140#[serde(rename_all = "camelCase", deny_unknown_fields)]
141pub struct ProviderAccountTestRequest {
142 pub provider: String,
143 pub placement: Placement,
144 pub data: Value,
145}
146
147#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
148#[serde(rename_all = "snake_case")]
149pub enum ProviderAccountOwnership {
150 System,
151 User,
152}
153
154#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
155#[serde(rename_all = "camelCase", deny_unknown_fields)]
156pub struct ProviderAccount {
157 pub provider: String,
158 pub placement: Placement,
159 pub account_id: String,
160 pub ownership: ProviderAccountOwnership,
161 #[serde(default, skip_serializing_if = "Option::is_none")]
162 pub display_name: Option<String>,
163 pub enabled: bool,
164 pub status: String,
165 #[serde(default, skip_serializing_if = "Option::is_none")]
166 pub status_message: Option<String>,
167 pub provider_data: Value,
168}
169
170#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
171#[serde(rename_all = "camelCase", deny_unknown_fields)]
172pub struct ProviderAccountListResponse {
173 pub accounts: Vec<ProviderAccount>,
174}
175
176#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
177#[serde(rename_all = "camelCase", deny_unknown_fields)]
178pub struct ProviderAccountUpdateResponse {
179 pub account: ProviderAccount,
180}
181
182#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
183#[serde(rename_all = "camelCase", deny_unknown_fields)]
184pub struct ProviderAccountTestResponse {
185 pub result: Value,
186}
187
188#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
189#[serde(rename_all = "camelCase", deny_unknown_fields)]
190pub struct ProviderStatus {
191 pub provider: String,
192 pub placement: Placement,
193 pub enabled: bool,
194 pub provider_data: Value,
195}
196
197#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
198#[serde(rename_all = "camelCase", deny_unknown_fields)]
199pub struct ProviderAccountStatusResponse {
200 pub status: ProviderStatus,
201}
202
203#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
204#[serde(rename_all = "camelCase", deny_unknown_fields)]
205pub struct MutationResponse {
206 pub success: bool,
207}
208
209#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
210#[serde(rename_all = "camelCase", deny_unknown_fields)]
211pub struct AccountGrantRequest {
212 pub provider: String,
213 pub placement: Placement,
214 pub account_id: String,
215}
216
217#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
218#[serde(rename_all = "camelCase", deny_unknown_fields)]
219pub struct AccountGrant {
220 pub provider: String,
221 pub placement: Placement,
222 pub account_id: String,
223 pub tenant_id: String,
224 pub scope_id: String,
225 pub user_id: String,
226 pub default: bool,
227}
228
229#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
230#[serde(rename_all = "camelCase", deny_unknown_fields)]
231pub struct AccountGrantListResponse {
232 pub grants: Vec<AccountGrant>,
233}
234
235#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
236#[serde(rename_all = "camelCase", deny_unknown_fields)]
237pub struct RouteListRequest {
238 pub provider: String,
239 pub placement: Placement,
240 #[serde(default, skip_serializing_if = "Option::is_none")]
241 pub account_id: Option<String>,
242 #[serde(default, skip_serializing_if = "Option::is_none")]
243 pub audience: Option<ConversationAudience>,
244}
245
246#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
247#[serde(rename_all = "camelCase", deny_unknown_fields)]
248pub struct RouteRequest {
249 pub provider: String,
250 pub placement: Placement,
251 pub route_id: String,
252}
253
254#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
255#[serde(rename_all = "camelCase", deny_unknown_fields)]
256pub struct RouteUpdateRequest {
257 pub provider: String,
258 pub placement: Placement,
259 pub route_id: String,
260 pub scope_id: String,
261 #[serde(default, skip_serializing_if = "Option::is_none")]
262 pub enabled: Option<bool>,
263}
264
265#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
266#[serde(
267 tag = "audience",
268 rename_all = "lowercase",
269 rename_all_fields = "camelCase",
270 deny_unknown_fields
271)]
272pub enum MessagingRoute {
273 Personal {
274 provider: String,
275 placement: Placement,
276 route_id: String,
277 account_id: String,
278 conversation_id: String,
279 external_actor_id: String,
280 tenant_id: String,
281 user_id: String,
282 scope_id: String,
283 #[serde(default, skip_serializing_if = "Option::is_none")]
284 display_name: Option<String>,
285 enabled: bool,
286 provider_data: Value,
287 },
288 Shared {
289 provider: String,
290 placement: Placement,
291 route_id: String,
292 account_id: String,
293 conversation_id: String,
294 tenant_id: String,
295 scope_id: String,
296 bound_by_user_id: String,
297 #[serde(default, skip_serializing_if = "Option::is_none")]
298 display_name: Option<String>,
299 enabled: bool,
300 provider_data: Value,
301 },
302}
303
304#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
305#[serde(rename_all = "camelCase", deny_unknown_fields)]
306pub struct RouteListResponse {
307 pub routes: Vec<MessagingRoute>,
308}
309
310#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
311#[serde(rename_all = "camelCase", deny_unknown_fields)]
312pub struct RouteUpdateResponse {
313 pub route: MessagingRoute,
314}
315
316#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
317#[serde(rename_all = "camelCase", deny_unknown_fields)]
318pub struct SetupStartRequest {
319 pub provider: String,
320 pub placement: Placement,
321 pub data: Value,
322}
323
324#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
325#[serde(rename_all = "camelCase", deny_unknown_fields)]
326pub struct SetupOptionsResponse {
327 pub options: Value,
328}
329
330#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
331#[serde(rename_all = "camelCase", deny_unknown_fields)]
332pub struct SetupStatusRequest {
333 pub provider: String,
334 pub placement: Placement,
335 pub setup_id: String,
336}
337
338#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
339#[serde(rename_all = "camelCase", deny_unknown_fields)]
340pub struct SetupAction {
341 #[serde(rename = "type")]
342 pub kind: String,
343 #[serde(default, skip_serializing_if = "Option::is_none")]
344 pub url: Option<String>,
345}
346
347#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
348#[serde(rename_all = "camelCase", deny_unknown_fields)]
349pub struct SetupState {
350 #[serde(default, skip_serializing_if = "Option::is_none")]
351 pub setup_id: Option<String>,
352 pub status: String,
353 #[serde(default, skip_serializing_if = "Option::is_none")]
354 pub expires_at_ms: Option<i64>,
355 #[serde(default, skip_serializing_if = "Option::is_none")]
356 pub action: Option<SetupAction>,
357 pub provider_data: Value,
358 #[serde(default, skip_serializing_if = "Option::is_none")]
359 pub account_id: Option<String>,
360 #[serde(default, skip_serializing_if = "Option::is_none")]
361 pub route_id: Option<String>,
362 #[serde(default, skip_serializing_if = "Option::is_none")]
363 pub message: Option<String>,
364}
365
366#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
367#[serde(rename_all = "camelCase", deny_unknown_fields)]
368pub struct SetupResponse {
369 pub setup: SetupState,
370}
371
372#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
373#[serde(rename_all = "lowercase")]
374pub enum SurfaceState {
375 Pending,
376 Bound,
377 Dismissed,
378}
379
380#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
381#[serde(rename_all = "camelCase", deny_unknown_fields)]
382pub struct SurfaceListRequest {
383 pub provider: String,
384 pub placement: Placement,
385 #[serde(default, skip_serializing_if = "Option::is_none")]
386 pub account_id: Option<String>,
387 #[serde(default, skip_serializing_if = "Option::is_none")]
388 pub state: Option<SurfaceState>,
389}
390
391#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
392#[serde(rename_all = "camelCase", deny_unknown_fields)]
393pub struct MessagingSurface {
394 pub provider: String,
395 pub placement: Placement,
396 pub account_id: String,
397 pub surface_id: String,
398 #[serde(default, skip_serializing_if = "Option::is_none")]
399 pub display_name: Option<String>,
400 pub state: SurfaceState,
401 #[serde(default, skip_serializing_if = "Option::is_none")]
402 pub scope_id: Option<String>,
403 pub first_seen_at_ms: i64,
404 pub last_seen_at_ms: i64,
405}
406
407#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
408#[serde(rename_all = "camelCase", deny_unknown_fields)]
409pub struct SurfaceListResponse {
410 pub surfaces: Vec<MessagingSurface>,
411}
412
413#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
414#[serde(rename_all = "camelCase", deny_unknown_fields)]
415pub struct SurfaceRequest {
416 pub provider: String,
417 pub placement: Placement,
418 pub surface_id: String,
419}
420
421#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
422#[serde(rename_all = "camelCase", deny_unknown_fields)]
423pub struct SurfaceBindCodeCreateRequest {
424 pub provider: String,
425 pub placement: Placement,
426 pub surface_id: String,
427 pub scope_id: String,
428}
429
430#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
431#[serde(rename_all = "camelCase", deny_unknown_fields)]
432pub struct ActorLinkCodeCreateRequest {
433 pub provider: String,
434 pub placement: Placement,
435 pub account_id: String,
436}
437
438#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
439#[serde(rename_all = "camelCase", deny_unknown_fields)]
440pub struct ChallengeCode {
441 pub code: String,
442 pub command: String,
443 pub expires_at_ms: i64,
444}
445
446#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
447#[serde(rename_all = "camelCase", deny_unknown_fields)]
448pub struct ChallengeCodeResponse {
449 pub challenge: ChallengeCode,
450}
451
452#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
453#[serde(rename_all = "camelCase", deny_unknown_fields)]
454pub struct ActorLinkListRequest {
455 pub provider: String,
456 pub placement: Placement,
457 #[serde(default, skip_serializing_if = "Option::is_none")]
458 pub account_id: Option<String>,
459}
460
461#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
462#[serde(rename_all = "camelCase", deny_unknown_fields)]
463pub struct ActorLinkView {
464 pub link_id: String,
465 pub provider: String,
466 pub placement: Placement,
467 pub account_id: String,
468 pub external_user_id: String,
469 #[serde(default, skip_serializing_if = "Option::is_none")]
470 pub display_name: Option<String>,
471 pub created_at_ms: i64,
472 pub updated_at_ms: i64,
473}
474
475#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
476#[serde(rename_all = "camelCase", deny_unknown_fields)]
477pub struct ActorLinkListResponse {
478 pub links: Vec<ActorLinkView>,
479}
480
481#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
482#[serde(rename_all = "camelCase", deny_unknown_fields)]
483pub struct ActorLinkDeleteRequest {
484 pub provider: String,
485 pub placement: Placement,
486 pub link_id: String,
487}