use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BlacklistEntry {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ListingTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub listing_time: Option<f64>,
#[serde(rename = "RblName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rbl_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Body {
#[serde(rename = "Html")]
#[serde(skip_serializing_if = "Option::is_none")]
pub html: Option<Content>,
#[serde(rename = "Text")]
#[serde(skip_serializing_if = "Option::is_none")]
pub text: Option<Content>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CloudWatchDestination {
#[serde(rename = "DimensionConfigurations")]
pub dimension_configurations: Vec<CloudWatchDimensionConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CloudWatchDimensionConfiguration {
#[serde(rename = "DefaultDimensionValue")]
pub default_dimension_value: String,
#[serde(rename = "DimensionName")]
pub dimension_name: String,
#[serde(rename = "DimensionValueSource")]
pub dimension_value_source: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Content {
#[serde(rename = "Charset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub charset: Option<String>,
#[serde(rename = "Data")]
pub data: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateConfigurationSetEventDestinationRequest {
#[serde(rename = "ConfigurationSetName")]
pub configuration_set_name: String,
#[serde(rename = "EventDestination")]
pub event_destination: EventDestinationDefinition,
#[serde(rename = "EventDestinationName")]
pub event_destination_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateConfigurationSetEventDestinationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateConfigurationSetRequest {
#[serde(rename = "ConfigurationSetName")]
pub configuration_set_name: String,
#[serde(rename = "DeliveryOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delivery_options: Option<DeliveryOptions>,
#[serde(rename = "ReputationOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reputation_options: Option<ReputationOptions>,
#[serde(rename = "SendingOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sending_options: Option<SendingOptions>,
#[serde(rename = "SuppressionOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub suppression_options: Option<SuppressionOptions>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "TrackingOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tracking_options: Option<TrackingOptions>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateConfigurationSetResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDedicatedIpPoolRequest {
#[serde(rename = "PoolName")]
pub pool_name: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDedicatedIpPoolResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDeliverabilityTestReportRequest {
#[serde(rename = "Content")]
pub content: EmailContent,
#[serde(rename = "FromEmailAddress")]
pub from_email_address: String,
#[serde(rename = "ReportName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub report_name: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDeliverabilityTestReportResponse {
#[serde(rename = "DeliverabilityTestStatus")]
pub deliverability_test_status: String,
#[serde(rename = "ReportId")]
pub report_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateEmailIdentityRequest {
#[serde(rename = "DkimSigningAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dkim_signing_attributes: Option<DkimSigningAttributes>,
#[serde(rename = "EmailIdentity")]
pub email_identity: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateEmailIdentityResponse {
#[serde(rename = "DkimAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dkim_attributes: Option<DkimAttributes>,
#[serde(rename = "IdentityType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_type: Option<String>,
#[serde(rename = "VerifiedForSendingStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub verified_for_sending_status: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DailyVolume {
#[serde(rename = "DomainIspPlacements")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_isp_placements: Option<Vec<DomainIspPlacement>>,
#[serde(rename = "StartDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_date: Option<f64>,
#[serde(rename = "VolumeStatistics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_statistics: Option<VolumeStatistics>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DedicatedIp {
#[serde(rename = "Ip")]
pub ip: String,
#[serde(rename = "PoolName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pool_name: Option<String>,
#[serde(rename = "WarmupPercentage")]
pub warmup_percentage: i64,
#[serde(rename = "WarmupStatus")]
pub warmup_status: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteConfigurationSetEventDestinationRequest {
#[serde(rename = "ConfigurationSetName")]
pub configuration_set_name: String,
#[serde(rename = "EventDestinationName")]
pub event_destination_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteConfigurationSetEventDestinationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteConfigurationSetRequest {
#[serde(rename = "ConfigurationSetName")]
pub configuration_set_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteConfigurationSetResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDedicatedIpPoolRequest {
#[serde(rename = "PoolName")]
pub pool_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDedicatedIpPoolResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteEmailIdentityRequest {
#[serde(rename = "EmailIdentity")]
pub email_identity: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteEmailIdentityResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteSuppressedDestinationRequest {
#[serde(rename = "EmailAddress")]
pub email_address: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteSuppressedDestinationResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeliverabilityTestReport {
#[serde(rename = "CreateDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_date: Option<f64>,
#[serde(rename = "DeliverabilityTestStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deliverability_test_status: Option<String>,
#[serde(rename = "FromEmailAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_email_address: Option<String>,
#[serde(rename = "ReportId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub report_id: Option<String>,
#[serde(rename = "ReportName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub report_name: Option<String>,
#[serde(rename = "Subject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subject: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DeliveryOptions {
#[serde(rename = "SendingPoolName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sending_pool_name: Option<String>,
#[serde(rename = "TlsPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tls_policy: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Destination {
#[serde(rename = "BccAddresses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bcc_addresses: Option<Vec<String>>,
#[serde(rename = "CcAddresses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cc_addresses: Option<Vec<String>>,
#[serde(rename = "ToAddresses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub to_addresses: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DkimAttributes {
#[serde(rename = "SigningAttributesOrigin")]
#[serde(skip_serializing_if = "Option::is_none")]
pub signing_attributes_origin: Option<String>,
#[serde(rename = "SigningEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub signing_enabled: Option<bool>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Tokens")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tokens: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DkimSigningAttributes {
#[serde(rename = "DomainSigningPrivateKey")]
pub domain_signing_private_key: String,
#[serde(rename = "DomainSigningSelector")]
pub domain_signing_selector: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DomainDeliverabilityCampaign {
#[serde(rename = "CampaignId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub campaign_id: Option<String>,
#[serde(rename = "DeleteRate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delete_rate: Option<f64>,
#[serde(rename = "Esps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub esps: Option<Vec<String>>,
#[serde(rename = "FirstSeenDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub first_seen_date_time: Option<f64>,
#[serde(rename = "FromAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_address: Option<String>,
#[serde(rename = "ImageUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_url: Option<String>,
#[serde(rename = "InboxCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub inbox_count: Option<i64>,
#[serde(rename = "LastSeenDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_seen_date_time: Option<f64>,
#[serde(rename = "ProjectedVolume")]
#[serde(skip_serializing_if = "Option::is_none")]
pub projected_volume: Option<i64>,
#[serde(rename = "ReadDeleteRate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub read_delete_rate: Option<f64>,
#[serde(rename = "ReadRate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub read_rate: Option<f64>,
#[serde(rename = "SendingIps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sending_ips: Option<Vec<String>>,
#[serde(rename = "SpamCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub spam_count: Option<i64>,
#[serde(rename = "Subject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subject: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DomainDeliverabilityTrackingOption {
#[serde(rename = "Domain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain: Option<String>,
#[serde(rename = "InboxPlacementTrackingOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub inbox_placement_tracking_option: Option<InboxPlacementTrackingOption>,
#[serde(rename = "SubscriptionStartDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription_start_date: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DomainIspPlacement {
#[serde(rename = "InboxPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub inbox_percentage: Option<f64>,
#[serde(rename = "InboxRawCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub inbox_raw_count: Option<i64>,
#[serde(rename = "IspName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub isp_name: Option<String>,
#[serde(rename = "SpamPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub spam_percentage: Option<f64>,
#[serde(rename = "SpamRawCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub spam_raw_count: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EmailContent {
#[serde(rename = "Raw")]
#[serde(skip_serializing_if = "Option::is_none")]
pub raw: Option<RawMessage>,
#[serde(rename = "Simple")]
#[serde(skip_serializing_if = "Option::is_none")]
pub simple: Option<Message>,
#[serde(rename = "Template")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template: Option<Template>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EventDestination {
#[serde(rename = "CloudWatchDestination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_destination: Option<CloudWatchDestination>,
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "KinesisFirehoseDestination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_firehose_destination: Option<KinesisFirehoseDestination>,
#[serde(rename = "MatchingEventTypes")]
pub matching_event_types: Vec<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "PinpointDestination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pinpoint_destination: Option<PinpointDestination>,
#[serde(rename = "SnsDestination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sns_destination: Option<SnsDestination>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EventDestinationDefinition {
#[serde(rename = "CloudWatchDestination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_destination: Option<CloudWatchDestination>,
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "KinesisFirehoseDestination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_firehose_destination: Option<KinesisFirehoseDestination>,
#[serde(rename = "MatchingEventTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub matching_event_types: Option<Vec<String>>,
#[serde(rename = "PinpointDestination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pinpoint_destination: Option<PinpointDestination>,
#[serde(rename = "SnsDestination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sns_destination: Option<SnsDestination>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAccountRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAccountResponse {
#[serde(rename = "DedicatedIpAutoWarmupEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dedicated_ip_auto_warmup_enabled: Option<bool>,
#[serde(rename = "EnforcementStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enforcement_status: Option<String>,
#[serde(rename = "ProductionAccessEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub production_access_enabled: Option<bool>,
#[serde(rename = "SendQuota")]
#[serde(skip_serializing_if = "Option::is_none")]
pub send_quota: Option<SendQuota>,
#[serde(rename = "SendingEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sending_enabled: Option<bool>,
#[serde(rename = "SuppressionAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub suppression_attributes: Option<SuppressionAttributes>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetBlacklistReportsRequest {
#[serde(rename = "BlacklistItemNames")]
pub blacklist_item_names: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetBlacklistReportsResponse {
#[serde(rename = "BlacklistReport")]
pub blacklist_report: ::std::collections::HashMap<String, Vec<BlacklistEntry>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetConfigurationSetEventDestinationsRequest {
#[serde(rename = "ConfigurationSetName")]
pub configuration_set_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetConfigurationSetEventDestinationsResponse {
#[serde(rename = "EventDestinations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_destinations: Option<Vec<EventDestination>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetConfigurationSetRequest {
#[serde(rename = "ConfigurationSetName")]
pub configuration_set_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetConfigurationSetResponse {
#[serde(rename = "ConfigurationSetName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_set_name: Option<String>,
#[serde(rename = "DeliveryOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delivery_options: Option<DeliveryOptions>,
#[serde(rename = "ReputationOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reputation_options: Option<ReputationOptions>,
#[serde(rename = "SendingOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sending_options: Option<SendingOptions>,
#[serde(rename = "SuppressionOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub suppression_options: Option<SuppressionOptions>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "TrackingOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tracking_options: Option<TrackingOptions>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDedicatedIpRequest {
#[serde(rename = "Ip")]
pub ip: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDedicatedIpResponse {
#[serde(rename = "DedicatedIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dedicated_ip: Option<DedicatedIp>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDedicatedIpsRequest {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PoolName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pool_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDedicatedIpsResponse {
#[serde(rename = "DedicatedIps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dedicated_ips: Option<Vec<DedicatedIp>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDeliverabilityDashboardOptionsRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDeliverabilityDashboardOptionsResponse {
#[serde(rename = "AccountStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_status: Option<String>,
#[serde(rename = "ActiveSubscribedDomains")]
#[serde(skip_serializing_if = "Option::is_none")]
pub active_subscribed_domains: Option<Vec<DomainDeliverabilityTrackingOption>>,
#[serde(rename = "DashboardEnabled")]
pub dashboard_enabled: bool,
#[serde(rename = "PendingExpirationSubscribedDomains")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pending_expiration_subscribed_domains: Option<Vec<DomainDeliverabilityTrackingOption>>,
#[serde(rename = "SubscriptionExpiryDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription_expiry_date: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDeliverabilityTestReportRequest {
#[serde(rename = "ReportId")]
pub report_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDeliverabilityTestReportResponse {
#[serde(rename = "DeliverabilityTestReport")]
pub deliverability_test_report: DeliverabilityTestReport,
#[serde(rename = "IspPlacements")]
pub isp_placements: Vec<IspPlacement>,
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "OverallPlacement")]
pub overall_placement: PlacementStatistics,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDomainDeliverabilityCampaignRequest {
#[serde(rename = "CampaignId")]
pub campaign_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDomainDeliverabilityCampaignResponse {
#[serde(rename = "DomainDeliverabilityCampaign")]
pub domain_deliverability_campaign: DomainDeliverabilityCampaign,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDomainStatisticsReportRequest {
#[serde(rename = "Domain")]
pub domain: String,
#[serde(rename = "EndDate")]
pub end_date: f64,
#[serde(rename = "StartDate")]
pub start_date: f64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDomainStatisticsReportResponse {
#[serde(rename = "DailyVolumes")]
pub daily_volumes: Vec<DailyVolume>,
#[serde(rename = "OverallVolume")]
pub overall_volume: OverallVolume,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetEmailIdentityRequest {
#[serde(rename = "EmailIdentity")]
pub email_identity: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetEmailIdentityResponse {
#[serde(rename = "DkimAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dkim_attributes: Option<DkimAttributes>,
#[serde(rename = "FeedbackForwardingStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub feedback_forwarding_status: Option<bool>,
#[serde(rename = "IdentityType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_type: Option<String>,
#[serde(rename = "MailFromAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mail_from_attributes: Option<MailFromAttributes>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "VerifiedForSendingStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub verified_for_sending_status: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetSuppressedDestinationRequest {
#[serde(rename = "EmailAddress")]
pub email_address: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetSuppressedDestinationResponse {
#[serde(rename = "SuppressedDestination")]
pub suppressed_destination: SuppressedDestination,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct IdentityInfo {
#[serde(rename = "IdentityName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_name: Option<String>,
#[serde(rename = "IdentityType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_type: Option<String>,
#[serde(rename = "SendingEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sending_enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct InboxPlacementTrackingOption {
#[serde(rename = "Global")]
#[serde(skip_serializing_if = "Option::is_none")]
pub global: Option<bool>,
#[serde(rename = "TrackedIsps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tracked_isps: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct IspPlacement {
#[serde(rename = "IspName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub isp_name: Option<String>,
#[serde(rename = "PlacementStatistics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub placement_statistics: Option<PlacementStatistics>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct KinesisFirehoseDestination {
#[serde(rename = "DeliveryStreamArn")]
pub delivery_stream_arn: String,
#[serde(rename = "IamRoleArn")]
pub iam_role_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListConfigurationSetsRequest {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListConfigurationSetsResponse {
#[serde(rename = "ConfigurationSets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_sets: Option<Vec<String>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDedicatedIpPoolsRequest {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDedicatedIpPoolsResponse {
#[serde(rename = "DedicatedIpPools")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dedicated_ip_pools: Option<Vec<String>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDeliverabilityTestReportsRequest {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDeliverabilityTestReportsResponse {
#[serde(rename = "DeliverabilityTestReports")]
pub deliverability_test_reports: Vec<DeliverabilityTestReport>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDomainDeliverabilityCampaignsRequest {
#[serde(rename = "EndDate")]
pub end_date: f64,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "StartDate")]
pub start_date: f64,
#[serde(rename = "SubscribedDomain")]
pub subscribed_domain: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDomainDeliverabilityCampaignsResponse {
#[serde(rename = "DomainDeliverabilityCampaigns")]
pub domain_deliverability_campaigns: Vec<DomainDeliverabilityCampaign>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListEmailIdentitiesRequest {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListEmailIdentitiesResponse {
#[serde(rename = "EmailIdentities")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_identities: Option<Vec<IdentityInfo>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListSuppressedDestinationsRequest {
#[serde(rename = "EndDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_date: Option<f64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "Reasons")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reasons: Option<Vec<String>>,
#[serde(rename = "StartDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_date: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListSuppressedDestinationsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SuppressedDestinationSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub suppressed_destination_summaries: Option<Vec<SuppressedDestinationSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MailFromAttributes {
#[serde(rename = "BehaviorOnMxFailure")]
pub behavior_on_mx_failure: String,
#[serde(rename = "MailFromDomain")]
pub mail_from_domain: String,
#[serde(rename = "MailFromDomainStatus")]
pub mail_from_domain_status: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Message {
#[serde(rename = "Body")]
pub body: Body,
#[serde(rename = "Subject")]
pub subject: Content,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct MessageTag {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OverallVolume {
#[serde(rename = "DomainIspPlacements")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_isp_placements: Option<Vec<DomainIspPlacement>>,
#[serde(rename = "ReadRatePercent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub read_rate_percent: Option<f64>,
#[serde(rename = "VolumeStatistics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_statistics: Option<VolumeStatistics>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct PinpointDestination {
#[serde(rename = "ApplicationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PlacementStatistics {
#[serde(rename = "DkimPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dkim_percentage: Option<f64>,
#[serde(rename = "InboxPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub inbox_percentage: Option<f64>,
#[serde(rename = "MissingPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub missing_percentage: Option<f64>,
#[serde(rename = "SpamPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub spam_percentage: Option<f64>,
#[serde(rename = "SpfPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub spf_percentage: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutAccountDedicatedIpWarmupAttributesRequest {
#[serde(rename = "AutoWarmupEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_warmup_enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutAccountDedicatedIpWarmupAttributesResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutAccountSendingAttributesRequest {
#[serde(rename = "SendingEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sending_enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutAccountSendingAttributesResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutAccountSuppressionAttributesRequest {
#[serde(rename = "SuppressedReasons")]
#[serde(skip_serializing_if = "Option::is_none")]
pub suppressed_reasons: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutAccountSuppressionAttributesResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutConfigurationSetDeliveryOptionsRequest {
#[serde(rename = "ConfigurationSetName")]
pub configuration_set_name: String,
#[serde(rename = "SendingPoolName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sending_pool_name: Option<String>,
#[serde(rename = "TlsPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tls_policy: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutConfigurationSetDeliveryOptionsResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutConfigurationSetReputationOptionsRequest {
#[serde(rename = "ConfigurationSetName")]
pub configuration_set_name: String,
#[serde(rename = "ReputationMetricsEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reputation_metrics_enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutConfigurationSetReputationOptionsResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutConfigurationSetSendingOptionsRequest {
#[serde(rename = "ConfigurationSetName")]
pub configuration_set_name: String,
#[serde(rename = "SendingEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sending_enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutConfigurationSetSendingOptionsResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutConfigurationSetSuppressionOptionsRequest {
#[serde(rename = "ConfigurationSetName")]
pub configuration_set_name: String,
#[serde(rename = "SuppressedReasons")]
#[serde(skip_serializing_if = "Option::is_none")]
pub suppressed_reasons: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutConfigurationSetSuppressionOptionsResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutConfigurationSetTrackingOptionsRequest {
#[serde(rename = "ConfigurationSetName")]
pub configuration_set_name: String,
#[serde(rename = "CustomRedirectDomain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_redirect_domain: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutConfigurationSetTrackingOptionsResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutDedicatedIpInPoolRequest {
#[serde(rename = "DestinationPoolName")]
pub destination_pool_name: String,
#[serde(rename = "Ip")]
pub ip: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutDedicatedIpInPoolResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutDedicatedIpWarmupAttributesRequest {
#[serde(rename = "Ip")]
pub ip: String,
#[serde(rename = "WarmupPercentage")]
pub warmup_percentage: i64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutDedicatedIpWarmupAttributesResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutDeliverabilityDashboardOptionRequest {
#[serde(rename = "DashboardEnabled")]
pub dashboard_enabled: bool,
#[serde(rename = "SubscribedDomains")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subscribed_domains: Option<Vec<DomainDeliverabilityTrackingOption>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutDeliverabilityDashboardOptionResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutEmailIdentityDkimAttributesRequest {
#[serde(rename = "EmailIdentity")]
pub email_identity: String,
#[serde(rename = "SigningEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub signing_enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutEmailIdentityDkimAttributesResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutEmailIdentityDkimSigningAttributesRequest {
#[serde(rename = "EmailIdentity")]
pub email_identity: String,
#[serde(rename = "SigningAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub signing_attributes: Option<DkimSigningAttributes>,
#[serde(rename = "SigningAttributesOrigin")]
pub signing_attributes_origin: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutEmailIdentityDkimSigningAttributesResponse {
#[serde(rename = "DkimStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dkim_status: Option<String>,
#[serde(rename = "DkimTokens")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dkim_tokens: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutEmailIdentityFeedbackAttributesRequest {
#[serde(rename = "EmailForwardingEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_forwarding_enabled: Option<bool>,
#[serde(rename = "EmailIdentity")]
pub email_identity: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutEmailIdentityFeedbackAttributesResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutEmailIdentityMailFromAttributesRequest {
#[serde(rename = "BehaviorOnMxFailure")]
#[serde(skip_serializing_if = "Option::is_none")]
pub behavior_on_mx_failure: Option<String>,
#[serde(rename = "EmailIdentity")]
pub email_identity: String,
#[serde(rename = "MailFromDomain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mail_from_domain: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutEmailIdentityMailFromAttributesResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutSuppressedDestinationRequest {
#[serde(rename = "EmailAddress")]
pub email_address: String,
#[serde(rename = "Reason")]
pub reason: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutSuppressedDestinationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RawMessage {
#[serde(rename = "Data")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
pub data: bytes::Bytes,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ReputationOptions {
#[serde(rename = "LastFreshStart")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_fresh_start: Option<f64>,
#[serde(rename = "ReputationMetricsEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reputation_metrics_enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SendEmailRequest {
#[serde(rename = "ConfigurationSetName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_set_name: Option<String>,
#[serde(rename = "Content")]
pub content: EmailContent,
#[serde(rename = "Destination")]
pub destination: Destination,
#[serde(rename = "EmailTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_tags: Option<Vec<MessageTag>>,
#[serde(rename = "FeedbackForwardingEmailAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub feedback_forwarding_email_address: Option<String>,
#[serde(rename = "FromEmailAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_email_address: Option<String>,
#[serde(rename = "ReplyToAddresses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reply_to_addresses: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SendEmailResponse {
#[serde(rename = "MessageId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SendQuota {
#[serde(rename = "Max24HourSend")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_24_hour_send: Option<f64>,
#[serde(rename = "MaxSendRate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_send_rate: Option<f64>,
#[serde(rename = "SentLast24Hours")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sent_last_24_hours: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SendingOptions {
#[serde(rename = "SendingEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sending_enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SnsDestination {
#[serde(rename = "TopicArn")]
pub topic_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SuppressedDestination {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<SuppressedDestinationAttributes>,
#[serde(rename = "EmailAddress")]
pub email_address: String,
#[serde(rename = "LastUpdateTime")]
pub last_update_time: f64,
#[serde(rename = "Reason")]
pub reason: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SuppressedDestinationAttributes {
#[serde(rename = "FeedbackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub feedback_id: Option<String>,
#[serde(rename = "MessageId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SuppressedDestinationSummary {
#[serde(rename = "EmailAddress")]
pub email_address: String,
#[serde(rename = "LastUpdateTime")]
pub last_update_time: f64,
#[serde(rename = "Reason")]
pub reason: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SuppressionAttributes {
#[serde(rename = "SuppressedReasons")]
#[serde(skip_serializing_if = "Option::is_none")]
pub suppressed_reasons: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SuppressionOptions {
#[serde(rename = "SuppressedReasons")]
#[serde(skip_serializing_if = "Option::is_none")]
pub suppressed_reasons: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Tag {
#[serde(rename = "Key")]
pub key: String,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Template {
#[serde(rename = "TemplateArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_arn: Option<String>,
#[serde(rename = "TemplateData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_data: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TrackingOptions {
#[serde(rename = "CustomRedirectDomain")]
pub custom_redirect_domain: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateConfigurationSetEventDestinationRequest {
#[serde(rename = "ConfigurationSetName")]
pub configuration_set_name: String,
#[serde(rename = "EventDestination")]
pub event_destination: EventDestinationDefinition,
#[serde(rename = "EventDestinationName")]
pub event_destination_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateConfigurationSetEventDestinationResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VolumeStatistics {
#[serde(rename = "InboxRawCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub inbox_raw_count: Option<i64>,
#[serde(rename = "ProjectedInbox")]
#[serde(skip_serializing_if = "Option::is_none")]
pub projected_inbox: Option<i64>,
#[serde(rename = "ProjectedSpam")]
#[serde(skip_serializing_if = "Option::is_none")]
pub projected_spam: Option<i64>,
#[serde(rename = "SpamRawCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub spam_raw_count: Option<i64>,
}
#[derive(Debug, PartialEq)]
pub enum CreateConfigurationSetError {
AlreadyExists(String),
BadRequest(String),
ConcurrentModification(String),
LimitExceeded(String),
NotFound(String),
TooManyRequests(String),
}
impl CreateConfigurationSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateConfigurationSetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AlreadyExistsException" => {
return RusotoError::Service(CreateConfigurationSetError::AlreadyExists(
err.msg,
))
}
"BadRequestException" => {
return RusotoError::Service(CreateConfigurationSetError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(
CreateConfigurationSetError::ConcurrentModification(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(CreateConfigurationSetError::LimitExceeded(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(CreateConfigurationSetError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateConfigurationSetError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateConfigurationSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateConfigurationSetError::AlreadyExists(ref cause) => write!(f, "{}", cause),
CreateConfigurationSetError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateConfigurationSetError::ConcurrentModification(ref cause) => {
write!(f, "{}", cause)
}
CreateConfigurationSetError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateConfigurationSetError::NotFound(ref cause) => write!(f, "{}", cause),
CreateConfigurationSetError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateConfigurationSetError {}
#[derive(Debug, PartialEq)]
pub enum CreateConfigurationSetEventDestinationError {
AlreadyExists(String),
BadRequest(String),
LimitExceeded(String),
NotFound(String),
TooManyRequests(String),
}
impl CreateConfigurationSetEventDestinationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateConfigurationSetEventDestinationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AlreadyExistsException" => {
return RusotoError::Service(
CreateConfigurationSetEventDestinationError::AlreadyExists(err.msg),
)
}
"BadRequestException" => {
return RusotoError::Service(
CreateConfigurationSetEventDestinationError::BadRequest(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(
CreateConfigurationSetEventDestinationError::LimitExceeded(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(
CreateConfigurationSetEventDestinationError::NotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
CreateConfigurationSetEventDestinationError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateConfigurationSetEventDestinationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateConfigurationSetEventDestinationError::AlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
CreateConfigurationSetEventDestinationError::BadRequest(ref cause) => {
write!(f, "{}", cause)
}
CreateConfigurationSetEventDestinationError::LimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateConfigurationSetEventDestinationError::NotFound(ref cause) => {
write!(f, "{}", cause)
}
CreateConfigurationSetEventDestinationError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateConfigurationSetEventDestinationError {}
#[derive(Debug, PartialEq)]
pub enum CreateDedicatedIpPoolError {
AlreadyExists(String),
BadRequest(String),
ConcurrentModification(String),
LimitExceeded(String),
TooManyRequests(String),
}
impl CreateDedicatedIpPoolError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDedicatedIpPoolError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AlreadyExistsException" => {
return RusotoError::Service(CreateDedicatedIpPoolError::AlreadyExists(err.msg))
}
"BadRequestException" => {
return RusotoError::Service(CreateDedicatedIpPoolError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(
CreateDedicatedIpPoolError::ConcurrentModification(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(CreateDedicatedIpPoolError::LimitExceeded(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateDedicatedIpPoolError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDedicatedIpPoolError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDedicatedIpPoolError::AlreadyExists(ref cause) => write!(f, "{}", cause),
CreateDedicatedIpPoolError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateDedicatedIpPoolError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
CreateDedicatedIpPoolError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateDedicatedIpPoolError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDedicatedIpPoolError {}
#[derive(Debug, PartialEq)]
pub enum CreateDeliverabilityTestReportError {
AccountSuspended(String),
BadRequest(String),
ConcurrentModification(String),
LimitExceeded(String),
MailFromDomainNotVerified(String),
MessageRejected(String),
NotFound(String),
SendingPaused(String),
TooManyRequests(String),
}
impl CreateDeliverabilityTestReportError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateDeliverabilityTestReportError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccountSuspendedException" => {
return RusotoError::Service(
CreateDeliverabilityTestReportError::AccountSuspended(err.msg),
)
}
"BadRequestException" => {
return RusotoError::Service(CreateDeliverabilityTestReportError::BadRequest(
err.msg,
))
}
"ConcurrentModificationException" => {
return RusotoError::Service(
CreateDeliverabilityTestReportError::ConcurrentModification(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(
CreateDeliverabilityTestReportError::LimitExceeded(err.msg),
)
}
"MailFromDomainNotVerifiedException" => {
return RusotoError::Service(
CreateDeliverabilityTestReportError::MailFromDomainNotVerified(err.msg),
)
}
"MessageRejected" => {
return RusotoError::Service(
CreateDeliverabilityTestReportError::MessageRejected(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(CreateDeliverabilityTestReportError::NotFound(
err.msg,
))
}
"SendingPausedException" => {
return RusotoError::Service(
CreateDeliverabilityTestReportError::SendingPaused(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
CreateDeliverabilityTestReportError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDeliverabilityTestReportError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDeliverabilityTestReportError::AccountSuspended(ref cause) => {
write!(f, "{}", cause)
}
CreateDeliverabilityTestReportError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateDeliverabilityTestReportError::ConcurrentModification(ref cause) => {
write!(f, "{}", cause)
}
CreateDeliverabilityTestReportError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateDeliverabilityTestReportError::MailFromDomainNotVerified(ref cause) => {
write!(f, "{}", cause)
}
CreateDeliverabilityTestReportError::MessageRejected(ref cause) => {
write!(f, "{}", cause)
}
CreateDeliverabilityTestReportError::NotFound(ref cause) => write!(f, "{}", cause),
CreateDeliverabilityTestReportError::SendingPaused(ref cause) => write!(f, "{}", cause),
CreateDeliverabilityTestReportError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateDeliverabilityTestReportError {}
#[derive(Debug, PartialEq)]
pub enum CreateEmailIdentityError {
AlreadyExists(String),
BadRequest(String),
ConcurrentModification(String),
LimitExceeded(String),
TooManyRequests(String),
}
impl CreateEmailIdentityError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateEmailIdentityError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AlreadyExistsException" => {
return RusotoError::Service(CreateEmailIdentityError::AlreadyExists(err.msg))
}
"BadRequestException" => {
return RusotoError::Service(CreateEmailIdentityError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(CreateEmailIdentityError::ConcurrentModification(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateEmailIdentityError::LimitExceeded(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateEmailIdentityError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateEmailIdentityError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateEmailIdentityError::AlreadyExists(ref cause) => write!(f, "{}", cause),
CreateEmailIdentityError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateEmailIdentityError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
CreateEmailIdentityError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateEmailIdentityError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateEmailIdentityError {}
#[derive(Debug, PartialEq)]
pub enum DeleteConfigurationSetError {
BadRequest(String),
ConcurrentModification(String),
NotFound(String),
TooManyRequests(String),
}
impl DeleteConfigurationSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteConfigurationSetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteConfigurationSetError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(
DeleteConfigurationSetError::ConcurrentModification(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(DeleteConfigurationSetError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteConfigurationSetError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteConfigurationSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteConfigurationSetError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteConfigurationSetError::ConcurrentModification(ref cause) => {
write!(f, "{}", cause)
}
DeleteConfigurationSetError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteConfigurationSetError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteConfigurationSetError {}
#[derive(Debug, PartialEq)]
pub enum DeleteConfigurationSetEventDestinationError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl DeleteConfigurationSetEventDestinationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteConfigurationSetEventDestinationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(
DeleteConfigurationSetEventDestinationError::BadRequest(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(
DeleteConfigurationSetEventDestinationError::NotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
DeleteConfigurationSetEventDestinationError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteConfigurationSetEventDestinationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteConfigurationSetEventDestinationError::BadRequest(ref cause) => {
write!(f, "{}", cause)
}
DeleteConfigurationSetEventDestinationError::NotFound(ref cause) => {
write!(f, "{}", cause)
}
DeleteConfigurationSetEventDestinationError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteConfigurationSetEventDestinationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDedicatedIpPoolError {
BadRequest(String),
ConcurrentModification(String),
NotFound(String),
TooManyRequests(String),
}
impl DeleteDedicatedIpPoolError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDedicatedIpPoolError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteDedicatedIpPoolError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(
DeleteDedicatedIpPoolError::ConcurrentModification(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(DeleteDedicatedIpPoolError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteDedicatedIpPoolError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDedicatedIpPoolError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDedicatedIpPoolError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteDedicatedIpPoolError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
DeleteDedicatedIpPoolError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteDedicatedIpPoolError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDedicatedIpPoolError {}
#[derive(Debug, PartialEq)]
pub enum DeleteEmailIdentityError {
BadRequest(String),
ConcurrentModification(String),
NotFound(String),
TooManyRequests(String),
}
impl DeleteEmailIdentityError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteEmailIdentityError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteEmailIdentityError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(DeleteEmailIdentityError::ConcurrentModification(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(DeleteEmailIdentityError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteEmailIdentityError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteEmailIdentityError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteEmailIdentityError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteEmailIdentityError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
DeleteEmailIdentityError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteEmailIdentityError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteEmailIdentityError {}
#[derive(Debug, PartialEq)]
pub enum DeleteSuppressedDestinationError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl DeleteSuppressedDestinationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteSuppressedDestinationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteSuppressedDestinationError::BadRequest(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(DeleteSuppressedDestinationError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteSuppressedDestinationError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteSuppressedDestinationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteSuppressedDestinationError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteSuppressedDestinationError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteSuppressedDestinationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteSuppressedDestinationError {}
#[derive(Debug, PartialEq)]
pub enum GetAccountError {
BadRequest(String),
TooManyRequests(String),
}
impl GetAccountError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAccountError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetAccountError::BadRequest(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetAccountError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAccountError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAccountError::BadRequest(ref cause) => write!(f, "{}", cause),
GetAccountError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetAccountError {}
#[derive(Debug, PartialEq)]
pub enum GetBlacklistReportsError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetBlacklistReportsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetBlacklistReportsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetBlacklistReportsError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetBlacklistReportsError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetBlacklistReportsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetBlacklistReportsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetBlacklistReportsError::BadRequest(ref cause) => write!(f, "{}", cause),
GetBlacklistReportsError::NotFound(ref cause) => write!(f, "{}", cause),
GetBlacklistReportsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetBlacklistReportsError {}
#[derive(Debug, PartialEq)]
pub enum GetConfigurationSetError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetConfigurationSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetConfigurationSetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetConfigurationSetError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetConfigurationSetError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetConfigurationSetError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetConfigurationSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetConfigurationSetError::BadRequest(ref cause) => write!(f, "{}", cause),
GetConfigurationSetError::NotFound(ref cause) => write!(f, "{}", cause),
GetConfigurationSetError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetConfigurationSetError {}
#[derive(Debug, PartialEq)]
pub enum GetConfigurationSetEventDestinationsError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetConfigurationSetEventDestinationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetConfigurationSetEventDestinationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(
GetConfigurationSetEventDestinationsError::BadRequest(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(
GetConfigurationSetEventDestinationsError::NotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
GetConfigurationSetEventDestinationsError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetConfigurationSetEventDestinationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetConfigurationSetEventDestinationsError::BadRequest(ref cause) => {
write!(f, "{}", cause)
}
GetConfigurationSetEventDestinationsError::NotFound(ref cause) => {
write!(f, "{}", cause)
}
GetConfigurationSetEventDestinationsError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetConfigurationSetEventDestinationsError {}
#[derive(Debug, PartialEq)]
pub enum GetDedicatedIpError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetDedicatedIpError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDedicatedIpError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetDedicatedIpError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetDedicatedIpError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetDedicatedIpError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDedicatedIpError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDedicatedIpError::BadRequest(ref cause) => write!(f, "{}", cause),
GetDedicatedIpError::NotFound(ref cause) => write!(f, "{}", cause),
GetDedicatedIpError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDedicatedIpError {}
#[derive(Debug, PartialEq)]
pub enum GetDedicatedIpsError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetDedicatedIpsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDedicatedIpsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetDedicatedIpsError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetDedicatedIpsError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetDedicatedIpsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDedicatedIpsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDedicatedIpsError::BadRequest(ref cause) => write!(f, "{}", cause),
GetDedicatedIpsError::NotFound(ref cause) => write!(f, "{}", cause),
GetDedicatedIpsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDedicatedIpsError {}
#[derive(Debug, PartialEq)]
pub enum GetDeliverabilityDashboardOptionsError {
BadRequest(String),
LimitExceeded(String),
TooManyRequests(String),
}
impl GetDeliverabilityDashboardOptionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetDeliverabilityDashboardOptionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(
GetDeliverabilityDashboardOptionsError::BadRequest(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(
GetDeliverabilityDashboardOptionsError::LimitExceeded(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
GetDeliverabilityDashboardOptionsError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDeliverabilityDashboardOptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDeliverabilityDashboardOptionsError::BadRequest(ref cause) => write!(f, "{}", cause),
GetDeliverabilityDashboardOptionsError::LimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
GetDeliverabilityDashboardOptionsError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetDeliverabilityDashboardOptionsError {}
#[derive(Debug, PartialEq)]
pub enum GetDeliverabilityTestReportError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetDeliverabilityTestReportError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetDeliverabilityTestReportError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetDeliverabilityTestReportError::BadRequest(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetDeliverabilityTestReportError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetDeliverabilityTestReportError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDeliverabilityTestReportError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDeliverabilityTestReportError::BadRequest(ref cause) => write!(f, "{}", cause),
GetDeliverabilityTestReportError::NotFound(ref cause) => write!(f, "{}", cause),
GetDeliverabilityTestReportError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDeliverabilityTestReportError {}
#[derive(Debug, PartialEq)]
pub enum GetDomainDeliverabilityCampaignError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetDomainDeliverabilityCampaignError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetDomainDeliverabilityCampaignError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetDomainDeliverabilityCampaignError::BadRequest(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetDomainDeliverabilityCampaignError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
GetDomainDeliverabilityCampaignError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDomainDeliverabilityCampaignError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDomainDeliverabilityCampaignError::BadRequest(ref cause) => write!(f, "{}", cause),
GetDomainDeliverabilityCampaignError::NotFound(ref cause) => write!(f, "{}", cause),
GetDomainDeliverabilityCampaignError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetDomainDeliverabilityCampaignError {}
#[derive(Debug, PartialEq)]
pub enum GetDomainStatisticsReportError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetDomainStatisticsReportError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDomainStatisticsReportError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetDomainStatisticsReportError::BadRequest(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetDomainStatisticsReportError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetDomainStatisticsReportError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDomainStatisticsReportError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDomainStatisticsReportError::BadRequest(ref cause) => write!(f, "{}", cause),
GetDomainStatisticsReportError::NotFound(ref cause) => write!(f, "{}", cause),
GetDomainStatisticsReportError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDomainStatisticsReportError {}
#[derive(Debug, PartialEq)]
pub enum GetEmailIdentityError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetEmailIdentityError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetEmailIdentityError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetEmailIdentityError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetEmailIdentityError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetEmailIdentityError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetEmailIdentityError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetEmailIdentityError::BadRequest(ref cause) => write!(f, "{}", cause),
GetEmailIdentityError::NotFound(ref cause) => write!(f, "{}", cause),
GetEmailIdentityError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetEmailIdentityError {}
#[derive(Debug, PartialEq)]
pub enum GetSuppressedDestinationError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetSuppressedDestinationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetSuppressedDestinationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetSuppressedDestinationError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetSuppressedDestinationError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetSuppressedDestinationError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetSuppressedDestinationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetSuppressedDestinationError::BadRequest(ref cause) => write!(f, "{}", cause),
GetSuppressedDestinationError::NotFound(ref cause) => write!(f, "{}", cause),
GetSuppressedDestinationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetSuppressedDestinationError {}
#[derive(Debug, PartialEq)]
pub enum ListConfigurationSetsError {
BadRequest(String),
TooManyRequests(String),
}
impl ListConfigurationSetsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListConfigurationSetsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListConfigurationSetsError::BadRequest(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListConfigurationSetsError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListConfigurationSetsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListConfigurationSetsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListConfigurationSetsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListConfigurationSetsError {}
#[derive(Debug, PartialEq)]
pub enum ListDedicatedIpPoolsError {
BadRequest(String),
TooManyRequests(String),
}
impl ListDedicatedIpPoolsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDedicatedIpPoolsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListDedicatedIpPoolsError::BadRequest(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListDedicatedIpPoolsError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDedicatedIpPoolsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDedicatedIpPoolsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListDedicatedIpPoolsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDedicatedIpPoolsError {}
#[derive(Debug, PartialEq)]
pub enum ListDeliverabilityTestReportsError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl ListDeliverabilityTestReportsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListDeliverabilityTestReportsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListDeliverabilityTestReportsError::BadRequest(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(ListDeliverabilityTestReportsError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
ListDeliverabilityTestReportsError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDeliverabilityTestReportsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDeliverabilityTestReportsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListDeliverabilityTestReportsError::NotFound(ref cause) => write!(f, "{}", cause),
ListDeliverabilityTestReportsError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListDeliverabilityTestReportsError {}
#[derive(Debug, PartialEq)]
pub enum ListDomainDeliverabilityCampaignsError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl ListDomainDeliverabilityCampaignsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListDomainDeliverabilityCampaignsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(
ListDomainDeliverabilityCampaignsError::BadRequest(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(ListDomainDeliverabilityCampaignsError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
ListDomainDeliverabilityCampaignsError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDomainDeliverabilityCampaignsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDomainDeliverabilityCampaignsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListDomainDeliverabilityCampaignsError::NotFound(ref cause) => write!(f, "{}", cause),
ListDomainDeliverabilityCampaignsError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListDomainDeliverabilityCampaignsError {}
#[derive(Debug, PartialEq)]
pub enum ListEmailIdentitiesError {
BadRequest(String),
TooManyRequests(String),
}
impl ListEmailIdentitiesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListEmailIdentitiesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListEmailIdentitiesError::BadRequest(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListEmailIdentitiesError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListEmailIdentitiesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListEmailIdentitiesError::BadRequest(ref cause) => write!(f, "{}", cause),
ListEmailIdentitiesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListEmailIdentitiesError {}
#[derive(Debug, PartialEq)]
pub enum ListSuppressedDestinationsError {
BadRequest(String),
InvalidNextToken(String),
TooManyRequests(String),
}
impl ListSuppressedDestinationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListSuppressedDestinationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListSuppressedDestinationsError::BadRequest(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListSuppressedDestinationsError::InvalidNextToken(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListSuppressedDestinationsError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListSuppressedDestinationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListSuppressedDestinationsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListSuppressedDestinationsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListSuppressedDestinationsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListSuppressedDestinationsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListTagsForResourceError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListTagsForResourceError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::NotFound(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum PutAccountDedicatedIpWarmupAttributesError {
BadRequest(String),
TooManyRequests(String),
}
impl PutAccountDedicatedIpWarmupAttributesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutAccountDedicatedIpWarmupAttributesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(
PutAccountDedicatedIpWarmupAttributesError::BadRequest(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
PutAccountDedicatedIpWarmupAttributesError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutAccountDedicatedIpWarmupAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutAccountDedicatedIpWarmupAttributesError::BadRequest(ref cause) => {
write!(f, "{}", cause)
}
PutAccountDedicatedIpWarmupAttributesError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutAccountDedicatedIpWarmupAttributesError {}
#[derive(Debug, PartialEq)]
pub enum PutAccountSendingAttributesError {
BadRequest(String),
TooManyRequests(String),
}
impl PutAccountSendingAttributesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutAccountSendingAttributesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(PutAccountSendingAttributesError::BadRequest(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(PutAccountSendingAttributesError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutAccountSendingAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutAccountSendingAttributesError::BadRequest(ref cause) => write!(f, "{}", cause),
PutAccountSendingAttributesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutAccountSendingAttributesError {}
#[derive(Debug, PartialEq)]
pub enum PutAccountSuppressionAttributesError {
BadRequest(String),
TooManyRequests(String),
}
impl PutAccountSuppressionAttributesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutAccountSuppressionAttributesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(PutAccountSuppressionAttributesError::BadRequest(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
PutAccountSuppressionAttributesError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutAccountSuppressionAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutAccountSuppressionAttributesError::BadRequest(ref cause) => write!(f, "{}", cause),
PutAccountSuppressionAttributesError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutAccountSuppressionAttributesError {}
#[derive(Debug, PartialEq)]
pub enum PutConfigurationSetDeliveryOptionsError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl PutConfigurationSetDeliveryOptionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutConfigurationSetDeliveryOptionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(
PutConfigurationSetDeliveryOptionsError::BadRequest(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(PutConfigurationSetDeliveryOptionsError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
PutConfigurationSetDeliveryOptionsError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutConfigurationSetDeliveryOptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutConfigurationSetDeliveryOptionsError::BadRequest(ref cause) => {
write!(f, "{}", cause)
}
PutConfigurationSetDeliveryOptionsError::NotFound(ref cause) => write!(f, "{}", cause),
PutConfigurationSetDeliveryOptionsError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutConfigurationSetDeliveryOptionsError {}
#[derive(Debug, PartialEq)]
pub enum PutConfigurationSetReputationOptionsError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl PutConfigurationSetReputationOptionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutConfigurationSetReputationOptionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(
PutConfigurationSetReputationOptionsError::BadRequest(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(
PutConfigurationSetReputationOptionsError::NotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
PutConfigurationSetReputationOptionsError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutConfigurationSetReputationOptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutConfigurationSetReputationOptionsError::BadRequest(ref cause) => {
write!(f, "{}", cause)
}
PutConfigurationSetReputationOptionsError::NotFound(ref cause) => {
write!(f, "{}", cause)
}
PutConfigurationSetReputationOptionsError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutConfigurationSetReputationOptionsError {}
#[derive(Debug, PartialEq)]
pub enum PutConfigurationSetSendingOptionsError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl PutConfigurationSetSendingOptionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutConfigurationSetSendingOptionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(
PutConfigurationSetSendingOptionsError::BadRequest(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(PutConfigurationSetSendingOptionsError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
PutConfigurationSetSendingOptionsError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutConfigurationSetSendingOptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutConfigurationSetSendingOptionsError::BadRequest(ref cause) => write!(f, "{}", cause),
PutConfigurationSetSendingOptionsError::NotFound(ref cause) => write!(f, "{}", cause),
PutConfigurationSetSendingOptionsError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutConfigurationSetSendingOptionsError {}
#[derive(Debug, PartialEq)]
pub enum PutConfigurationSetSuppressionOptionsError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl PutConfigurationSetSuppressionOptionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutConfigurationSetSuppressionOptionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(
PutConfigurationSetSuppressionOptionsError::BadRequest(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(
PutConfigurationSetSuppressionOptionsError::NotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
PutConfigurationSetSuppressionOptionsError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutConfigurationSetSuppressionOptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutConfigurationSetSuppressionOptionsError::BadRequest(ref cause) => {
write!(f, "{}", cause)
}
PutConfigurationSetSuppressionOptionsError::NotFound(ref cause) => {
write!(f, "{}", cause)
}
PutConfigurationSetSuppressionOptionsError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutConfigurationSetSuppressionOptionsError {}
#[derive(Debug, PartialEq)]
pub enum PutConfigurationSetTrackingOptionsError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl PutConfigurationSetTrackingOptionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutConfigurationSetTrackingOptionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(
PutConfigurationSetTrackingOptionsError::BadRequest(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(PutConfigurationSetTrackingOptionsError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
PutConfigurationSetTrackingOptionsError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutConfigurationSetTrackingOptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutConfigurationSetTrackingOptionsError::BadRequest(ref cause) => {
write!(f, "{}", cause)
}
PutConfigurationSetTrackingOptionsError::NotFound(ref cause) => write!(f, "{}", cause),
PutConfigurationSetTrackingOptionsError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutConfigurationSetTrackingOptionsError {}
#[derive(Debug, PartialEq)]
pub enum PutDedicatedIpInPoolError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl PutDedicatedIpInPoolError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutDedicatedIpInPoolError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(PutDedicatedIpInPoolError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(PutDedicatedIpInPoolError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(PutDedicatedIpInPoolError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutDedicatedIpInPoolError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutDedicatedIpInPoolError::BadRequest(ref cause) => write!(f, "{}", cause),
PutDedicatedIpInPoolError::NotFound(ref cause) => write!(f, "{}", cause),
PutDedicatedIpInPoolError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutDedicatedIpInPoolError {}
#[derive(Debug, PartialEq)]
pub enum PutDedicatedIpWarmupAttributesError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl PutDedicatedIpWarmupAttributesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutDedicatedIpWarmupAttributesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(PutDedicatedIpWarmupAttributesError::BadRequest(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(PutDedicatedIpWarmupAttributesError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
PutDedicatedIpWarmupAttributesError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutDedicatedIpWarmupAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutDedicatedIpWarmupAttributesError::BadRequest(ref cause) => write!(f, "{}", cause),
PutDedicatedIpWarmupAttributesError::NotFound(ref cause) => write!(f, "{}", cause),
PutDedicatedIpWarmupAttributesError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutDedicatedIpWarmupAttributesError {}
#[derive(Debug, PartialEq)]
pub enum PutDeliverabilityDashboardOptionError {
AlreadyExists(String),
BadRequest(String),
LimitExceeded(String),
NotFound(String),
TooManyRequests(String),
}
impl PutDeliverabilityDashboardOptionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutDeliverabilityDashboardOptionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AlreadyExistsException" => {
return RusotoError::Service(
PutDeliverabilityDashboardOptionError::AlreadyExists(err.msg),
)
}
"BadRequestException" => {
return RusotoError::Service(PutDeliverabilityDashboardOptionError::BadRequest(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(
PutDeliverabilityDashboardOptionError::LimitExceeded(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(PutDeliverabilityDashboardOptionError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
PutDeliverabilityDashboardOptionError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutDeliverabilityDashboardOptionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutDeliverabilityDashboardOptionError::AlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
PutDeliverabilityDashboardOptionError::BadRequest(ref cause) => write!(f, "{}", cause),
PutDeliverabilityDashboardOptionError::LimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
PutDeliverabilityDashboardOptionError::NotFound(ref cause) => write!(f, "{}", cause),
PutDeliverabilityDashboardOptionError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutDeliverabilityDashboardOptionError {}
#[derive(Debug, PartialEq)]
pub enum PutEmailIdentityDkimAttributesError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl PutEmailIdentityDkimAttributesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutEmailIdentityDkimAttributesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(PutEmailIdentityDkimAttributesError::BadRequest(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(PutEmailIdentityDkimAttributesError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
PutEmailIdentityDkimAttributesError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutEmailIdentityDkimAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutEmailIdentityDkimAttributesError::BadRequest(ref cause) => write!(f, "{}", cause),
PutEmailIdentityDkimAttributesError::NotFound(ref cause) => write!(f, "{}", cause),
PutEmailIdentityDkimAttributesError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutEmailIdentityDkimAttributesError {}
#[derive(Debug, PartialEq)]
pub enum PutEmailIdentityDkimSigningAttributesError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl PutEmailIdentityDkimSigningAttributesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutEmailIdentityDkimSigningAttributesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(
PutEmailIdentityDkimSigningAttributesError::BadRequest(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(
PutEmailIdentityDkimSigningAttributesError::NotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
PutEmailIdentityDkimSigningAttributesError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutEmailIdentityDkimSigningAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutEmailIdentityDkimSigningAttributesError::BadRequest(ref cause) => {
write!(f, "{}", cause)
}
PutEmailIdentityDkimSigningAttributesError::NotFound(ref cause) => {
write!(f, "{}", cause)
}
PutEmailIdentityDkimSigningAttributesError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutEmailIdentityDkimSigningAttributesError {}
#[derive(Debug, PartialEq)]
pub enum PutEmailIdentityFeedbackAttributesError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl PutEmailIdentityFeedbackAttributesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutEmailIdentityFeedbackAttributesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(
PutEmailIdentityFeedbackAttributesError::BadRequest(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(PutEmailIdentityFeedbackAttributesError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
PutEmailIdentityFeedbackAttributesError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutEmailIdentityFeedbackAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutEmailIdentityFeedbackAttributesError::BadRequest(ref cause) => {
write!(f, "{}", cause)
}
PutEmailIdentityFeedbackAttributesError::NotFound(ref cause) => write!(f, "{}", cause),
PutEmailIdentityFeedbackAttributesError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutEmailIdentityFeedbackAttributesError {}
#[derive(Debug, PartialEq)]
pub enum PutEmailIdentityMailFromAttributesError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl PutEmailIdentityMailFromAttributesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutEmailIdentityMailFromAttributesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(
PutEmailIdentityMailFromAttributesError::BadRequest(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(PutEmailIdentityMailFromAttributesError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
PutEmailIdentityMailFromAttributesError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutEmailIdentityMailFromAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutEmailIdentityMailFromAttributesError::BadRequest(ref cause) => {
write!(f, "{}", cause)
}
PutEmailIdentityMailFromAttributesError::NotFound(ref cause) => write!(f, "{}", cause),
PutEmailIdentityMailFromAttributesError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutEmailIdentityMailFromAttributesError {}
#[derive(Debug, PartialEq)]
pub enum PutSuppressedDestinationError {
BadRequest(String),
TooManyRequests(String),
}
impl PutSuppressedDestinationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutSuppressedDestinationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(PutSuppressedDestinationError::BadRequest(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(PutSuppressedDestinationError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutSuppressedDestinationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutSuppressedDestinationError::BadRequest(ref cause) => write!(f, "{}", cause),
PutSuppressedDestinationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutSuppressedDestinationError {}
#[derive(Debug, PartialEq)]
pub enum SendEmailError {
AccountSuspended(String),
BadRequest(String),
LimitExceeded(String),
MailFromDomainNotVerified(String),
MessageRejected(String),
NotFound(String),
SendingPaused(String),
TooManyRequests(String),
}
impl SendEmailError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SendEmailError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccountSuspendedException" => {
return RusotoError::Service(SendEmailError::AccountSuspended(err.msg))
}
"BadRequestException" => {
return RusotoError::Service(SendEmailError::BadRequest(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(SendEmailError::LimitExceeded(err.msg))
}
"MailFromDomainNotVerifiedException" => {
return RusotoError::Service(SendEmailError::MailFromDomainNotVerified(err.msg))
}
"MessageRejected" => {
return RusotoError::Service(SendEmailError::MessageRejected(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(SendEmailError::NotFound(err.msg))
}
"SendingPausedException" => {
return RusotoError::Service(SendEmailError::SendingPaused(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(SendEmailError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SendEmailError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SendEmailError::AccountSuspended(ref cause) => write!(f, "{}", cause),
SendEmailError::BadRequest(ref cause) => write!(f, "{}", cause),
SendEmailError::LimitExceeded(ref cause) => write!(f, "{}", cause),
SendEmailError::MailFromDomainNotVerified(ref cause) => write!(f, "{}", cause),
SendEmailError::MessageRejected(ref cause) => write!(f, "{}", cause),
SendEmailError::NotFound(ref cause) => write!(f, "{}", cause),
SendEmailError::SendingPaused(ref cause) => write!(f, "{}", cause),
SendEmailError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SendEmailError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
BadRequest(String),
ConcurrentModification(String),
NotFound(String),
TooManyRequests(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(TagResourceError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(TagResourceError::ConcurrentModification(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(TagResourceError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(TagResourceError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
TagResourceError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
TagResourceError::NotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
BadRequest(String),
ConcurrentModification(String),
NotFound(String),
TooManyRequests(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UntagResourceError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(UntagResourceError::ConcurrentModification(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(UntagResourceError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UntagResourceError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
UntagResourceError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
UntagResourceError::NotFound(ref cause) => write!(f, "{}", cause),
UntagResourceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateConfigurationSetEventDestinationError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl UpdateConfigurationSetEventDestinationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateConfigurationSetEventDestinationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(
UpdateConfigurationSetEventDestinationError::BadRequest(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(
UpdateConfigurationSetEventDestinationError::NotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
UpdateConfigurationSetEventDestinationError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateConfigurationSetEventDestinationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateConfigurationSetEventDestinationError::BadRequest(ref cause) => {
write!(f, "{}", cause)
}
UpdateConfigurationSetEventDestinationError::NotFound(ref cause) => {
write!(f, "{}", cause)
}
UpdateConfigurationSetEventDestinationError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateConfigurationSetEventDestinationError {}
#[async_trait]
pub trait SesV2 {
async fn create_configuration_set(
&self,
input: CreateConfigurationSetRequest,
) -> Result<CreateConfigurationSetResponse, RusotoError<CreateConfigurationSetError>>;
async fn create_configuration_set_event_destination(
&self,
input: CreateConfigurationSetEventDestinationRequest,
) -> Result<
CreateConfigurationSetEventDestinationResponse,
RusotoError<CreateConfigurationSetEventDestinationError>,
>;
async fn create_dedicated_ip_pool(
&self,
input: CreateDedicatedIpPoolRequest,
) -> Result<CreateDedicatedIpPoolResponse, RusotoError<CreateDedicatedIpPoolError>>;
async fn create_deliverability_test_report(
&self,
input: CreateDeliverabilityTestReportRequest,
) -> Result<
CreateDeliverabilityTestReportResponse,
RusotoError<CreateDeliverabilityTestReportError>,
>;
async fn create_email_identity(
&self,
input: CreateEmailIdentityRequest,
) -> Result<CreateEmailIdentityResponse, RusotoError<CreateEmailIdentityError>>;
async fn delete_configuration_set(
&self,
input: DeleteConfigurationSetRequest,
) -> Result<DeleteConfigurationSetResponse, RusotoError<DeleteConfigurationSetError>>;
async fn delete_configuration_set_event_destination(
&self,
input: DeleteConfigurationSetEventDestinationRequest,
) -> Result<
DeleteConfigurationSetEventDestinationResponse,
RusotoError<DeleteConfigurationSetEventDestinationError>,
>;
async fn delete_dedicated_ip_pool(
&self,
input: DeleteDedicatedIpPoolRequest,
) -> Result<DeleteDedicatedIpPoolResponse, RusotoError<DeleteDedicatedIpPoolError>>;
async fn delete_email_identity(
&self,
input: DeleteEmailIdentityRequest,
) -> Result<DeleteEmailIdentityResponse, RusotoError<DeleteEmailIdentityError>>;
async fn delete_suppressed_destination(
&self,
input: DeleteSuppressedDestinationRequest,
) -> Result<DeleteSuppressedDestinationResponse, RusotoError<DeleteSuppressedDestinationError>>;
async fn get_account(&self) -> Result<GetAccountResponse, RusotoError<GetAccountError>>;
async fn get_blacklist_reports(
&self,
input: GetBlacklistReportsRequest,
) -> Result<GetBlacklistReportsResponse, RusotoError<GetBlacklistReportsError>>;
async fn get_configuration_set(
&self,
input: GetConfigurationSetRequest,
) -> Result<GetConfigurationSetResponse, RusotoError<GetConfigurationSetError>>;
async fn get_configuration_set_event_destinations(
&self,
input: GetConfigurationSetEventDestinationsRequest,
) -> Result<
GetConfigurationSetEventDestinationsResponse,
RusotoError<GetConfigurationSetEventDestinationsError>,
>;
async fn get_dedicated_ip(
&self,
input: GetDedicatedIpRequest,
) -> Result<GetDedicatedIpResponse, RusotoError<GetDedicatedIpError>>;
async fn get_dedicated_ips(
&self,
input: GetDedicatedIpsRequest,
) -> Result<GetDedicatedIpsResponse, RusotoError<GetDedicatedIpsError>>;
async fn get_deliverability_dashboard_options(
&self,
) -> Result<
GetDeliverabilityDashboardOptionsResponse,
RusotoError<GetDeliverabilityDashboardOptionsError>,
>;
async fn get_deliverability_test_report(
&self,
input: GetDeliverabilityTestReportRequest,
) -> Result<GetDeliverabilityTestReportResponse, RusotoError<GetDeliverabilityTestReportError>>;
async fn get_domain_deliverability_campaign(
&self,
input: GetDomainDeliverabilityCampaignRequest,
) -> Result<
GetDomainDeliverabilityCampaignResponse,
RusotoError<GetDomainDeliverabilityCampaignError>,
>;
async fn get_domain_statistics_report(
&self,
input: GetDomainStatisticsReportRequest,
) -> Result<GetDomainStatisticsReportResponse, RusotoError<GetDomainStatisticsReportError>>;
async fn get_email_identity(
&self,
input: GetEmailIdentityRequest,
) -> Result<GetEmailIdentityResponse, RusotoError<GetEmailIdentityError>>;
async fn get_suppressed_destination(
&self,
input: GetSuppressedDestinationRequest,
) -> Result<GetSuppressedDestinationResponse, RusotoError<GetSuppressedDestinationError>>;
async fn list_configuration_sets(
&self,
input: ListConfigurationSetsRequest,
) -> Result<ListConfigurationSetsResponse, RusotoError<ListConfigurationSetsError>>;
async fn list_dedicated_ip_pools(
&self,
input: ListDedicatedIpPoolsRequest,
) -> Result<ListDedicatedIpPoolsResponse, RusotoError<ListDedicatedIpPoolsError>>;
async fn list_deliverability_test_reports(
&self,
input: ListDeliverabilityTestReportsRequest,
) -> Result<
ListDeliverabilityTestReportsResponse,
RusotoError<ListDeliverabilityTestReportsError>,
>;
async fn list_domain_deliverability_campaigns(
&self,
input: ListDomainDeliverabilityCampaignsRequest,
) -> Result<
ListDomainDeliverabilityCampaignsResponse,
RusotoError<ListDomainDeliverabilityCampaignsError>,
>;
async fn list_email_identities(
&self,
input: ListEmailIdentitiesRequest,
) -> Result<ListEmailIdentitiesResponse, RusotoError<ListEmailIdentitiesError>>;
async fn list_suppressed_destinations(
&self,
input: ListSuppressedDestinationsRequest,
) -> Result<ListSuppressedDestinationsResponse, RusotoError<ListSuppressedDestinationsError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn put_account_dedicated_ip_warmup_attributes(
&self,
input: PutAccountDedicatedIpWarmupAttributesRequest,
) -> Result<
PutAccountDedicatedIpWarmupAttributesResponse,
RusotoError<PutAccountDedicatedIpWarmupAttributesError>,
>;
async fn put_account_sending_attributes(
&self,
input: PutAccountSendingAttributesRequest,
) -> Result<PutAccountSendingAttributesResponse, RusotoError<PutAccountSendingAttributesError>>;
async fn put_account_suppression_attributes(
&self,
input: PutAccountSuppressionAttributesRequest,
) -> Result<
PutAccountSuppressionAttributesResponse,
RusotoError<PutAccountSuppressionAttributesError>,
>;
async fn put_configuration_set_delivery_options(
&self,
input: PutConfigurationSetDeliveryOptionsRequest,
) -> Result<
PutConfigurationSetDeliveryOptionsResponse,
RusotoError<PutConfigurationSetDeliveryOptionsError>,
>;
async fn put_configuration_set_reputation_options(
&self,
input: PutConfigurationSetReputationOptionsRequest,
) -> Result<
PutConfigurationSetReputationOptionsResponse,
RusotoError<PutConfigurationSetReputationOptionsError>,
>;
async fn put_configuration_set_sending_options(
&self,
input: PutConfigurationSetSendingOptionsRequest,
) -> Result<
PutConfigurationSetSendingOptionsResponse,
RusotoError<PutConfigurationSetSendingOptionsError>,
>;
async fn put_configuration_set_suppression_options(
&self,
input: PutConfigurationSetSuppressionOptionsRequest,
) -> Result<
PutConfigurationSetSuppressionOptionsResponse,
RusotoError<PutConfigurationSetSuppressionOptionsError>,
>;
async fn put_configuration_set_tracking_options(
&self,
input: PutConfigurationSetTrackingOptionsRequest,
) -> Result<
PutConfigurationSetTrackingOptionsResponse,
RusotoError<PutConfigurationSetTrackingOptionsError>,
>;
async fn put_dedicated_ip_in_pool(
&self,
input: PutDedicatedIpInPoolRequest,
) -> Result<PutDedicatedIpInPoolResponse, RusotoError<PutDedicatedIpInPoolError>>;
async fn put_dedicated_ip_warmup_attributes(
&self,
input: PutDedicatedIpWarmupAttributesRequest,
) -> Result<
PutDedicatedIpWarmupAttributesResponse,
RusotoError<PutDedicatedIpWarmupAttributesError>,
>;
async fn put_deliverability_dashboard_option(
&self,
input: PutDeliverabilityDashboardOptionRequest,
) -> Result<
PutDeliverabilityDashboardOptionResponse,
RusotoError<PutDeliverabilityDashboardOptionError>,
>;
async fn put_email_identity_dkim_attributes(
&self,
input: PutEmailIdentityDkimAttributesRequest,
) -> Result<
PutEmailIdentityDkimAttributesResponse,
RusotoError<PutEmailIdentityDkimAttributesError>,
>;
async fn put_email_identity_dkim_signing_attributes(
&self,
input: PutEmailIdentityDkimSigningAttributesRequest,
) -> Result<
PutEmailIdentityDkimSigningAttributesResponse,
RusotoError<PutEmailIdentityDkimSigningAttributesError>,
>;
async fn put_email_identity_feedback_attributes(
&self,
input: PutEmailIdentityFeedbackAttributesRequest,
) -> Result<
PutEmailIdentityFeedbackAttributesResponse,
RusotoError<PutEmailIdentityFeedbackAttributesError>,
>;
async fn put_email_identity_mail_from_attributes(
&self,
input: PutEmailIdentityMailFromAttributesRequest,
) -> Result<
PutEmailIdentityMailFromAttributesResponse,
RusotoError<PutEmailIdentityMailFromAttributesError>,
>;
async fn put_suppressed_destination(
&self,
input: PutSuppressedDestinationRequest,
) -> Result<PutSuppressedDestinationResponse, RusotoError<PutSuppressedDestinationError>>;
async fn send_email(
&self,
input: SendEmailRequest,
) -> Result<SendEmailResponse, RusotoError<SendEmailError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
async fn update_configuration_set_event_destination(
&self,
input: UpdateConfigurationSetEventDestinationRequest,
) -> Result<
UpdateConfigurationSetEventDestinationResponse,
RusotoError<UpdateConfigurationSetEventDestinationError>,
>;
}
#[derive(Clone)]
pub struct SesV2Client {
client: Client,
region: region::Region,
}
impl SesV2Client {
pub fn new(region: region::Region) -> SesV2Client {
SesV2Client {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> SesV2Client
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
SesV2Client {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> SesV2Client {
SesV2Client { client, region }
}
}
#[async_trait]
impl SesV2 for SesV2Client {
#[allow(unused_mut)]
async fn create_configuration_set(
&self,
input: CreateConfigurationSetRequest,
) -> Result<CreateConfigurationSetResponse, RusotoError<CreateConfigurationSetError>> {
let request_uri = "/v2/email/configuration-sets";
let mut request = SignedRequest::new("POST", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateConfigurationSetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateConfigurationSetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_configuration_set_event_destination(
&self,
input: CreateConfigurationSetEventDestinationRequest,
) -> Result<
CreateConfigurationSetEventDestinationResponse,
RusotoError<CreateConfigurationSetEventDestinationError>,
> {
let request_uri = format!(
"/v2/email/configuration-sets/{configuration_set_name}/event-destinations",
configuration_set_name = input.configuration_set_name
);
let mut request = SignedRequest::new("POST", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateConfigurationSetEventDestinationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateConfigurationSetEventDestinationError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn create_dedicated_ip_pool(
&self,
input: CreateDedicatedIpPoolRequest,
) -> Result<CreateDedicatedIpPoolResponse, RusotoError<CreateDedicatedIpPoolError>> {
let request_uri = "/v2/email/dedicated-ip-pools";
let mut request = SignedRequest::new("POST", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDedicatedIpPoolResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateDedicatedIpPoolError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_deliverability_test_report(
&self,
input: CreateDeliverabilityTestReportRequest,
) -> Result<
CreateDeliverabilityTestReportResponse,
RusotoError<CreateDeliverabilityTestReportError>,
> {
let request_uri = "/v2/email/deliverability-dashboard/test";
let mut request = SignedRequest::new("POST", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDeliverabilityTestReportResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateDeliverabilityTestReportError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_email_identity(
&self,
input: CreateEmailIdentityRequest,
) -> Result<CreateEmailIdentityResponse, RusotoError<CreateEmailIdentityError>> {
let request_uri = "/v2/email/identities";
let mut request = SignedRequest::new("POST", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateEmailIdentityResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateEmailIdentityError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_configuration_set(
&self,
input: DeleteConfigurationSetRequest,
) -> Result<DeleteConfigurationSetResponse, RusotoError<DeleteConfigurationSetError>> {
let request_uri = format!(
"/v2/email/configuration-sets/{configuration_set_name}",
configuration_set_name = input.configuration_set_name
);
let mut request = SignedRequest::new("DELETE", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteConfigurationSetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteConfigurationSetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_configuration_set_event_destination(
&self,
input: DeleteConfigurationSetEventDestinationRequest,
) -> Result<
DeleteConfigurationSetEventDestinationResponse,
RusotoError<DeleteConfigurationSetEventDestinationError>,
> {
let request_uri = format!("/v2/email/configuration-sets/{configuration_set_name}/event-destinations/{event_destination_name}", configuration_set_name = input.configuration_set_name, event_destination_name = input.event_destination_name);
let mut request = SignedRequest::new("DELETE", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteConfigurationSetEventDestinationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteConfigurationSetEventDestinationError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn delete_dedicated_ip_pool(
&self,
input: DeleteDedicatedIpPoolRequest,
) -> Result<DeleteDedicatedIpPoolResponse, RusotoError<DeleteDedicatedIpPoolError>> {
let request_uri = format!(
"/v2/email/dedicated-ip-pools/{pool_name}",
pool_name = input.pool_name
);
let mut request = SignedRequest::new("DELETE", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteDedicatedIpPoolResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteDedicatedIpPoolError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_email_identity(
&self,
input: DeleteEmailIdentityRequest,
) -> Result<DeleteEmailIdentityResponse, RusotoError<DeleteEmailIdentityError>> {
let request_uri = format!(
"/v2/email/identities/{email_identity}",
email_identity = input.email_identity
);
let mut request = SignedRequest::new("DELETE", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteEmailIdentityResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteEmailIdentityError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_suppressed_destination(
&self,
input: DeleteSuppressedDestinationRequest,
) -> Result<DeleteSuppressedDestinationResponse, RusotoError<DeleteSuppressedDestinationError>>
{
let request_uri = format!(
"/v2/email/suppression/addresses/{email_address}",
email_address = input.email_address
);
let mut request = SignedRequest::new("DELETE", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteSuppressedDestinationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteSuppressedDestinationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_account(&self) -> Result<GetAccountResponse, RusotoError<GetAccountError>> {
let request_uri = "/v2/email/account";
let mut request = SignedRequest::new("GET", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetAccountResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetAccountError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_blacklist_reports(
&self,
input: GetBlacklistReportsRequest,
) -> Result<GetBlacklistReportsResponse, RusotoError<GetBlacklistReportsError>> {
let request_uri = "/v2/email/deliverability-dashboard/blacklist-report";
let mut request = SignedRequest::new("GET", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut params = Params::new();
for item in input.blacklist_item_names.iter() {
params.put("BlacklistItemNames", item);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetBlacklistReportsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetBlacklistReportsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_configuration_set(
&self,
input: GetConfigurationSetRequest,
) -> Result<GetConfigurationSetResponse, RusotoError<GetConfigurationSetError>> {
let request_uri = format!(
"/v2/email/configuration-sets/{configuration_set_name}",
configuration_set_name = input.configuration_set_name
);
let mut request = SignedRequest::new("GET", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetConfigurationSetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetConfigurationSetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_configuration_set_event_destinations(
&self,
input: GetConfigurationSetEventDestinationsRequest,
) -> Result<
GetConfigurationSetEventDestinationsResponse,
RusotoError<GetConfigurationSetEventDestinationsError>,
> {
let request_uri = format!(
"/v2/email/configuration-sets/{configuration_set_name}/event-destinations",
configuration_set_name = input.configuration_set_name
);
let mut request = SignedRequest::new("GET", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetConfigurationSetEventDestinationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetConfigurationSetEventDestinationsError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn get_dedicated_ip(
&self,
input: GetDedicatedIpRequest,
) -> Result<GetDedicatedIpResponse, RusotoError<GetDedicatedIpError>> {
let request_uri = format!("/v2/email/dedicated-ips/{ip}", ip = input.ip);
let mut request = SignedRequest::new("GET", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetDedicatedIpResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDedicatedIpError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_dedicated_ips(
&self,
input: GetDedicatedIpsRequest,
) -> Result<GetDedicatedIpsResponse, RusotoError<GetDedicatedIpsError>> {
let request_uri = "/v2/email/dedicated-ips";
let mut request = SignedRequest::new("GET", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut params = Params::new();
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
if let Some(ref x) = input.page_size {
params.put("PageSize", x);
}
if let Some(ref x) = input.pool_name {
params.put("PoolName", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetDedicatedIpsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDedicatedIpsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_deliverability_dashboard_options(
&self,
) -> Result<
GetDeliverabilityDashboardOptionsResponse,
RusotoError<GetDeliverabilityDashboardOptionsError>,
> {
let request_uri = "/v2/email/deliverability-dashboard";
let mut request = SignedRequest::new("GET", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetDeliverabilityDashboardOptionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDeliverabilityDashboardOptionsError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn get_deliverability_test_report(
&self,
input: GetDeliverabilityTestReportRequest,
) -> Result<GetDeliverabilityTestReportResponse, RusotoError<GetDeliverabilityTestReportError>>
{
let request_uri = format!(
"/v2/email/deliverability-dashboard/test-reports/{report_id}",
report_id = input.report_id
);
let mut request = SignedRequest::new("GET", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetDeliverabilityTestReportResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDeliverabilityTestReportError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_domain_deliverability_campaign(
&self,
input: GetDomainDeliverabilityCampaignRequest,
) -> Result<
GetDomainDeliverabilityCampaignResponse,
RusotoError<GetDomainDeliverabilityCampaignError>,
> {
let request_uri = format!(
"/v2/email/deliverability-dashboard/campaigns/{campaign_id}",
campaign_id = input.campaign_id
);
let mut request = SignedRequest::new("GET", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetDomainDeliverabilityCampaignResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDomainDeliverabilityCampaignError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn get_domain_statistics_report(
&self,
input: GetDomainStatisticsReportRequest,
) -> Result<GetDomainStatisticsReportResponse, RusotoError<GetDomainStatisticsReportError>>
{
let request_uri = format!(
"/v2/email/deliverability-dashboard/statistics-report/{domain}",
domain = input.domain
);
let mut request = SignedRequest::new("GET", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut params = Params::new();
params.put("EndDate", &input.end_date);
params.put("StartDate", &input.start_date);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetDomainStatisticsReportResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDomainStatisticsReportError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_email_identity(
&self,
input: GetEmailIdentityRequest,
) -> Result<GetEmailIdentityResponse, RusotoError<GetEmailIdentityError>> {
let request_uri = format!(
"/v2/email/identities/{email_identity}",
email_identity = input.email_identity
);
let mut request = SignedRequest::new("GET", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetEmailIdentityResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetEmailIdentityError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_suppressed_destination(
&self,
input: GetSuppressedDestinationRequest,
) -> Result<GetSuppressedDestinationResponse, RusotoError<GetSuppressedDestinationError>> {
let request_uri = format!(
"/v2/email/suppression/addresses/{email_address}",
email_address = input.email_address
);
let mut request = SignedRequest::new("GET", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetSuppressedDestinationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetSuppressedDestinationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_configuration_sets(
&self,
input: ListConfigurationSetsRequest,
) -> Result<ListConfigurationSetsResponse, RusotoError<ListConfigurationSetsError>> {
let request_uri = "/v2/email/configuration-sets";
let mut request = SignedRequest::new("GET", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut params = Params::new();
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
if let Some(ref x) = input.page_size {
params.put("PageSize", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListConfigurationSetsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListConfigurationSetsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_dedicated_ip_pools(
&self,
input: ListDedicatedIpPoolsRequest,
) -> Result<ListDedicatedIpPoolsResponse, RusotoError<ListDedicatedIpPoolsError>> {
let request_uri = "/v2/email/dedicated-ip-pools";
let mut request = SignedRequest::new("GET", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut params = Params::new();
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
if let Some(ref x) = input.page_size {
params.put("PageSize", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDedicatedIpPoolsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDedicatedIpPoolsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_deliverability_test_reports(
&self,
input: ListDeliverabilityTestReportsRequest,
) -> Result<
ListDeliverabilityTestReportsResponse,
RusotoError<ListDeliverabilityTestReportsError>,
> {
let request_uri = "/v2/email/deliverability-dashboard/test-reports";
let mut request = SignedRequest::new("GET", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut params = Params::new();
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
if let Some(ref x) = input.page_size {
params.put("PageSize", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDeliverabilityTestReportsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDeliverabilityTestReportsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_domain_deliverability_campaigns(
&self,
input: ListDomainDeliverabilityCampaignsRequest,
) -> Result<
ListDomainDeliverabilityCampaignsResponse,
RusotoError<ListDomainDeliverabilityCampaignsError>,
> {
let request_uri = format!(
"/v2/email/deliverability-dashboard/domains/{subscribed_domain}/campaigns",
subscribed_domain = input.subscribed_domain
);
let mut request = SignedRequest::new("GET", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut params = Params::new();
params.put("EndDate", &input.end_date);
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
if let Some(ref x) = input.page_size {
params.put("PageSize", x);
}
params.put("StartDate", &input.start_date);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDomainDeliverabilityCampaignsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDomainDeliverabilityCampaignsError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn list_email_identities(
&self,
input: ListEmailIdentitiesRequest,
) -> Result<ListEmailIdentitiesResponse, RusotoError<ListEmailIdentitiesError>> {
let request_uri = "/v2/email/identities";
let mut request = SignedRequest::new("GET", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut params = Params::new();
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
if let Some(ref x) = input.page_size {
params.put("PageSize", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListEmailIdentitiesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListEmailIdentitiesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_suppressed_destinations(
&self,
input: ListSuppressedDestinationsRequest,
) -> Result<ListSuppressedDestinationsResponse, RusotoError<ListSuppressedDestinationsError>>
{
let request_uri = "/v2/email/suppression/addresses";
let mut request = SignedRequest::new("GET", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut params = Params::new();
if let Some(ref x) = input.end_date {
params.put("EndDate", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
if let Some(ref x) = input.page_size {
params.put("PageSize", x);
}
if let Some(ref x) = input.reasons {
for item in x.iter() {
params.put("Reason", item);
}
}
if let Some(ref x) = input.start_date {
params.put("StartDate", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListSuppressedDestinationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListSuppressedDestinationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let request_uri = "/v2/email/tags";
let mut request = SignedRequest::new("GET", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut params = Params::new();
params.put("ResourceArn", &input.resource_arn);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsForResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_account_dedicated_ip_warmup_attributes(
&self,
input: PutAccountDedicatedIpWarmupAttributesRequest,
) -> Result<
PutAccountDedicatedIpWarmupAttributesResponse,
RusotoError<PutAccountDedicatedIpWarmupAttributesError>,
> {
let request_uri = "/v2/email/account/dedicated-ips/warmup";
let mut request = SignedRequest::new("PUT", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutAccountDedicatedIpWarmupAttributesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutAccountDedicatedIpWarmupAttributesError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn put_account_sending_attributes(
&self,
input: PutAccountSendingAttributesRequest,
) -> Result<PutAccountSendingAttributesResponse, RusotoError<PutAccountSendingAttributesError>>
{
let request_uri = "/v2/email/account/sending";
let mut request = SignedRequest::new("PUT", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutAccountSendingAttributesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutAccountSendingAttributesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_account_suppression_attributes(
&self,
input: PutAccountSuppressionAttributesRequest,
) -> Result<
PutAccountSuppressionAttributesResponse,
RusotoError<PutAccountSuppressionAttributesError>,
> {
let request_uri = "/v2/email/account/suppression";
let mut request = SignedRequest::new("PUT", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutAccountSuppressionAttributesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutAccountSuppressionAttributesError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn put_configuration_set_delivery_options(
&self,
input: PutConfigurationSetDeliveryOptionsRequest,
) -> Result<
PutConfigurationSetDeliveryOptionsResponse,
RusotoError<PutConfigurationSetDeliveryOptionsError>,
> {
let request_uri = format!(
"/v2/email/configuration-sets/{configuration_set_name}/delivery-options",
configuration_set_name = input.configuration_set_name
);
let mut request = SignedRequest::new("PUT", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutConfigurationSetDeliveryOptionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutConfigurationSetDeliveryOptionsError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn put_configuration_set_reputation_options(
&self,
input: PutConfigurationSetReputationOptionsRequest,
) -> Result<
PutConfigurationSetReputationOptionsResponse,
RusotoError<PutConfigurationSetReputationOptionsError>,
> {
let request_uri = format!(
"/v2/email/configuration-sets/{configuration_set_name}/reputation-options",
configuration_set_name = input.configuration_set_name
);
let mut request = SignedRequest::new("PUT", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutConfigurationSetReputationOptionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutConfigurationSetReputationOptionsError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn put_configuration_set_sending_options(
&self,
input: PutConfigurationSetSendingOptionsRequest,
) -> Result<
PutConfigurationSetSendingOptionsResponse,
RusotoError<PutConfigurationSetSendingOptionsError>,
> {
let request_uri = format!(
"/v2/email/configuration-sets/{configuration_set_name}/sending",
configuration_set_name = input.configuration_set_name
);
let mut request = SignedRequest::new("PUT", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutConfigurationSetSendingOptionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutConfigurationSetSendingOptionsError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn put_configuration_set_suppression_options(
&self,
input: PutConfigurationSetSuppressionOptionsRequest,
) -> Result<
PutConfigurationSetSuppressionOptionsResponse,
RusotoError<PutConfigurationSetSuppressionOptionsError>,
> {
let request_uri = format!(
"/v2/email/configuration-sets/{configuration_set_name}/suppression-options",
configuration_set_name = input.configuration_set_name
);
let mut request = SignedRequest::new("PUT", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutConfigurationSetSuppressionOptionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutConfigurationSetSuppressionOptionsError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn put_configuration_set_tracking_options(
&self,
input: PutConfigurationSetTrackingOptionsRequest,
) -> Result<
PutConfigurationSetTrackingOptionsResponse,
RusotoError<PutConfigurationSetTrackingOptionsError>,
> {
let request_uri = format!(
"/v2/email/configuration-sets/{configuration_set_name}/tracking-options",
configuration_set_name = input.configuration_set_name
);
let mut request = SignedRequest::new("PUT", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutConfigurationSetTrackingOptionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutConfigurationSetTrackingOptionsError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn put_dedicated_ip_in_pool(
&self,
input: PutDedicatedIpInPoolRequest,
) -> Result<PutDedicatedIpInPoolResponse, RusotoError<PutDedicatedIpInPoolError>> {
let request_uri = format!("/v2/email/dedicated-ips/{ip}/pool", ip = input.ip);
let mut request = SignedRequest::new("PUT", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutDedicatedIpInPoolResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutDedicatedIpInPoolError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_dedicated_ip_warmup_attributes(
&self,
input: PutDedicatedIpWarmupAttributesRequest,
) -> Result<
PutDedicatedIpWarmupAttributesResponse,
RusotoError<PutDedicatedIpWarmupAttributesError>,
> {
let request_uri = format!("/v2/email/dedicated-ips/{ip}/warmup", ip = input.ip);
let mut request = SignedRequest::new("PUT", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutDedicatedIpWarmupAttributesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutDedicatedIpWarmupAttributesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_deliverability_dashboard_option(
&self,
input: PutDeliverabilityDashboardOptionRequest,
) -> Result<
PutDeliverabilityDashboardOptionResponse,
RusotoError<PutDeliverabilityDashboardOptionError>,
> {
let request_uri = "/v2/email/deliverability-dashboard";
let mut request = SignedRequest::new("PUT", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutDeliverabilityDashboardOptionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutDeliverabilityDashboardOptionError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn put_email_identity_dkim_attributes(
&self,
input: PutEmailIdentityDkimAttributesRequest,
) -> Result<
PutEmailIdentityDkimAttributesResponse,
RusotoError<PutEmailIdentityDkimAttributesError>,
> {
let request_uri = format!(
"/v2/email/identities/{email_identity}/dkim",
email_identity = input.email_identity
);
let mut request = SignedRequest::new("PUT", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutEmailIdentityDkimAttributesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutEmailIdentityDkimAttributesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_email_identity_dkim_signing_attributes(
&self,
input: PutEmailIdentityDkimSigningAttributesRequest,
) -> Result<
PutEmailIdentityDkimSigningAttributesResponse,
RusotoError<PutEmailIdentityDkimSigningAttributesError>,
> {
let request_uri = format!(
"/v1/email/identities/{email_identity}/dkim/signing",
email_identity = input.email_identity
);
let mut request = SignedRequest::new("PUT", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutEmailIdentityDkimSigningAttributesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutEmailIdentityDkimSigningAttributesError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn put_email_identity_feedback_attributes(
&self,
input: PutEmailIdentityFeedbackAttributesRequest,
) -> Result<
PutEmailIdentityFeedbackAttributesResponse,
RusotoError<PutEmailIdentityFeedbackAttributesError>,
> {
let request_uri = format!(
"/v2/email/identities/{email_identity}/feedback",
email_identity = input.email_identity
);
let mut request = SignedRequest::new("PUT", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutEmailIdentityFeedbackAttributesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutEmailIdentityFeedbackAttributesError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn put_email_identity_mail_from_attributes(
&self,
input: PutEmailIdentityMailFromAttributesRequest,
) -> Result<
PutEmailIdentityMailFromAttributesResponse,
RusotoError<PutEmailIdentityMailFromAttributesError>,
> {
let request_uri = format!(
"/v2/email/identities/{email_identity}/mail-from",
email_identity = input.email_identity
);
let mut request = SignedRequest::new("PUT", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutEmailIdentityMailFromAttributesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutEmailIdentityMailFromAttributesError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn put_suppressed_destination(
&self,
input: PutSuppressedDestinationRequest,
) -> Result<PutSuppressedDestinationResponse, RusotoError<PutSuppressedDestinationError>> {
let request_uri = "/v2/email/suppression/addresses";
let mut request = SignedRequest::new("PUT", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutSuppressedDestinationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutSuppressedDestinationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn send_email(
&self,
input: SendEmailRequest,
) -> Result<SendEmailResponse, RusotoError<SendEmailError>> {
let request_uri = "/v2/email/outbound-emails";
let mut request = SignedRequest::new("POST", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<SendEmailResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(SendEmailError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let request_uri = "/v2/email/tags";
let mut request = SignedRequest::new("POST", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<TagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let request_uri = "/v2/email/tags";
let mut request = SignedRequest::new("DELETE", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let mut params = Params::new();
params.put("ResourceArn", &input.resource_arn);
for item in input.tag_keys.iter() {
params.put("TagKeys", item);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UntagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_configuration_set_event_destination(
&self,
input: UpdateConfigurationSetEventDestinationRequest,
) -> Result<
UpdateConfigurationSetEventDestinationResponse,
RusotoError<UpdateConfigurationSetEventDestinationError>,
> {
let request_uri = format!("/v2/email/configuration-sets/{configuration_set_name}/event-destinations/{event_destination_name}", configuration_set_name = input.configuration_set_name, event_destination_name = input.event_destination_name);
let mut request = SignedRequest::new("PUT", "ses", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("email".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateConfigurationSetEventDestinationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateConfigurationSetEventDestinationError::from_response(
response,
))
}
}
}