1use serde::{Deserialize, Serialize};
2
3#[derive(Debug, Clone, Serialize, Deserialize)]
6#[serde(rename_all = "camelCase")]
7pub struct HealthResponse {
8 pub status: String,
9 pub version: String,
10 pub services: Vec<String>,
11}
12
13#[derive(Debug, Clone, Serialize, Deserialize)]
16#[serde(rename_all = "camelCase")]
17pub struct ResetResponse {
18 pub status: String,
19}
20
21#[derive(Debug, Clone, Serialize, Deserialize)]
22#[serde(rename_all = "camelCase")]
23pub struct ResetServiceResponse {
24 pub reset: String,
25}
26
27#[derive(Debug, Clone, Serialize, Deserialize)]
30#[serde(rename_all = "camelCase")]
31pub struct LambdaInvocation {
32 pub function_arn: String,
33 pub payload: String,
34 pub source: String,
35 pub timestamp: String,
36}
37
38#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(rename_all = "camelCase")]
40pub struct LambdaInvocationsResponse {
41 pub invocations: Vec<LambdaInvocation>,
42}
43
44#[derive(Debug, Clone, Serialize, Deserialize)]
45#[serde(rename_all = "camelCase")]
46pub struct WarmContainer {
47 pub function_name: String,
48 pub runtime: String,
49 pub container_id: String,
50 pub last_used_secs_ago: u64,
51}
52
53#[derive(Debug, Clone, Serialize, Deserialize)]
54#[serde(rename_all = "camelCase")]
55pub struct WarmContainersResponse {
56 pub containers: Vec<WarmContainer>,
57}
58
59#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(rename_all = "camelCase")]
61pub struct EvictContainerResponse {
62 pub evicted: bool,
63}
64
65#[derive(Debug, Clone, Serialize, Deserialize)]
68#[serde(rename_all = "camelCase")]
69pub struct SentEmail {
70 pub message_id: String,
71 pub from: String,
72 pub to: Vec<String>,
73 #[serde(default)]
74 pub cc: Vec<String>,
75 #[serde(default)]
76 pub bcc: Vec<String>,
77 pub subject: Option<String>,
78 pub html_body: Option<String>,
79 pub text_body: Option<String>,
80 pub raw_data: Option<String>,
81 pub template_name: Option<String>,
82 pub template_data: Option<String>,
83 pub timestamp: String,
84}
85
86#[derive(Debug, Clone, Serialize, Deserialize)]
87#[serde(rename_all = "camelCase")]
88pub struct SesEmailsResponse {
89 pub emails: Vec<SentEmail>,
90}
91
92#[derive(Debug, Clone, Serialize, Deserialize)]
93#[serde(rename_all = "camelCase")]
94pub struct InboundEmailRequest {
95 pub from: String,
96 pub to: Vec<String>,
97 pub subject: String,
98 pub body: String,
99}
100
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(rename_all = "camelCase")]
103pub struct InboundActionExecuted {
104 pub rule: String,
105 pub action_type: String,
106}
107
108#[derive(Debug, Clone, Serialize, Deserialize)]
109#[serde(rename_all = "camelCase")]
110pub struct InboundEmailResponse {
111 pub message_id: String,
112 pub matched_rules: Vec<String>,
113 pub actions_executed: Vec<InboundActionExecuted>,
114}
115
116#[derive(Debug, Clone, Serialize, Deserialize)]
119#[serde(rename_all = "camelCase")]
120pub struct SnsMessage {
121 pub message_id: String,
122 pub topic_arn: String,
123 pub message: String,
124 pub subject: Option<String>,
125 pub timestamp: String,
126}
127
128#[derive(Debug, Clone, Serialize, Deserialize)]
129#[serde(rename_all = "camelCase")]
130pub struct SnsMessagesResponse {
131 pub messages: Vec<SnsMessage>,
132}
133
134#[derive(Debug, Clone, Serialize, Deserialize)]
135#[serde(rename_all = "camelCase")]
136pub struct PendingConfirmation {
137 pub subscription_arn: String,
138 pub topic_arn: String,
139 pub protocol: String,
140 pub endpoint: String,
141 pub token: Option<String>,
142}
143
144#[derive(Debug, Clone, Serialize, Deserialize)]
145#[serde(rename_all = "camelCase")]
146pub struct PendingConfirmationsResponse {
147 pub pending_confirmations: Vec<PendingConfirmation>,
148}
149
150#[derive(Debug, Clone, Serialize, Deserialize)]
151#[serde(rename_all = "camelCase")]
152pub struct ConfirmSubscriptionRequest {
153 pub subscription_arn: String,
154}
155
156#[derive(Debug, Clone, Serialize, Deserialize)]
157#[serde(rename_all = "camelCase")]
158pub struct ConfirmSubscriptionResponse {
159 pub confirmed: bool,
160}
161
162#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(rename_all = "camelCase")]
166pub struct SqsMessageInfo {
167 pub message_id: String,
168 pub body: String,
169 pub receive_count: u64,
170 pub in_flight: bool,
171 pub created_at: String,
172}
173
174#[derive(Debug, Clone, Serialize, Deserialize)]
175#[serde(rename_all = "camelCase")]
176pub struct SqsQueueMessages {
177 pub queue_url: String,
178 pub queue_name: String,
179 pub messages: Vec<SqsMessageInfo>,
180}
181
182#[derive(Debug, Clone, Serialize, Deserialize)]
183#[serde(rename_all = "camelCase")]
184pub struct SqsMessagesResponse {
185 pub queues: Vec<SqsQueueMessages>,
186}
187
188#[derive(Debug, Clone, Serialize, Deserialize)]
189#[serde(rename_all = "camelCase")]
190pub struct ExpirationTickResponse {
191 pub expired_messages: u64,
192}
193
194#[derive(Debug, Clone, Serialize, Deserialize)]
195#[serde(rename_all = "camelCase")]
196pub struct ForceDlqResponse {
197 pub moved_messages: u64,
198}
199
200#[derive(Debug, Clone, Serialize, Deserialize)]
203#[serde(rename_all = "camelCase")]
204pub struct EventBridgeEvent {
205 pub event_id: String,
206 pub source: String,
207 pub detail_type: String,
208 pub detail: String,
209 pub bus_name: String,
210 pub timestamp: String,
211}
212
213#[derive(Debug, Clone, Serialize, Deserialize)]
214#[serde(rename_all = "camelCase")]
215pub struct EventBridgeLambdaDelivery {
216 pub function_arn: String,
217 pub payload: String,
218 pub timestamp: String,
219}
220
221#[derive(Debug, Clone, Serialize, Deserialize)]
222#[serde(rename_all = "camelCase")]
223pub struct EventBridgeLogDelivery {
224 pub log_group_arn: String,
225 pub payload: String,
226 pub timestamp: String,
227}
228
229#[derive(Debug, Clone, Serialize, Deserialize)]
230#[serde(rename_all = "camelCase")]
231pub struct EventBridgeDeliveries {
232 pub lambda: Vec<EventBridgeLambdaDelivery>,
233 pub logs: Vec<EventBridgeLogDelivery>,
234}
235
236#[derive(Debug, Clone, Serialize, Deserialize)]
237#[serde(rename_all = "camelCase")]
238pub struct EventHistoryResponse {
239 pub events: Vec<EventBridgeEvent>,
240 pub deliveries: EventBridgeDeliveries,
241}
242
243#[derive(Debug, Clone, Serialize, Deserialize)]
244#[serde(rename_all = "camelCase")]
245pub struct FireRuleRequest {
246 pub bus_name: Option<String>,
247 pub rule_name: String,
248}
249
250#[derive(Debug, Clone, Serialize, Deserialize)]
251#[serde(rename_all = "camelCase")]
252pub struct FireRuleTarget {
253 #[serde(rename = "type")]
254 pub target_type: String,
255 pub arn: String,
256}
257
258#[derive(Debug, Clone, Serialize, Deserialize)]
259#[serde(rename_all = "camelCase")]
260pub struct FireRuleResponse {
261 pub targets: Vec<FireRuleTarget>,
262}
263
264#[derive(Debug, Clone, Serialize, Deserialize)]
267#[serde(rename_all = "camelCase")]
268pub struct S3Notification {
269 pub bucket: String,
270 pub key: String,
271 pub event_type: String,
272 pub timestamp: String,
273}
274
275#[derive(Debug, Clone, Serialize, Deserialize)]
276#[serde(rename_all = "camelCase")]
277pub struct S3NotificationsResponse {
278 pub notifications: Vec<S3Notification>,
279}
280
281#[derive(Debug, Clone, Serialize, Deserialize)]
282#[serde(rename_all = "camelCase")]
283pub struct LifecycleTickResponse {
284 pub processed_buckets: u64,
285 pub expired_objects: u64,
286 pub transitioned_objects: u64,
287}
288
289#[derive(Debug, Clone, Serialize, Deserialize)]
292#[serde(rename_all = "camelCase")]
293pub struct TtlTickResponse {
294 pub expired_items: u64,
295}
296
297#[derive(Debug, Clone, Serialize, Deserialize)]
300#[serde(rename_all = "camelCase")]
301pub struct RotationTickResponse {
302 pub rotated_secrets: Vec<String>,
303}
304
305#[derive(Debug, Clone, Serialize, Deserialize)]
308#[serde(rename_all = "camelCase")]
309pub struct UserConfirmationCodes {
310 pub confirmation_code: Option<String>,
311 pub attribute_verification_codes: serde_json::Value,
312}
313
314#[derive(Debug, Clone, Serialize, Deserialize)]
315#[serde(rename_all = "camelCase")]
316pub struct ConfirmationCode {
317 pub pool_id: String,
318 pub username: String,
319 pub code: String,
320 #[serde(rename = "type")]
321 pub code_type: String,
322 #[serde(skip_serializing_if = "Option::is_none")]
323 pub attribute: Option<String>,
324}
325
326#[derive(Debug, Clone, Serialize, Deserialize)]
327#[serde(rename_all = "camelCase")]
328pub struct ConfirmationCodesResponse {
329 pub codes: Vec<ConfirmationCode>,
330}
331
332#[derive(Debug, Clone, Serialize, Deserialize)]
333#[serde(rename_all = "camelCase")]
334pub struct ConfirmUserRequest {
335 pub user_pool_id: String,
336 pub username: String,
337}
338
339#[derive(Debug, Clone, Serialize, Deserialize)]
340#[serde(rename_all = "camelCase")]
341pub struct ConfirmUserResponse {
342 pub confirmed: bool,
343 #[serde(skip_serializing_if = "Option::is_none")]
344 pub error: Option<String>,
345}
346
347#[derive(Debug, Clone, Serialize, Deserialize)]
348#[serde(rename_all = "camelCase")]
349pub struct TokenInfo {
350 #[serde(rename = "type")]
351 pub token_type: String,
352 pub username: String,
353 pub pool_id: String,
354 pub client_id: String,
355 pub issued_at: f64,
356}
357
358#[derive(Debug, Clone, Serialize, Deserialize)]
359#[serde(rename_all = "camelCase")]
360pub struct TokensResponse {
361 pub tokens: Vec<TokenInfo>,
362}
363
364#[derive(Debug, Clone, Serialize, Deserialize)]
365#[serde(rename_all = "camelCase")]
366pub struct ExpireTokensRequest {
367 #[serde(skip_serializing_if = "Option::is_none")]
368 pub user_pool_id: Option<String>,
369 #[serde(skip_serializing_if = "Option::is_none")]
370 pub username: Option<String>,
371}
372
373#[derive(Debug, Clone, Serialize, Deserialize)]
374#[serde(rename_all = "camelCase")]
375pub struct ExpireTokensResponse {
376 pub expired_tokens: u64,
377}
378
379#[derive(Debug, Clone, Serialize, Deserialize)]
380#[serde(rename_all = "camelCase")]
381pub struct AuthEvent {
382 pub event_type: String,
383 pub username: String,
384 pub user_pool_id: String,
385 pub client_id: Option<String>,
386 pub timestamp: f64,
387 pub success: bool,
388}
389
390#[derive(Debug, Clone, Serialize, Deserialize)]
391#[serde(rename_all = "camelCase")]
392pub struct AuthEventsResponse {
393 pub events: Vec<AuthEvent>,
394}