rustack_ses_model/
types.rs

1//! Auto-generated from AWS SES Smithy model. DO NOT EDIT.
2
3use serde::{Deserialize, Serialize};
4
5/// SES BehaviorOnMXFailure enum.
6#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
7pub enum BehaviorOnMXFailure {
8    /// Default variant.
9    #[default]
10    RejectMessage,
11    UseDefaultValue,
12}
13
14impl BehaviorOnMXFailure {
15    /// Returns the string value of this enum variant.
16    #[must_use]
17    pub fn as_str(&self) -> &'static str {
18        match self {
19            Self::RejectMessage => "RejectMessage",
20            Self::UseDefaultValue => "UseDefaultValue",
21        }
22    }
23}
24
25impl std::fmt::Display for BehaviorOnMXFailure {
26    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
27        f.write_str(self.as_str())
28    }
29}
30
31impl From<&str> for BehaviorOnMXFailure {
32    fn from(s: &str) -> Self {
33        match s {
34            "RejectMessage" => Self::RejectMessage,
35            "UseDefaultValue" => Self::UseDefaultValue,
36            _ => Self::default(),
37        }
38    }
39}
40
41/// SES ConfigurationSetAttribute enum.
42#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
43pub enum ConfigurationSetAttribute {
44    /// Default variant.
45    #[default]
46    #[serde(rename = "deliveryOptions")]
47    DeliveryOptions,
48    #[serde(rename = "eventDestinations")]
49    EventDestinations,
50    #[serde(rename = "reputationOptions")]
51    ReputationOptions,
52    #[serde(rename = "trackingOptions")]
53    TrackingOptions,
54}
55
56impl ConfigurationSetAttribute {
57    /// Returns the string value of this enum variant.
58    #[must_use]
59    pub fn as_str(&self) -> &'static str {
60        match self {
61            Self::DeliveryOptions => "deliveryOptions",
62            Self::EventDestinations => "eventDestinations",
63            Self::ReputationOptions => "reputationOptions",
64            Self::TrackingOptions => "trackingOptions",
65        }
66    }
67}
68
69impl std::fmt::Display for ConfigurationSetAttribute {
70    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
71        f.write_str(self.as_str())
72    }
73}
74
75impl From<&str> for ConfigurationSetAttribute {
76    fn from(s: &str) -> Self {
77        match s {
78            "deliveryOptions" => Self::DeliveryOptions,
79            "eventDestinations" => Self::EventDestinations,
80            "reputationOptions" => Self::ReputationOptions,
81            "trackingOptions" => Self::TrackingOptions,
82            _ => Self::default(),
83        }
84    }
85}
86
87/// SES CustomMailFromStatus enum.
88#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
89pub enum CustomMailFromStatus {
90    /// Default variant.
91    #[default]
92    Failed,
93    Pending,
94    Success,
95    TemporaryFailure,
96}
97
98impl CustomMailFromStatus {
99    /// Returns the string value of this enum variant.
100    #[must_use]
101    pub fn as_str(&self) -> &'static str {
102        match self {
103            Self::Failed => "Failed",
104            Self::Pending => "Pending",
105            Self::Success => "Success",
106            Self::TemporaryFailure => "TemporaryFailure",
107        }
108    }
109}
110
111impl std::fmt::Display for CustomMailFromStatus {
112    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
113        f.write_str(self.as_str())
114    }
115}
116
117impl From<&str> for CustomMailFromStatus {
118    fn from(s: &str) -> Self {
119        match s {
120            "Failed" => Self::Failed,
121            "Pending" => Self::Pending,
122            "Success" => Self::Success,
123            "TemporaryFailure" => Self::TemporaryFailure,
124            _ => Self::default(),
125        }
126    }
127}
128
129/// SES DimensionValueSource enum.
130#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
131pub enum DimensionValueSource {
132    /// Default variant.
133    #[default]
134    #[serde(rename = "emailHeader")]
135    EmailHeader,
136    #[serde(rename = "linkTag")]
137    LinkTag,
138    #[serde(rename = "messageTag")]
139    MessageTag,
140}
141
142impl DimensionValueSource {
143    /// Returns the string value of this enum variant.
144    #[must_use]
145    pub fn as_str(&self) -> &'static str {
146        match self {
147            Self::EmailHeader => "emailHeader",
148            Self::LinkTag => "linkTag",
149            Self::MessageTag => "messageTag",
150        }
151    }
152}
153
154impl std::fmt::Display for DimensionValueSource {
155    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
156        f.write_str(self.as_str())
157    }
158}
159
160impl From<&str> for DimensionValueSource {
161    fn from(s: &str) -> Self {
162        match s {
163            "emailHeader" => Self::EmailHeader,
164            "linkTag" => Self::LinkTag,
165            "messageTag" => Self::MessageTag,
166            _ => Self::default(),
167        }
168    }
169}
170
171/// SES EventType enum.
172#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
173pub enum EventType {
174    /// Default variant.
175    #[default]
176    #[serde(rename = "bounce")]
177    Bounce,
178    #[serde(rename = "click")]
179    Click,
180    #[serde(rename = "complaint")]
181    Complaint,
182    #[serde(rename = "delivery")]
183    Delivery,
184    #[serde(rename = "open")]
185    Open,
186    #[serde(rename = "reject")]
187    Reject,
188    #[serde(rename = "renderingFailure")]
189    RenderingFailure,
190    #[serde(rename = "send")]
191    Send,
192}
193
194impl EventType {
195    /// Returns the string value of this enum variant.
196    #[must_use]
197    pub fn as_str(&self) -> &'static str {
198        match self {
199            Self::Bounce => "bounce",
200            Self::Click => "click",
201            Self::Complaint => "complaint",
202            Self::Delivery => "delivery",
203            Self::Open => "open",
204            Self::Reject => "reject",
205            Self::RenderingFailure => "renderingFailure",
206            Self::Send => "send",
207        }
208    }
209}
210
211impl std::fmt::Display for EventType {
212    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
213        f.write_str(self.as_str())
214    }
215}
216
217impl From<&str> for EventType {
218    fn from(s: &str) -> Self {
219        match s {
220            "bounce" => Self::Bounce,
221            "click" => Self::Click,
222            "complaint" => Self::Complaint,
223            "delivery" => Self::Delivery,
224            "open" => Self::Open,
225            "reject" => Self::Reject,
226            "renderingFailure" => Self::RenderingFailure,
227            "send" => Self::Send,
228            _ => Self::default(),
229        }
230    }
231}
232
233/// SES IdentityType enum.
234#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
235pub enum IdentityType {
236    /// Default variant.
237    #[default]
238    Domain,
239    EmailAddress,
240}
241
242impl IdentityType {
243    /// Returns the string value of this enum variant.
244    #[must_use]
245    pub fn as_str(&self) -> &'static str {
246        match self {
247            Self::Domain => "Domain",
248            Self::EmailAddress => "EmailAddress",
249        }
250    }
251}
252
253impl std::fmt::Display for IdentityType {
254    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
255        f.write_str(self.as_str())
256    }
257}
258
259impl From<&str> for IdentityType {
260    fn from(s: &str) -> Self {
261        match s {
262            "Domain" => Self::Domain,
263            "EmailAddress" => Self::EmailAddress,
264            _ => Self::default(),
265        }
266    }
267}
268
269/// SES InvocationType enum.
270#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
271pub enum InvocationType {
272    /// Default variant.
273    #[default]
274    Event,
275    RequestResponse,
276}
277
278impl InvocationType {
279    /// Returns the string value of this enum variant.
280    #[must_use]
281    pub fn as_str(&self) -> &'static str {
282        match self {
283            Self::Event => "Event",
284            Self::RequestResponse => "RequestResponse",
285        }
286    }
287}
288
289impl std::fmt::Display for InvocationType {
290    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
291        f.write_str(self.as_str())
292    }
293}
294
295impl From<&str> for InvocationType {
296    fn from(s: &str) -> Self {
297        match s {
298            "Event" => Self::Event,
299            "RequestResponse" => Self::RequestResponse,
300            _ => Self::default(),
301        }
302    }
303}
304
305/// SES NotificationType enum.
306#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
307pub enum NotificationType {
308    /// Default variant.
309    #[default]
310    Bounce,
311    Complaint,
312    Delivery,
313}
314
315impl NotificationType {
316    /// Returns the string value of this enum variant.
317    #[must_use]
318    pub fn as_str(&self) -> &'static str {
319        match self {
320            Self::Bounce => "Bounce",
321            Self::Complaint => "Complaint",
322            Self::Delivery => "Delivery",
323        }
324    }
325}
326
327impl std::fmt::Display for NotificationType {
328    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
329        f.write_str(self.as_str())
330    }
331}
332
333impl From<&str> for NotificationType {
334    fn from(s: &str) -> Self {
335        match s {
336            "Bounce" => Self::Bounce,
337            "Complaint" => Self::Complaint,
338            "Delivery" => Self::Delivery,
339            _ => Self::default(),
340        }
341    }
342}
343
344/// SES SNSActionEncoding enum.
345#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
346pub enum SNSActionEncoding {
347    /// Default variant.
348    #[default]
349    Base64,
350    #[serde(rename = "UTF-8")]
351    Utf8,
352}
353
354impl SNSActionEncoding {
355    /// Returns the string value of this enum variant.
356    #[must_use]
357    pub fn as_str(&self) -> &'static str {
358        match self {
359            Self::Base64 => "Base64",
360            Self::Utf8 => "UTF-8",
361        }
362    }
363}
364
365impl std::fmt::Display for SNSActionEncoding {
366    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
367        f.write_str(self.as_str())
368    }
369}
370
371impl From<&str> for SNSActionEncoding {
372    fn from(s: &str) -> Self {
373        match s {
374            "Base64" => Self::Base64,
375            "UTF-8" => Self::Utf8,
376            _ => Self::default(),
377        }
378    }
379}
380
381/// SES StopScope enum.
382#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
383pub enum StopScope {
384    /// Default variant.
385    #[default]
386    RuleSet,
387}
388
389impl StopScope {
390    /// Returns the string value of this enum variant.
391    #[must_use]
392    pub fn as_str(&self) -> &'static str {
393        match self {
394            Self::RuleSet => "RuleSet",
395        }
396    }
397}
398
399impl std::fmt::Display for StopScope {
400    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
401        f.write_str(self.as_str())
402    }
403}
404
405impl From<&str> for StopScope {
406    fn from(s: &str) -> Self {
407        match s {
408            "RuleSet" => Self::RuleSet,
409            _ => Self::default(),
410        }
411    }
412}
413
414/// SES TlsPolicy enum.
415#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
416pub enum TlsPolicy {
417    /// Default variant.
418    #[default]
419    Optional,
420    Require,
421}
422
423impl TlsPolicy {
424    /// Returns the string value of this enum variant.
425    #[must_use]
426    pub fn as_str(&self) -> &'static str {
427        match self {
428            Self::Optional => "Optional",
429            Self::Require => "Require",
430        }
431    }
432}
433
434impl std::fmt::Display for TlsPolicy {
435    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
436        f.write_str(self.as_str())
437    }
438}
439
440impl From<&str> for TlsPolicy {
441    fn from(s: &str) -> Self {
442        match s {
443            "Optional" => Self::Optional,
444            "Require" => Self::Require,
445            _ => Self::default(),
446        }
447    }
448}
449
450/// SES VerificationStatus enum.
451#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
452pub enum VerificationStatus {
453    /// Default variant.
454    #[default]
455    Failed,
456    NotStarted,
457    Pending,
458    Success,
459    TemporaryFailure,
460}
461
462impl VerificationStatus {
463    /// Returns the string value of this enum variant.
464    #[must_use]
465    pub fn as_str(&self) -> &'static str {
466        match self {
467            Self::Failed => "Failed",
468            Self::NotStarted => "NotStarted",
469            Self::Pending => "Pending",
470            Self::Success => "Success",
471            Self::TemporaryFailure => "TemporaryFailure",
472        }
473    }
474}
475
476impl std::fmt::Display for VerificationStatus {
477    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
478        f.write_str(self.as_str())
479    }
480}
481
482impl From<&str> for VerificationStatus {
483    fn from(s: &str) -> Self {
484        match s {
485            "Failed" => Self::Failed,
486            "NotStarted" => Self::NotStarted,
487            "Pending" => Self::Pending,
488            "Success" => Self::Success,
489            "TemporaryFailure" => Self::TemporaryFailure,
490            _ => Self::default(),
491        }
492    }
493}
494
495/// SES AddHeaderAction.
496#[derive(Debug, Clone, Default, Serialize, Deserialize)]
497#[serde(rename_all = "PascalCase")]
498pub struct AddHeaderAction {
499    pub header_name: String,
500    pub header_value: String,
501}
502
503/// SES Body.
504#[derive(Debug, Clone, Default, Serialize, Deserialize)]
505#[serde(rename_all = "PascalCase")]
506pub struct Body {
507    #[serde(skip_serializing_if = "Option::is_none")]
508    pub html: Option<Content>,
509    #[serde(skip_serializing_if = "Option::is_none")]
510    pub text: Option<Content>,
511}
512
513/// SES BounceAction.
514#[derive(Debug, Clone, Default, Serialize, Deserialize)]
515#[serde(rename_all = "PascalCase")]
516pub struct BounceAction {
517    pub message: String,
518    pub sender: String,
519    pub smtp_reply_code: String,
520    #[serde(skip_serializing_if = "Option::is_none")]
521    pub status_code: Option<String>,
522    #[serde(skip_serializing_if = "Option::is_none")]
523    pub topic_arn: Option<String>,
524}
525
526/// SES CloudWatchDestination.
527#[derive(Debug, Clone, Default, Serialize, Deserialize)]
528#[serde(rename_all = "PascalCase")]
529pub struct CloudWatchDestination {
530    #[serde(default, skip_serializing_if = "Vec::is_empty")]
531    pub dimension_configurations: Vec<CloudWatchDimensionConfiguration>,
532}
533
534/// SES CloudWatchDimensionConfiguration.
535#[derive(Debug, Clone, Default, Serialize, Deserialize)]
536#[serde(rename_all = "PascalCase")]
537pub struct CloudWatchDimensionConfiguration {
538    pub default_dimension_value: String,
539    pub dimension_name: String,
540    pub dimension_value_source: DimensionValueSource,
541}
542
543/// SES ConfigurationSet.
544#[derive(Debug, Clone, Default, Serialize, Deserialize)]
545#[serde(rename_all = "PascalCase")]
546pub struct ConfigurationSet {
547    pub name: String,
548}
549
550/// SES ConnectAction.
551#[derive(Debug, Clone, Default, Serialize, Deserialize)]
552#[serde(rename_all = "PascalCase")]
553pub struct ConnectAction {
554    #[serde(rename = "IAMRoleARN")]
555    pub iam_role_arn: String,
556    #[serde(rename = "InstanceARN")]
557    pub instance_arn: String,
558}
559
560/// SES Content.
561#[derive(Debug, Clone, Default, Serialize, Deserialize)]
562#[serde(rename_all = "PascalCase")]
563pub struct Content {
564    #[serde(skip_serializing_if = "Option::is_none")]
565    pub charset: Option<String>,
566    pub data: String,
567}
568
569/// SES DeliveryOptions.
570#[derive(Debug, Clone, Default, Serialize, Deserialize)]
571#[serde(rename_all = "PascalCase")]
572pub struct DeliveryOptions {
573    #[serde(skip_serializing_if = "Option::is_none")]
574    pub tls_policy: Option<TlsPolicy>,
575}
576
577/// SES Destination.
578#[derive(Debug, Clone, Default, Serialize, Deserialize)]
579#[serde(rename_all = "PascalCase")]
580pub struct Destination {
581    #[serde(default, skip_serializing_if = "Vec::is_empty")]
582    pub bcc_addresses: Vec<String>,
583    #[serde(default, skip_serializing_if = "Vec::is_empty")]
584    pub cc_addresses: Vec<String>,
585    #[serde(default, skip_serializing_if = "Vec::is_empty")]
586    pub to_addresses: Vec<String>,
587}
588
589/// SES EventDestination.
590#[derive(Debug, Clone, Default, Serialize, Deserialize)]
591#[serde(rename_all = "PascalCase")]
592pub struct EventDestination {
593    #[serde(skip_serializing_if = "Option::is_none")]
594    pub cloud_watch_destination: Option<CloudWatchDestination>,
595    #[serde(skip_serializing_if = "Option::is_none")]
596    pub enabled: Option<bool>,
597    #[serde(skip_serializing_if = "Option::is_none")]
598    pub kinesis_firehose_destination: Option<KinesisFirehoseDestination>,
599    #[serde(default, skip_serializing_if = "Vec::is_empty")]
600    pub matching_event_types: Vec<EventType>,
601    pub name: String,
602    #[serde(rename = "SNSDestination")]
603    #[serde(skip_serializing_if = "Option::is_none")]
604    pub sns_destination: Option<SNSDestination>,
605}
606
607/// SES IdentityDkimAttributes.
608#[derive(Debug, Clone, Default, Serialize, Deserialize)]
609#[serde(rename_all = "PascalCase")]
610pub struct IdentityDkimAttributes {
611    pub dkim_enabled: bool,
612    #[serde(default, skip_serializing_if = "Vec::is_empty")]
613    pub dkim_tokens: Vec<String>,
614    pub dkim_verification_status: VerificationStatus,
615}
616
617/// SES IdentityMailFromDomainAttributes.
618#[derive(Debug, Clone, Default, Serialize, Deserialize)]
619#[serde(rename_all = "PascalCase")]
620pub struct IdentityMailFromDomainAttributes {
621    #[serde(rename = "BehaviorOnMXFailure")]
622    pub behavior_on_mx_failure: BehaviorOnMXFailure,
623    pub mail_from_domain: String,
624    pub mail_from_domain_status: CustomMailFromStatus,
625}
626
627/// SES IdentityNotificationAttributes.
628#[derive(Debug, Clone, Default, Serialize, Deserialize)]
629#[serde(rename_all = "PascalCase")]
630pub struct IdentityNotificationAttributes {
631    pub bounce_topic: String,
632    pub complaint_topic: String,
633    pub delivery_topic: String,
634    pub forwarding_enabled: bool,
635    #[serde(skip_serializing_if = "Option::is_none")]
636    pub headers_in_bounce_notifications_enabled: Option<bool>,
637    #[serde(skip_serializing_if = "Option::is_none")]
638    pub headers_in_complaint_notifications_enabled: Option<bool>,
639    #[serde(skip_serializing_if = "Option::is_none")]
640    pub headers_in_delivery_notifications_enabled: Option<bool>,
641}
642
643/// SES IdentityVerificationAttributes.
644#[derive(Debug, Clone, Default, Serialize, Deserialize)]
645#[serde(rename_all = "PascalCase")]
646pub struct IdentityVerificationAttributes {
647    pub verification_status: VerificationStatus,
648    #[serde(skip_serializing_if = "Option::is_none")]
649    pub verification_token: Option<String>,
650}
651
652/// SES KinesisFirehoseDestination.
653#[derive(Debug, Clone, Default, Serialize, Deserialize)]
654#[serde(rename_all = "PascalCase")]
655pub struct KinesisFirehoseDestination {
656    #[serde(rename = "DeliveryStreamARN")]
657    pub delivery_stream_arn: String,
658    #[serde(rename = "IAMRoleARN")]
659    pub iam_role_arn: String,
660}
661
662/// SES LambdaAction.
663#[derive(Debug, Clone, Default, Serialize, Deserialize)]
664#[serde(rename_all = "PascalCase")]
665pub struct LambdaAction {
666    pub function_arn: String,
667    #[serde(skip_serializing_if = "Option::is_none")]
668    pub invocation_type: Option<InvocationType>,
669    #[serde(skip_serializing_if = "Option::is_none")]
670    pub topic_arn: Option<String>,
671}
672
673/// SES Message.
674#[derive(Debug, Clone, Default, Serialize, Deserialize)]
675#[serde(rename_all = "PascalCase")]
676pub struct Message {
677    pub body: Body,
678    pub subject: Content,
679}
680
681/// SES MessageTag.
682#[derive(Debug, Clone, Default, Serialize, Deserialize)]
683#[serde(rename_all = "PascalCase")]
684pub struct MessageTag {
685    pub name: String,
686    pub value: String,
687}
688
689/// SES RawMessage.
690#[derive(Debug, Clone, Default, Serialize, Deserialize)]
691#[serde(rename_all = "PascalCase")]
692pub struct RawMessage {
693    pub data: Vec<u8>,
694}
695
696/// SES ReceiptAction.
697#[derive(Debug, Clone, Default, Serialize, Deserialize)]
698#[serde(rename_all = "PascalCase")]
699pub struct ReceiptAction {
700    #[serde(skip_serializing_if = "Option::is_none")]
701    pub add_header_action: Option<AddHeaderAction>,
702    #[serde(skip_serializing_if = "Option::is_none")]
703    pub bounce_action: Option<BounceAction>,
704    #[serde(skip_serializing_if = "Option::is_none")]
705    pub connect_action: Option<ConnectAction>,
706    #[serde(skip_serializing_if = "Option::is_none")]
707    pub lambda_action: Option<LambdaAction>,
708    #[serde(skip_serializing_if = "Option::is_none")]
709    pub s3_action: Option<S3Action>,
710    #[serde(rename = "SNSAction")]
711    #[serde(skip_serializing_if = "Option::is_none")]
712    pub sns_action: Option<SNSAction>,
713    #[serde(skip_serializing_if = "Option::is_none")]
714    pub stop_action: Option<StopAction>,
715    #[serde(skip_serializing_if = "Option::is_none")]
716    pub workmail_action: Option<WorkmailAction>,
717}
718
719/// SES ReceiptRule.
720#[derive(Debug, Clone, Default, Serialize, Deserialize)]
721#[serde(rename_all = "PascalCase")]
722pub struct ReceiptRule {
723    #[serde(default, skip_serializing_if = "Vec::is_empty")]
724    pub actions: Vec<ReceiptAction>,
725    #[serde(skip_serializing_if = "Option::is_none")]
726    pub enabled: Option<bool>,
727    pub name: String,
728    #[serde(default, skip_serializing_if = "Vec::is_empty")]
729    pub recipients: Vec<String>,
730    #[serde(skip_serializing_if = "Option::is_none")]
731    pub scan_enabled: Option<bool>,
732    #[serde(skip_serializing_if = "Option::is_none")]
733    pub tls_policy: Option<TlsPolicy>,
734}
735
736/// SES ReceiptRuleSetMetadata.
737#[derive(Debug, Clone, Default, Serialize, Deserialize)]
738#[serde(rename_all = "PascalCase")]
739pub struct ReceiptRuleSetMetadata {
740    #[serde(skip_serializing_if = "Option::is_none")]
741    pub created_timestamp: Option<chrono::DateTime<chrono::Utc>>,
742    #[serde(skip_serializing_if = "Option::is_none")]
743    pub name: Option<String>,
744}
745
746/// SES ReputationOptions.
747#[derive(Debug, Clone, Default, Serialize, Deserialize)]
748#[serde(rename_all = "PascalCase")]
749pub struct ReputationOptions {
750    #[serde(skip_serializing_if = "Option::is_none")]
751    pub last_fresh_start: Option<chrono::DateTime<chrono::Utc>>,
752    #[serde(skip_serializing_if = "Option::is_none")]
753    pub reputation_metrics_enabled: Option<bool>,
754    #[serde(skip_serializing_if = "Option::is_none")]
755    pub sending_enabled: Option<bool>,
756}
757
758/// SES S3Action.
759#[derive(Debug, Clone, Default, Serialize, Deserialize)]
760#[serde(rename_all = "PascalCase")]
761pub struct S3Action {
762    pub bucket_name: String,
763    #[serde(skip_serializing_if = "Option::is_none")]
764    pub iam_role_arn: Option<String>,
765    #[serde(skip_serializing_if = "Option::is_none")]
766    pub kms_key_arn: Option<String>,
767    #[serde(skip_serializing_if = "Option::is_none")]
768    pub object_key_prefix: Option<String>,
769    #[serde(skip_serializing_if = "Option::is_none")]
770    pub topic_arn: Option<String>,
771}
772
773/// SES SNSAction.
774#[derive(Debug, Clone, Default, Serialize, Deserialize)]
775#[serde(rename_all = "PascalCase")]
776pub struct SNSAction {
777    #[serde(skip_serializing_if = "Option::is_none")]
778    pub encoding: Option<SNSActionEncoding>,
779    pub topic_arn: String,
780}
781
782/// SES SNSDestination.
783#[derive(Debug, Clone, Default, Serialize, Deserialize)]
784#[serde(rename_all = "PascalCase")]
785pub struct SNSDestination {
786    #[serde(rename = "TopicARN")]
787    pub topic_arn: String,
788}
789
790/// SES SendDataPoint.
791#[derive(Debug, Clone, Default, Serialize, Deserialize)]
792#[serde(rename_all = "PascalCase")]
793pub struct SendDataPoint {
794    #[serde(skip_serializing_if = "Option::is_none")]
795    pub bounces: Option<i64>,
796    #[serde(skip_serializing_if = "Option::is_none")]
797    pub complaints: Option<i64>,
798    #[serde(skip_serializing_if = "Option::is_none")]
799    pub delivery_attempts: Option<i64>,
800    #[serde(skip_serializing_if = "Option::is_none")]
801    pub rejects: Option<i64>,
802    #[serde(skip_serializing_if = "Option::is_none")]
803    pub timestamp: Option<chrono::DateTime<chrono::Utc>>,
804}
805
806/// SES StopAction.
807#[derive(Debug, Clone, Default, Serialize, Deserialize)]
808#[serde(rename_all = "PascalCase")]
809pub struct StopAction {
810    pub scope: StopScope,
811    #[serde(skip_serializing_if = "Option::is_none")]
812    pub topic_arn: Option<String>,
813}
814
815/// SES Template.
816#[derive(Debug, Clone, Default, Serialize, Deserialize)]
817#[serde(rename_all = "PascalCase")]
818pub struct Template {
819    #[serde(skip_serializing_if = "Option::is_none")]
820    pub html_part: Option<String>,
821    #[serde(skip_serializing_if = "Option::is_none")]
822    pub subject_part: Option<String>,
823    pub template_name: String,
824    #[serde(skip_serializing_if = "Option::is_none")]
825    pub text_part: Option<String>,
826}
827
828/// SES TemplateMetadata.
829#[derive(Debug, Clone, Default, Serialize, Deserialize)]
830#[serde(rename_all = "PascalCase")]
831pub struct TemplateMetadata {
832    #[serde(skip_serializing_if = "Option::is_none")]
833    pub created_timestamp: Option<chrono::DateTime<chrono::Utc>>,
834    #[serde(skip_serializing_if = "Option::is_none")]
835    pub name: Option<String>,
836}
837
838/// SES TrackingOptions.
839#[derive(Debug, Clone, Default, Serialize, Deserialize)]
840#[serde(rename_all = "PascalCase")]
841pub struct TrackingOptions {
842    #[serde(skip_serializing_if = "Option::is_none")]
843    pub custom_redirect_domain: Option<String>,
844}
845
846/// SES WorkmailAction.
847#[derive(Debug, Clone, Default, Serialize, Deserialize)]
848#[serde(rename_all = "PascalCase")]
849pub struct WorkmailAction {
850    pub organization_arn: String,
851    #[serde(skip_serializing_if = "Option::is_none")]
852    pub topic_arn: Option<String>,
853}
rustack_ses_model/types.rs

rustack_ses_model/
types.rs
