pub fn serialize_operation_crate_operation_clone_receipt_rule_set(
input: &crate::input::CloneReceiptRuleSetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CloneReceiptRuleSet", "2010-12-01");
#[allow(unused_mut)]
let mut scope_1 = writer.prefix("RuleSetName");
if let Some(var_2) = &input.rule_set_name {
scope_1.string(var_2);
}
#[allow(unused_mut)]
let mut scope_3 = writer.prefix("OriginalRuleSetName");
if let Some(var_4) = &input.original_rule_set_name {
scope_3.string(var_4);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_configuration_set(
input: &crate::input::CreateConfigurationSetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateConfigurationSet", "2010-12-01");
#[allow(unused_mut)]
let mut scope_5 = writer.prefix("ConfigurationSet");
if let Some(var_6) = &input.configuration_set {
crate::query_ser::serialize_structure_crate_model_configuration_set(scope_5, var_6)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_configuration_set_event_destination(
input: &crate::input::CreateConfigurationSetEventDestinationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateConfigurationSetEventDestination",
"2010-12-01",
);
#[allow(unused_mut)]
let mut scope_7 = writer.prefix("ConfigurationSetName");
if let Some(var_8) = &input.configuration_set_name {
scope_7.string(var_8);
}
#[allow(unused_mut)]
let mut scope_9 = writer.prefix("EventDestination");
if let Some(var_10) = &input.event_destination {
crate::query_ser::serialize_structure_crate_model_event_destination(scope_9, var_10)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_configuration_set_tracking_options(
input: &crate::input::CreateConfigurationSetTrackingOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateConfigurationSetTrackingOptions",
"2010-12-01",
);
#[allow(unused_mut)]
let mut scope_11 = writer.prefix("ConfigurationSetName");
if let Some(var_12) = &input.configuration_set_name {
scope_11.string(var_12);
}
#[allow(unused_mut)]
let mut scope_13 = writer.prefix("TrackingOptions");
if let Some(var_14) = &input.tracking_options {
crate::query_ser::serialize_structure_crate_model_tracking_options(scope_13, var_14)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_custom_verification_email_template(
input: &crate::input::CreateCustomVerificationEmailTemplateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"CreateCustomVerificationEmailTemplate",
"2010-12-01",
);
#[allow(unused_mut)]
let mut scope_15 = writer.prefix("TemplateName");
if let Some(var_16) = &input.template_name {
scope_15.string(var_16);
}
#[allow(unused_mut)]
let mut scope_17 = writer.prefix("FromEmailAddress");
if let Some(var_18) = &input.from_email_address {
scope_17.string(var_18);
}
#[allow(unused_mut)]
let mut scope_19 = writer.prefix("TemplateSubject");
if let Some(var_20) = &input.template_subject {
scope_19.string(var_20);
}
#[allow(unused_mut)]
let mut scope_21 = writer.prefix("TemplateContent");
if let Some(var_22) = &input.template_content {
scope_21.string(var_22);
}
#[allow(unused_mut)]
let mut scope_23 = writer.prefix("SuccessRedirectionURL");
if let Some(var_24) = &input.success_redirection_url {
scope_23.string(var_24);
}
#[allow(unused_mut)]
let mut scope_25 = writer.prefix("FailureRedirectionURL");
if let Some(var_26) = &input.failure_redirection_url {
scope_25.string(var_26);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_receipt_filter(
input: &crate::input::CreateReceiptFilterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateReceiptFilter", "2010-12-01");
#[allow(unused_mut)]
let mut scope_27 = writer.prefix("Filter");
if let Some(var_28) = &input.filter {
crate::query_ser::serialize_structure_crate_model_receipt_filter(scope_27, var_28)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_receipt_rule(
input: &crate::input::CreateReceiptRuleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateReceiptRule", "2010-12-01");
#[allow(unused_mut)]
let mut scope_29 = writer.prefix("RuleSetName");
if let Some(var_30) = &input.rule_set_name {
scope_29.string(var_30);
}
#[allow(unused_mut)]
let mut scope_31 = writer.prefix("After");
if let Some(var_32) = &input.after {
scope_31.string(var_32);
}
#[allow(unused_mut)]
let mut scope_33 = writer.prefix("Rule");
if let Some(var_34) = &input.rule {
crate::query_ser::serialize_structure_crate_model_receipt_rule(scope_33, var_34)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_receipt_rule_set(
input: &crate::input::CreateReceiptRuleSetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateReceiptRuleSet", "2010-12-01");
#[allow(unused_mut)]
let mut scope_35 = writer.prefix("RuleSetName");
if let Some(var_36) = &input.rule_set_name {
scope_35.string(var_36);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_template(
input: &crate::input::CreateTemplateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateTemplate", "2010-12-01");
#[allow(unused_mut)]
let mut scope_37 = writer.prefix("Template");
if let Some(var_38) = &input.template {
crate::query_ser::serialize_structure_crate_model_template(scope_37, var_38)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_configuration_set(
input: &crate::input::DeleteConfigurationSetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteConfigurationSet", "2010-12-01");
#[allow(unused_mut)]
let mut scope_39 = writer.prefix("ConfigurationSetName");
if let Some(var_40) = &input.configuration_set_name {
scope_39.string(var_40);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_configuration_set_event_destination(
input: &crate::input::DeleteConfigurationSetEventDestinationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteConfigurationSetEventDestination",
"2010-12-01",
);
#[allow(unused_mut)]
let mut scope_41 = writer.prefix("ConfigurationSetName");
if let Some(var_42) = &input.configuration_set_name {
scope_41.string(var_42);
}
#[allow(unused_mut)]
let mut scope_43 = writer.prefix("EventDestinationName");
if let Some(var_44) = &input.event_destination_name {
scope_43.string(var_44);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_configuration_set_tracking_options(
input: &crate::input::DeleteConfigurationSetTrackingOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteConfigurationSetTrackingOptions",
"2010-12-01",
);
#[allow(unused_mut)]
let mut scope_45 = writer.prefix("ConfigurationSetName");
if let Some(var_46) = &input.configuration_set_name {
scope_45.string(var_46);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_custom_verification_email_template(
input: &crate::input::DeleteCustomVerificationEmailTemplateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteCustomVerificationEmailTemplate",
"2010-12-01",
);
#[allow(unused_mut)]
let mut scope_47 = writer.prefix("TemplateName");
if let Some(var_48) = &input.template_name {
scope_47.string(var_48);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_identity(
input: &crate::input::DeleteIdentityInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteIdentity", "2010-12-01");
#[allow(unused_mut)]
let mut scope_49 = writer.prefix("Identity");
if let Some(var_50) = &input.identity {
scope_49.string(var_50);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_identity_policy(
input: &crate::input::DeleteIdentityPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteIdentityPolicy", "2010-12-01");
#[allow(unused_mut)]
let mut scope_51 = writer.prefix("Identity");
if let Some(var_52) = &input.identity {
scope_51.string(var_52);
}
#[allow(unused_mut)]
let mut scope_53 = writer.prefix("PolicyName");
if let Some(var_54) = &input.policy_name {
scope_53.string(var_54);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_receipt_filter(
input: &crate::input::DeleteReceiptFilterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteReceiptFilter", "2010-12-01");
#[allow(unused_mut)]
let mut scope_55 = writer.prefix("FilterName");
if let Some(var_56) = &input.filter_name {
scope_55.string(var_56);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_receipt_rule(
input: &crate::input::DeleteReceiptRuleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteReceiptRule", "2010-12-01");
#[allow(unused_mut)]
let mut scope_57 = writer.prefix("RuleSetName");
if let Some(var_58) = &input.rule_set_name {
scope_57.string(var_58);
}
#[allow(unused_mut)]
let mut scope_59 = writer.prefix("RuleName");
if let Some(var_60) = &input.rule_name {
scope_59.string(var_60);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_receipt_rule_set(
input: &crate::input::DeleteReceiptRuleSetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteReceiptRuleSet", "2010-12-01");
#[allow(unused_mut)]
let mut scope_61 = writer.prefix("RuleSetName");
if let Some(var_62) = &input.rule_set_name {
scope_61.string(var_62);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_template(
input: &crate::input::DeleteTemplateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteTemplate", "2010-12-01");
#[allow(unused_mut)]
let mut scope_63 = writer.prefix("TemplateName");
if let Some(var_64) = &input.template_name {
scope_63.string(var_64);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_verified_email_address(
input: &crate::input::DeleteVerifiedEmailAddressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteVerifiedEmailAddress", "2010-12-01");
#[allow(unused_mut)]
let mut scope_65 = writer.prefix("EmailAddress");
if let Some(var_66) = &input.email_address {
scope_65.string(var_66);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_active_receipt_rule_set(
input: &crate::input::DescribeActiveReceiptRuleSetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeActiveReceiptRuleSet", "2010-12-01");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_configuration_set(
input: &crate::input::DescribeConfigurationSetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeConfigurationSet", "2010-12-01");
#[allow(unused_mut)]
let mut scope_67 = writer.prefix("ConfigurationSetName");
if let Some(var_68) = &input.configuration_set_name {
scope_67.string(var_68);
}
#[allow(unused_mut)]
let mut scope_69 = writer.prefix("ConfigurationSetAttributeNames");
if let Some(var_70) = &input.configuration_set_attribute_names {
let mut list_72 = scope_69.start_list(false, None);
for item_71 in var_70 {
#[allow(unused_mut)]
let mut entry_73 = list_72.entry();
entry_73.string(item_71.as_str());
}
list_72.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_receipt_rule(
input: &crate::input::DescribeReceiptRuleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeReceiptRule", "2010-12-01");
#[allow(unused_mut)]
let mut scope_74 = writer.prefix("RuleSetName");
if let Some(var_75) = &input.rule_set_name {
scope_74.string(var_75);
}
#[allow(unused_mut)]
let mut scope_76 = writer.prefix("RuleName");
if let Some(var_77) = &input.rule_name {
scope_76.string(var_77);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_receipt_rule_set(
input: &crate::input::DescribeReceiptRuleSetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeReceiptRuleSet", "2010-12-01");
#[allow(unused_mut)]
let mut scope_78 = writer.prefix("RuleSetName");
if let Some(var_79) = &input.rule_set_name {
scope_78.string(var_79);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_account_sending_enabled(
input: &crate::input::GetAccountSendingEnabledInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetAccountSendingEnabled", "2010-12-01");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_custom_verification_email_template(
input: &crate::input::GetCustomVerificationEmailTemplateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetCustomVerificationEmailTemplate",
"2010-12-01",
);
#[allow(unused_mut)]
let mut scope_80 = writer.prefix("TemplateName");
if let Some(var_81) = &input.template_name {
scope_80.string(var_81);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_identity_dkim_attributes(
input: &crate::input::GetIdentityDkimAttributesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetIdentityDkimAttributes", "2010-12-01");
#[allow(unused_mut)]
let mut scope_82 = writer.prefix("Identities");
if let Some(var_83) = &input.identities {
let mut list_85 = scope_82.start_list(false, None);
for item_84 in var_83 {
#[allow(unused_mut)]
let mut entry_86 = list_85.entry();
entry_86.string(item_84);
}
list_85.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_identity_mail_from_domain_attributes(
input: &crate::input::GetIdentityMailFromDomainAttributesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetIdentityMailFromDomainAttributes",
"2010-12-01",
);
#[allow(unused_mut)]
let mut scope_87 = writer.prefix("Identities");
if let Some(var_88) = &input.identities {
let mut list_90 = scope_87.start_list(false, None);
for item_89 in var_88 {
#[allow(unused_mut)]
let mut entry_91 = list_90.entry();
entry_91.string(item_89);
}
list_90.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_identity_notification_attributes(
input: &crate::input::GetIdentityNotificationAttributesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetIdentityNotificationAttributes",
"2010-12-01",
);
#[allow(unused_mut)]
let mut scope_92 = writer.prefix("Identities");
if let Some(var_93) = &input.identities {
let mut list_95 = scope_92.start_list(false, None);
for item_94 in var_93 {
#[allow(unused_mut)]
let mut entry_96 = list_95.entry();
entry_96.string(item_94);
}
list_95.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_identity_policies(
input: &crate::input::GetIdentityPoliciesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetIdentityPolicies", "2010-12-01");
#[allow(unused_mut)]
let mut scope_97 = writer.prefix("Identity");
if let Some(var_98) = &input.identity {
scope_97.string(var_98);
}
#[allow(unused_mut)]
let mut scope_99 = writer.prefix("PolicyNames");
if let Some(var_100) = &input.policy_names {
let mut list_102 = scope_99.start_list(false, None);
for item_101 in var_100 {
#[allow(unused_mut)]
let mut entry_103 = list_102.entry();
entry_103.string(item_101);
}
list_102.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_identity_verification_attributes(
input: &crate::input::GetIdentityVerificationAttributesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetIdentityVerificationAttributes",
"2010-12-01",
);
#[allow(unused_mut)]
let mut scope_104 = writer.prefix("Identities");
if let Some(var_105) = &input.identities {
let mut list_107 = scope_104.start_list(false, None);
for item_106 in var_105 {
#[allow(unused_mut)]
let mut entry_108 = list_107.entry();
entry_108.string(item_106);
}
list_107.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_send_quota(
input: &crate::input::GetSendQuotaInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetSendQuota", "2010-12-01");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_send_statistics(
input: &crate::input::GetSendStatisticsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetSendStatistics", "2010-12-01");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_template(
input: &crate::input::GetTemplateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "GetTemplate", "2010-12-01");
#[allow(unused_mut)]
let mut scope_109 = writer.prefix("TemplateName");
if let Some(var_110) = &input.template_name {
scope_109.string(var_110);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_configuration_sets(
input: &crate::input::ListConfigurationSetsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListConfigurationSets", "2010-12-01");
#[allow(unused_mut)]
let mut scope_111 = writer.prefix("NextToken");
if let Some(var_112) = &input.next_token {
scope_111.string(var_112);
}
#[allow(unused_mut)]
let mut scope_113 = writer.prefix("MaxItems");
if let Some(var_114) = &input.max_items {
scope_113.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_114).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_custom_verification_email_templates(
input: &crate::input::ListCustomVerificationEmailTemplatesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ListCustomVerificationEmailTemplates",
"2010-12-01",
);
#[allow(unused_mut)]
let mut scope_115 = writer.prefix("NextToken");
if let Some(var_116) = &input.next_token {
scope_115.string(var_116);
}
#[allow(unused_mut)]
let mut scope_117 = writer.prefix("MaxResults");
if let Some(var_118) = &input.max_results {
scope_117.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_118).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_identities(
input: &crate::input::ListIdentitiesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListIdentities", "2010-12-01");
#[allow(unused_mut)]
let mut scope_119 = writer.prefix("IdentityType");
if let Some(var_120) = &input.identity_type {
scope_119.string(var_120.as_str());
}
#[allow(unused_mut)]
let mut scope_121 = writer.prefix("NextToken");
if let Some(var_122) = &input.next_token {
scope_121.string(var_122);
}
#[allow(unused_mut)]
let mut scope_123 = writer.prefix("MaxItems");
if let Some(var_124) = &input.max_items {
scope_123.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_124).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_identity_policies(
input: &crate::input::ListIdentityPoliciesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListIdentityPolicies", "2010-12-01");
#[allow(unused_mut)]
let mut scope_125 = writer.prefix("Identity");
if let Some(var_126) = &input.identity {
scope_125.string(var_126);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_receipt_filters(
input: &crate::input::ListReceiptFiltersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListReceiptFilters", "2010-12-01");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_receipt_rule_sets(
input: &crate::input::ListReceiptRuleSetsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListReceiptRuleSets", "2010-12-01");
#[allow(unused_mut)]
let mut scope_127 = writer.prefix("NextToken");
if let Some(var_128) = &input.next_token {
scope_127.string(var_128);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_templates(
input: &crate::input::ListTemplatesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ListTemplates", "2010-12-01");
#[allow(unused_mut)]
let mut scope_129 = writer.prefix("NextToken");
if let Some(var_130) = &input.next_token {
scope_129.string(var_130);
}
#[allow(unused_mut)]
let mut scope_131 = writer.prefix("MaxItems");
if let Some(var_132) = &input.max_items {
scope_131.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_132).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_verified_email_addresses(
input: &crate::input::ListVerifiedEmailAddressesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListVerifiedEmailAddresses", "2010-12-01");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_configuration_set_delivery_options(
input: &crate::input::PutConfigurationSetDeliveryOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"PutConfigurationSetDeliveryOptions",
"2010-12-01",
);
#[allow(unused_mut)]
let mut scope_133 = writer.prefix("ConfigurationSetName");
if let Some(var_134) = &input.configuration_set_name {
scope_133.string(var_134);
}
#[allow(unused_mut)]
let mut scope_135 = writer.prefix("DeliveryOptions");
if let Some(var_136) = &input.delivery_options {
crate::query_ser::serialize_structure_crate_model_delivery_options(scope_135, var_136)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_put_identity_policy(
input: &crate::input::PutIdentityPolicyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "PutIdentityPolicy", "2010-12-01");
#[allow(unused_mut)]
let mut scope_137 = writer.prefix("Identity");
if let Some(var_138) = &input.identity {
scope_137.string(var_138);
}
#[allow(unused_mut)]
let mut scope_139 = writer.prefix("PolicyName");
if let Some(var_140) = &input.policy_name {
scope_139.string(var_140);
}
#[allow(unused_mut)]
let mut scope_141 = writer.prefix("Policy");
if let Some(var_142) = &input.policy {
scope_141.string(var_142);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reorder_receipt_rule_set(
input: &crate::input::ReorderReceiptRuleSetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ReorderReceiptRuleSet", "2010-12-01");
#[allow(unused_mut)]
let mut scope_143 = writer.prefix("RuleSetName");
if let Some(var_144) = &input.rule_set_name {
scope_143.string(var_144);
}
#[allow(unused_mut)]
let mut scope_145 = writer.prefix("RuleNames");
if let Some(var_146) = &input.rule_names {
let mut list_148 = scope_145.start_list(false, None);
for item_147 in var_146 {
#[allow(unused_mut)]
let mut entry_149 = list_148.entry();
entry_149.string(item_147);
}
list_148.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_send_bounce(
input: &crate::input::SendBounceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "SendBounce", "2010-12-01");
#[allow(unused_mut)]
let mut scope_150 = writer.prefix("OriginalMessageId");
if let Some(var_151) = &input.original_message_id {
scope_150.string(var_151);
}
#[allow(unused_mut)]
let mut scope_152 = writer.prefix("BounceSender");
if let Some(var_153) = &input.bounce_sender {
scope_152.string(var_153);
}
#[allow(unused_mut)]
let mut scope_154 = writer.prefix("Explanation");
if let Some(var_155) = &input.explanation {
scope_154.string(var_155);
}
#[allow(unused_mut)]
let mut scope_156 = writer.prefix("MessageDsn");
if let Some(var_157) = &input.message_dsn {
crate::query_ser::serialize_structure_crate_model_message_dsn(scope_156, var_157)?;
}
#[allow(unused_mut)]
let mut scope_158 = writer.prefix("BouncedRecipientInfoList");
if let Some(var_159) = &input.bounced_recipient_info_list {
let mut list_161 = scope_158.start_list(false, None);
for item_160 in var_159 {
#[allow(unused_mut)]
let mut entry_162 = list_161.entry();
crate::query_ser::serialize_structure_crate_model_bounced_recipient_info(
entry_162, item_160,
)?;
}
list_161.finish();
}
#[allow(unused_mut)]
let mut scope_163 = writer.prefix("BounceSenderArn");
if let Some(var_164) = &input.bounce_sender_arn {
scope_163.string(var_164);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_send_bulk_templated_email(
input: &crate::input::SendBulkTemplatedEmailInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SendBulkTemplatedEmail", "2010-12-01");
#[allow(unused_mut)]
let mut scope_165 = writer.prefix("Source");
if let Some(var_166) = &input.source {
scope_165.string(var_166);
}
#[allow(unused_mut)]
let mut scope_167 = writer.prefix("SourceArn");
if let Some(var_168) = &input.source_arn {
scope_167.string(var_168);
}
#[allow(unused_mut)]
let mut scope_169 = writer.prefix("ReplyToAddresses");
if let Some(var_170) = &input.reply_to_addresses {
let mut list_172 = scope_169.start_list(false, None);
for item_171 in var_170 {
#[allow(unused_mut)]
let mut entry_173 = list_172.entry();
entry_173.string(item_171);
}
list_172.finish();
}
#[allow(unused_mut)]
let mut scope_174 = writer.prefix("ReturnPath");
if let Some(var_175) = &input.return_path {
scope_174.string(var_175);
}
#[allow(unused_mut)]
let mut scope_176 = writer.prefix("ReturnPathArn");
if let Some(var_177) = &input.return_path_arn {
scope_176.string(var_177);
}
#[allow(unused_mut)]
let mut scope_178 = writer.prefix("ConfigurationSetName");
if let Some(var_179) = &input.configuration_set_name {
scope_178.string(var_179);
}
#[allow(unused_mut)]
let mut scope_180 = writer.prefix("DefaultTags");
if let Some(var_181) = &input.default_tags {
let mut list_183 = scope_180.start_list(false, None);
for item_182 in var_181 {
#[allow(unused_mut)]
let mut entry_184 = list_183.entry();
crate::query_ser::serialize_structure_crate_model_message_tag(entry_184, item_182)?;
}
list_183.finish();
}
#[allow(unused_mut)]
let mut scope_185 = writer.prefix("Template");
if let Some(var_186) = &input.template {
scope_185.string(var_186);
}
#[allow(unused_mut)]
let mut scope_187 = writer.prefix("TemplateArn");
if let Some(var_188) = &input.template_arn {
scope_187.string(var_188);
}
#[allow(unused_mut)]
let mut scope_189 = writer.prefix("DefaultTemplateData");
if let Some(var_190) = &input.default_template_data {
scope_189.string(var_190);
}
#[allow(unused_mut)]
let mut scope_191 = writer.prefix("Destinations");
if let Some(var_192) = &input.destinations {
let mut list_194 = scope_191.start_list(false, None);
for item_193 in var_192 {
#[allow(unused_mut)]
let mut entry_195 = list_194.entry();
crate::query_ser::serialize_structure_crate_model_bulk_email_destination(
entry_195, item_193,
)?;
}
list_194.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_send_custom_verification_email(
input: &crate::input::SendCustomVerificationEmailInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SendCustomVerificationEmail", "2010-12-01");
#[allow(unused_mut)]
let mut scope_196 = writer.prefix("EmailAddress");
if let Some(var_197) = &input.email_address {
scope_196.string(var_197);
}
#[allow(unused_mut)]
let mut scope_198 = writer.prefix("TemplateName");
if let Some(var_199) = &input.template_name {
scope_198.string(var_199);
}
#[allow(unused_mut)]
let mut scope_200 = writer.prefix("ConfigurationSetName");
if let Some(var_201) = &input.configuration_set_name {
scope_200.string(var_201);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_send_email(
input: &crate::input::SendEmailInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "SendEmail", "2010-12-01");
#[allow(unused_mut)]
let mut scope_202 = writer.prefix("Source");
if let Some(var_203) = &input.source {
scope_202.string(var_203);
}
#[allow(unused_mut)]
let mut scope_204 = writer.prefix("Destination");
if let Some(var_205) = &input.destination {
crate::query_ser::serialize_structure_crate_model_destination(scope_204, var_205)?;
}
#[allow(unused_mut)]
let mut scope_206 = writer.prefix("Message");
if let Some(var_207) = &input.message {
crate::query_ser::serialize_structure_crate_model_message(scope_206, var_207)?;
}
#[allow(unused_mut)]
let mut scope_208 = writer.prefix("ReplyToAddresses");
if let Some(var_209) = &input.reply_to_addresses {
let mut list_211 = scope_208.start_list(false, None);
for item_210 in var_209 {
#[allow(unused_mut)]
let mut entry_212 = list_211.entry();
entry_212.string(item_210);
}
list_211.finish();
}
#[allow(unused_mut)]
let mut scope_213 = writer.prefix("ReturnPath");
if let Some(var_214) = &input.return_path {
scope_213.string(var_214);
}
#[allow(unused_mut)]
let mut scope_215 = writer.prefix("SourceArn");
if let Some(var_216) = &input.source_arn {
scope_215.string(var_216);
}
#[allow(unused_mut)]
let mut scope_217 = writer.prefix("ReturnPathArn");
if let Some(var_218) = &input.return_path_arn {
scope_217.string(var_218);
}
#[allow(unused_mut)]
let mut scope_219 = writer.prefix("Tags");
if let Some(var_220) = &input.tags {
let mut list_222 = scope_219.start_list(false, None);
for item_221 in var_220 {
#[allow(unused_mut)]
let mut entry_223 = list_222.entry();
crate::query_ser::serialize_structure_crate_model_message_tag(entry_223, item_221)?;
}
list_222.finish();
}
#[allow(unused_mut)]
let mut scope_224 = writer.prefix("ConfigurationSetName");
if let Some(var_225) = &input.configuration_set_name {
scope_224.string(var_225);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_send_raw_email(
input: &crate::input::SendRawEmailInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "SendRawEmail", "2010-12-01");
#[allow(unused_mut)]
let mut scope_226 = writer.prefix("Source");
if let Some(var_227) = &input.source {
scope_226.string(var_227);
}
#[allow(unused_mut)]
let mut scope_228 = writer.prefix("Destinations");
if let Some(var_229) = &input.destinations {
let mut list_231 = scope_228.start_list(false, None);
for item_230 in var_229 {
#[allow(unused_mut)]
let mut entry_232 = list_231.entry();
entry_232.string(item_230);
}
list_231.finish();
}
#[allow(unused_mut)]
let mut scope_233 = writer.prefix("RawMessage");
if let Some(var_234) = &input.raw_message {
crate::query_ser::serialize_structure_crate_model_raw_message(scope_233, var_234)?;
}
#[allow(unused_mut)]
let mut scope_235 = writer.prefix("FromArn");
if let Some(var_236) = &input.from_arn {
scope_235.string(var_236);
}
#[allow(unused_mut)]
let mut scope_237 = writer.prefix("SourceArn");
if let Some(var_238) = &input.source_arn {
scope_237.string(var_238);
}
#[allow(unused_mut)]
let mut scope_239 = writer.prefix("ReturnPathArn");
if let Some(var_240) = &input.return_path_arn {
scope_239.string(var_240);
}
#[allow(unused_mut)]
let mut scope_241 = writer.prefix("Tags");
if let Some(var_242) = &input.tags {
let mut list_244 = scope_241.start_list(false, None);
for item_243 in var_242 {
#[allow(unused_mut)]
let mut entry_245 = list_244.entry();
crate::query_ser::serialize_structure_crate_model_message_tag(entry_245, item_243)?;
}
list_244.finish();
}
#[allow(unused_mut)]
let mut scope_246 = writer.prefix("ConfigurationSetName");
if let Some(var_247) = &input.configuration_set_name {
scope_246.string(var_247);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_send_templated_email(
input: &crate::input::SendTemplatedEmailInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SendTemplatedEmail", "2010-12-01");
#[allow(unused_mut)]
let mut scope_248 = writer.prefix("Source");
if let Some(var_249) = &input.source {
scope_248.string(var_249);
}
#[allow(unused_mut)]
let mut scope_250 = writer.prefix("Destination");
if let Some(var_251) = &input.destination {
crate::query_ser::serialize_structure_crate_model_destination(scope_250, var_251)?;
}
#[allow(unused_mut)]
let mut scope_252 = writer.prefix("ReplyToAddresses");
if let Some(var_253) = &input.reply_to_addresses {
let mut list_255 = scope_252.start_list(false, None);
for item_254 in var_253 {
#[allow(unused_mut)]
let mut entry_256 = list_255.entry();
entry_256.string(item_254);
}
list_255.finish();
}
#[allow(unused_mut)]
let mut scope_257 = writer.prefix("ReturnPath");
if let Some(var_258) = &input.return_path {
scope_257.string(var_258);
}
#[allow(unused_mut)]
let mut scope_259 = writer.prefix("SourceArn");
if let Some(var_260) = &input.source_arn {
scope_259.string(var_260);
}
#[allow(unused_mut)]
let mut scope_261 = writer.prefix("ReturnPathArn");
if let Some(var_262) = &input.return_path_arn {
scope_261.string(var_262);
}
#[allow(unused_mut)]
let mut scope_263 = writer.prefix("Tags");
if let Some(var_264) = &input.tags {
let mut list_266 = scope_263.start_list(false, None);
for item_265 in var_264 {
#[allow(unused_mut)]
let mut entry_267 = list_266.entry();
crate::query_ser::serialize_structure_crate_model_message_tag(entry_267, item_265)?;
}
list_266.finish();
}
#[allow(unused_mut)]
let mut scope_268 = writer.prefix("ConfigurationSetName");
if let Some(var_269) = &input.configuration_set_name {
scope_268.string(var_269);
}
#[allow(unused_mut)]
let mut scope_270 = writer.prefix("Template");
if let Some(var_271) = &input.template {
scope_270.string(var_271);
}
#[allow(unused_mut)]
let mut scope_272 = writer.prefix("TemplateArn");
if let Some(var_273) = &input.template_arn {
scope_272.string(var_273);
}
#[allow(unused_mut)]
let mut scope_274 = writer.prefix("TemplateData");
if let Some(var_275) = &input.template_data {
scope_274.string(var_275);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_set_active_receipt_rule_set(
input: &crate::input::SetActiveReceiptRuleSetInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SetActiveReceiptRuleSet", "2010-12-01");
#[allow(unused_mut)]
let mut scope_276 = writer.prefix("RuleSetName");
if let Some(var_277) = &input.rule_set_name {
scope_276.string(var_277);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_set_identity_dkim_enabled(
input: &crate::input::SetIdentityDkimEnabledInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SetIdentityDkimEnabled", "2010-12-01");
#[allow(unused_mut)]
let mut scope_278 = writer.prefix("Identity");
if let Some(var_279) = &input.identity {
scope_278.string(var_279);
}
#[allow(unused_mut)]
let mut scope_280 = writer.prefix("DkimEnabled");
{
scope_280.boolean(input.dkim_enabled);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_set_identity_feedback_forwarding_enabled(
input: &crate::input::SetIdentityFeedbackForwardingEnabledInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"SetIdentityFeedbackForwardingEnabled",
"2010-12-01",
);
#[allow(unused_mut)]
let mut scope_281 = writer.prefix("Identity");
if let Some(var_282) = &input.identity {
scope_281.string(var_282);
}
#[allow(unused_mut)]
let mut scope_283 = writer.prefix("ForwardingEnabled");
{
scope_283.boolean(input.forwarding_enabled);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_set_identity_headers_in_notifications_enabled(
input: &crate::input::SetIdentityHeadersInNotificationsEnabledInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"SetIdentityHeadersInNotificationsEnabled",
"2010-12-01",
);
#[allow(unused_mut)]
let mut scope_284 = writer.prefix("Identity");
if let Some(var_285) = &input.identity {
scope_284.string(var_285);
}
#[allow(unused_mut)]
let mut scope_286 = writer.prefix("NotificationType");
if let Some(var_287) = &input.notification_type {
scope_286.string(var_287.as_str());
}
#[allow(unused_mut)]
let mut scope_288 = writer.prefix("Enabled");
{
scope_288.boolean(input.enabled);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_set_identity_mail_from_domain(
input: &crate::input::SetIdentityMailFromDomainInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SetIdentityMailFromDomain", "2010-12-01");
#[allow(unused_mut)]
let mut scope_289 = writer.prefix("Identity");
if let Some(var_290) = &input.identity {
scope_289.string(var_290);
}
#[allow(unused_mut)]
let mut scope_291 = writer.prefix("MailFromDomain");
if let Some(var_292) = &input.mail_from_domain {
scope_291.string(var_292);
}
#[allow(unused_mut)]
let mut scope_293 = writer.prefix("BehaviorOnMXFailure");
if let Some(var_294) = &input.behavior_on_mx_failure {
scope_293.string(var_294.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_set_identity_notification_topic(
input: &crate::input::SetIdentityNotificationTopicInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SetIdentityNotificationTopic", "2010-12-01");
#[allow(unused_mut)]
let mut scope_295 = writer.prefix("Identity");
if let Some(var_296) = &input.identity {
scope_295.string(var_296);
}
#[allow(unused_mut)]
let mut scope_297 = writer.prefix("NotificationType");
if let Some(var_298) = &input.notification_type {
scope_297.string(var_298.as_str());
}
#[allow(unused_mut)]
let mut scope_299 = writer.prefix("SnsTopic");
if let Some(var_300) = &input.sns_topic {
scope_299.string(var_300);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_set_receipt_rule_position(
input: &crate::input::SetReceiptRulePositionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SetReceiptRulePosition", "2010-12-01");
#[allow(unused_mut)]
let mut scope_301 = writer.prefix("RuleSetName");
if let Some(var_302) = &input.rule_set_name {
scope_301.string(var_302);
}
#[allow(unused_mut)]
let mut scope_303 = writer.prefix("RuleName");
if let Some(var_304) = &input.rule_name {
scope_303.string(var_304);
}
#[allow(unused_mut)]
let mut scope_305 = writer.prefix("After");
if let Some(var_306) = &input.after {
scope_305.string(var_306);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_test_render_template(
input: &crate::input::TestRenderTemplateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "TestRenderTemplate", "2010-12-01");
#[allow(unused_mut)]
let mut scope_307 = writer.prefix("TemplateName");
if let Some(var_308) = &input.template_name {
scope_307.string(var_308);
}
#[allow(unused_mut)]
let mut scope_309 = writer.prefix("TemplateData");
if let Some(var_310) = &input.template_data {
scope_309.string(var_310);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_account_sending_enabled(
input: &crate::input::UpdateAccountSendingEnabledInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UpdateAccountSendingEnabled", "2010-12-01");
#[allow(unused_mut)]
let mut scope_311 = writer.prefix("Enabled");
if input.enabled {
scope_311.boolean(input.enabled);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_configuration_set_event_destination(
input: &crate::input::UpdateConfigurationSetEventDestinationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"UpdateConfigurationSetEventDestination",
"2010-12-01",
);
#[allow(unused_mut)]
let mut scope_312 = writer.prefix("ConfigurationSetName");
if let Some(var_313) = &input.configuration_set_name {
scope_312.string(var_313);
}
#[allow(unused_mut)]
let mut scope_314 = writer.prefix("EventDestination");
if let Some(var_315) = &input.event_destination {
crate::query_ser::serialize_structure_crate_model_event_destination(scope_314, var_315)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_configuration_set_reputation_metrics_enabled(
input: &crate::input::UpdateConfigurationSetReputationMetricsEnabledInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"UpdateConfigurationSetReputationMetricsEnabled",
"2010-12-01",
);
#[allow(unused_mut)]
let mut scope_316 = writer.prefix("ConfigurationSetName");
if let Some(var_317) = &input.configuration_set_name {
scope_316.string(var_317);
}
#[allow(unused_mut)]
let mut scope_318 = writer.prefix("Enabled");
{
scope_318.boolean(input.enabled);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_configuration_set_sending_enabled(
input: &crate::input::UpdateConfigurationSetSendingEnabledInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"UpdateConfigurationSetSendingEnabled",
"2010-12-01",
);
#[allow(unused_mut)]
let mut scope_319 = writer.prefix("ConfigurationSetName");
if let Some(var_320) = &input.configuration_set_name {
scope_319.string(var_320);
}
#[allow(unused_mut)]
let mut scope_321 = writer.prefix("Enabled");
{
scope_321.boolean(input.enabled);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_configuration_set_tracking_options(
input: &crate::input::UpdateConfigurationSetTrackingOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"UpdateConfigurationSetTrackingOptions",
"2010-12-01",
);
#[allow(unused_mut)]
let mut scope_322 = writer.prefix("ConfigurationSetName");
if let Some(var_323) = &input.configuration_set_name {
scope_322.string(var_323);
}
#[allow(unused_mut)]
let mut scope_324 = writer.prefix("TrackingOptions");
if let Some(var_325) = &input.tracking_options {
crate::query_ser::serialize_structure_crate_model_tracking_options(scope_324, var_325)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_custom_verification_email_template(
input: &crate::input::UpdateCustomVerificationEmailTemplateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"UpdateCustomVerificationEmailTemplate",
"2010-12-01",
);
#[allow(unused_mut)]
let mut scope_326 = writer.prefix("TemplateName");
if let Some(var_327) = &input.template_name {
scope_326.string(var_327);
}
#[allow(unused_mut)]
let mut scope_328 = writer.prefix("FromEmailAddress");
if let Some(var_329) = &input.from_email_address {
scope_328.string(var_329);
}
#[allow(unused_mut)]
let mut scope_330 = writer.prefix("TemplateSubject");
if let Some(var_331) = &input.template_subject {
scope_330.string(var_331);
}
#[allow(unused_mut)]
let mut scope_332 = writer.prefix("TemplateContent");
if let Some(var_333) = &input.template_content {
scope_332.string(var_333);
}
#[allow(unused_mut)]
let mut scope_334 = writer.prefix("SuccessRedirectionURL");
if let Some(var_335) = &input.success_redirection_url {
scope_334.string(var_335);
}
#[allow(unused_mut)]
let mut scope_336 = writer.prefix("FailureRedirectionURL");
if let Some(var_337) = &input.failure_redirection_url {
scope_336.string(var_337);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_receipt_rule(
input: &crate::input::UpdateReceiptRuleInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UpdateReceiptRule", "2010-12-01");
#[allow(unused_mut)]
let mut scope_338 = writer.prefix("RuleSetName");
if let Some(var_339) = &input.rule_set_name {
scope_338.string(var_339);
}
#[allow(unused_mut)]
let mut scope_340 = writer.prefix("Rule");
if let Some(var_341) = &input.rule {
crate::query_ser::serialize_structure_crate_model_receipt_rule(scope_340, var_341)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_template(
input: &crate::input::UpdateTemplateInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "UpdateTemplate", "2010-12-01");
#[allow(unused_mut)]
let mut scope_342 = writer.prefix("Template");
if let Some(var_343) = &input.template {
crate::query_ser::serialize_structure_crate_model_template(scope_342, var_343)?;
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_verify_domain_dkim(
input: &crate::input::VerifyDomainDkimInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "VerifyDomainDkim", "2010-12-01");
#[allow(unused_mut)]
let mut scope_344 = writer.prefix("Domain");
if let Some(var_345) = &input.domain {
scope_344.string(var_345);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_verify_domain_identity(
input: &crate::input::VerifyDomainIdentityInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "VerifyDomainIdentity", "2010-12-01");
#[allow(unused_mut)]
let mut scope_346 = writer.prefix("Domain");
if let Some(var_347) = &input.domain {
scope_346.string(var_347);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_verify_email_address(
input: &crate::input::VerifyEmailAddressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "VerifyEmailAddress", "2010-12-01");
#[allow(unused_mut)]
let mut scope_348 = writer.prefix("EmailAddress");
if let Some(var_349) = &input.email_address {
scope_348.string(var_349);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_verify_email_identity(
input: &crate::input::VerifyEmailIdentityInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "VerifyEmailIdentity", "2010-12-01");
#[allow(unused_mut)]
let mut scope_350 = writer.prefix("EmailAddress");
if let Some(var_351) = &input.email_address {
scope_350.string(var_351);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}