pub fn serialize_structure_crate_input_batch_get_metric_data_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetMetricDataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.queries {
let mut array_2 = object.key("Queries").start_array();
for item_3 in var_1 {
{
#[allow(unused_mut)]
let mut object_4 = array_2.value().start_object();
crate::json_ser::serialize_structure_crate_model_batch_get_metric_data_query(
&mut object_4,
item_3,
)?;
object_4.finish();
}
}
array_2.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_configuration_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateConfigurationSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_5) = &input.configuration_set_name {
object.key("ConfigurationSetName").string(var_5.as_str());
}
if let Some(var_6) = &input.delivery_options {
#[allow(unused_mut)]
let mut object_7 = object.key("DeliveryOptions").start_object();
crate::json_ser::serialize_structure_crate_model_delivery_options(&mut object_7, var_6)?;
object_7.finish();
}
if let Some(var_8) = &input.reputation_options {
#[allow(unused_mut)]
let mut object_9 = object.key("ReputationOptions").start_object();
crate::json_ser::serialize_structure_crate_model_reputation_options(&mut object_9, var_8)?;
object_9.finish();
}
if let Some(var_10) = &input.sending_options {
#[allow(unused_mut)]
let mut object_11 = object.key("SendingOptions").start_object();
crate::json_ser::serialize_structure_crate_model_sending_options(&mut object_11, var_10)?;
object_11.finish();
}
if let Some(var_12) = &input.suppression_options {
#[allow(unused_mut)]
let mut object_13 = object.key("SuppressionOptions").start_object();
crate::json_ser::serialize_structure_crate_model_suppression_options(
&mut object_13,
var_12,
)?;
object_13.finish();
}
if let Some(var_14) = &input.tags {
let mut array_15 = object.key("Tags").start_array();
for item_16 in var_14 {
{
#[allow(unused_mut)]
let mut object_17 = array_15.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_17, item_16)?;
object_17.finish();
}
}
array_15.finish();
}
if let Some(var_18) = &input.tracking_options {
#[allow(unused_mut)]
let mut object_19 = object.key("TrackingOptions").start_object();
crate::json_ser::serialize_structure_crate_model_tracking_options(&mut object_19, var_18)?;
object_19.finish();
}
if let Some(var_20) = &input.vdm_options {
#[allow(unused_mut)]
let mut object_21 = object.key("VdmOptions").start_object();
crate::json_ser::serialize_structure_crate_model_vdm_options(&mut object_21, var_20)?;
object_21.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_configuration_set_event_destination_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateConfigurationSetEventDestinationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_22) = &input.event_destination {
#[allow(unused_mut)]
let mut object_23 = object.key("EventDestination").start_object();
crate::json_ser::serialize_structure_crate_model_event_destination_definition(
&mut object_23,
var_22,
)?;
object_23.finish();
}
if let Some(var_24) = &input.event_destination_name {
object.key("EventDestinationName").string(var_24.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_contact_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateContactInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_25) = &input.attributes_data {
object.key("AttributesData").string(var_25.as_str());
}
if let Some(var_26) = &input.email_address {
object.key("EmailAddress").string(var_26.as_str());
}
if let Some(var_27) = &input.topic_preferences {
let mut array_28 = object.key("TopicPreferences").start_array();
for item_29 in var_27 {
{
#[allow(unused_mut)]
let mut object_30 = array_28.value().start_object();
crate::json_ser::serialize_structure_crate_model_topic_preference(
&mut object_30,
item_29,
)?;
object_30.finish();
}
}
array_28.finish();
}
if input.unsubscribe_all {
object.key("UnsubscribeAll").boolean(input.unsubscribe_all);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_contact_list_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateContactListInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.contact_list_name {
object.key("ContactListName").string(var_31.as_str());
}
if let Some(var_32) = &input.description {
object.key("Description").string(var_32.as_str());
}
if let Some(var_33) = &input.tags {
let mut array_34 = object.key("Tags").start_array();
for item_35 in var_33 {
{
#[allow(unused_mut)]
let mut object_36 = array_34.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_36, item_35)?;
object_36.finish();
}
}
array_34.finish();
}
if let Some(var_37) = &input.topics {
let mut array_38 = object.key("Topics").start_array();
for item_39 in var_37 {
{
#[allow(unused_mut)]
let mut object_40 = array_38.value().start_object();
crate::json_ser::serialize_structure_crate_model_topic(&mut object_40, item_39)?;
object_40.finish();
}
}
array_38.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_custom_verification_email_template_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCustomVerificationEmailTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_41) = &input.failure_redirection_url {
object.key("FailureRedirectionURL").string(var_41.as_str());
}
if let Some(var_42) = &input.from_email_address {
object.key("FromEmailAddress").string(var_42.as_str());
}
if let Some(var_43) = &input.success_redirection_url {
object.key("SuccessRedirectionURL").string(var_43.as_str());
}
if let Some(var_44) = &input.template_content {
object.key("TemplateContent").string(var_44.as_str());
}
if let Some(var_45) = &input.template_name {
object.key("TemplateName").string(var_45.as_str());
}
if let Some(var_46) = &input.template_subject {
object.key("TemplateSubject").string(var_46.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_dedicated_ip_pool_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDedicatedIpPoolInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_47) = &input.pool_name {
object.key("PoolName").string(var_47.as_str());
}
if let Some(var_48) = &input.scaling_mode {
object.key("ScalingMode").string(var_48.as_str());
}
if let Some(var_49) = &input.tags {
let mut array_50 = object.key("Tags").start_array();
for item_51 in var_49 {
{
#[allow(unused_mut)]
let mut object_52 = array_50.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_52, item_51)?;
object_52.finish();
}
}
array_50.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_deliverability_test_report_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDeliverabilityTestReportInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_53) = &input.content {
#[allow(unused_mut)]
let mut object_54 = object.key("Content").start_object();
crate::json_ser::serialize_structure_crate_model_email_content(&mut object_54, var_53)?;
object_54.finish();
}
if let Some(var_55) = &input.from_email_address {
object.key("FromEmailAddress").string(var_55.as_str());
}
if let Some(var_56) = &input.report_name {
object.key("ReportName").string(var_56.as_str());
}
if let Some(var_57) = &input.tags {
let mut array_58 = object.key("Tags").start_array();
for item_59 in var_57 {
{
#[allow(unused_mut)]
let mut object_60 = array_58.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_60, item_59)?;
object_60.finish();
}
}
array_58.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_email_identity_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateEmailIdentityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_61) = &input.configuration_set_name {
object.key("ConfigurationSetName").string(var_61.as_str());
}
if let Some(var_62) = &input.dkim_signing_attributes {
#[allow(unused_mut)]
let mut object_63 = object.key("DkimSigningAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_dkim_signing_attributes(
&mut object_63,
var_62,
)?;
object_63.finish();
}
if let Some(var_64) = &input.email_identity {
object.key("EmailIdentity").string(var_64.as_str());
}
if let Some(var_65) = &input.tags {
let mut array_66 = object.key("Tags").start_array();
for item_67 in var_65 {
{
#[allow(unused_mut)]
let mut object_68 = array_66.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_68, item_67)?;
object_68.finish();
}
}
array_66.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_email_identity_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateEmailIdentityPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_69) = &input.policy {
object.key("Policy").string(var_69.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_email_template_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateEmailTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.template_content {
#[allow(unused_mut)]
let mut object_71 = object.key("TemplateContent").start_object();
crate::json_ser::serialize_structure_crate_model_email_template_content(
&mut object_71,
var_70,
)?;
object_71.finish();
}
if let Some(var_72) = &input.template_name {
object.key("TemplateName").string(var_72.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_import_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateImportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_73) = &input.import_data_source {
#[allow(unused_mut)]
let mut object_74 = object.key("ImportDataSource").start_object();
crate::json_ser::serialize_structure_crate_model_import_data_source(
&mut object_74,
var_73,
)?;
object_74.finish();
}
if let Some(var_75) = &input.import_destination {
#[allow(unused_mut)]
let mut object_76 = object.key("ImportDestination").start_object();
crate::json_ser::serialize_structure_crate_model_import_destination(
&mut object_76,
var_75,
)?;
object_76.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_contacts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListContactsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_77) = &input.filter {
#[allow(unused_mut)]
let mut object_78 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_list_contacts_filter(
&mut object_78,
var_77,
)?;
object_78.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_import_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListImportJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_79) = &input.import_destination_type {
object.key("ImportDestinationType").string(var_79.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_recommendations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListRecommendationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.filter {
#[allow(unused_mut)]
let mut object_81 = object.key("Filter").start_object();
for (key_82, value_83) in var_80 {
{
object_81.key(key_82.as_str()).string(value_83.as_str());
}
}
object_81.finish();
}
if let Some(var_84) = &input.next_token {
object.key("NextToken").string(var_84.as_str());
}
if let Some(var_85) = &input.page_size {
object.key("PageSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_85).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_account_dedicated_ip_warmup_attributes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutAccountDedicatedIpWarmupAttributesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.auto_warmup_enabled {
object
.key("AutoWarmupEnabled")
.boolean(input.auto_warmup_enabled);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_account_details_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutAccountDetailsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_86) = &input.additional_contact_email_addresses {
let mut array_87 = object.key("AdditionalContactEmailAddresses").start_array();
for item_88 in var_86 {
{
array_87.value().string(item_88.as_str());
}
}
array_87.finish();
}
if let Some(var_89) = &input.contact_language {
object.key("ContactLanguage").string(var_89.as_str());
}
if let Some(var_90) = &input.mail_type {
object.key("MailType").string(var_90.as_str());
}
if let Some(var_91) = &input.production_access_enabled {
object.key("ProductionAccessEnabled").boolean(*var_91);
}
if let Some(var_92) = &input.use_case_description {
object.key("UseCaseDescription").string(var_92.as_str());
}
if let Some(var_93) = &input.website_url {
object.key("WebsiteURL").string(var_93.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_account_sending_attributes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutAccountSendingAttributesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.sending_enabled {
object.key("SendingEnabled").boolean(input.sending_enabled);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_account_suppression_attributes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutAccountSuppressionAttributesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_94) = &input.suppressed_reasons {
let mut array_95 = object.key("SuppressedReasons").start_array();
for item_96 in var_94 {
{
array_95.value().string(item_96.as_str());
}
}
array_95.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_account_vdm_attributes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutAccountVdmAttributesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.vdm_attributes {
#[allow(unused_mut)]
let mut object_98 = object.key("VdmAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_vdm_attributes(&mut object_98, var_97)?;
object_98.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_configuration_set_delivery_options_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutConfigurationSetDeliveryOptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_99) = &input.sending_pool_name {
object.key("SendingPoolName").string(var_99.as_str());
}
if let Some(var_100) = &input.tls_policy {
object.key("TlsPolicy").string(var_100.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_configuration_set_reputation_options_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutConfigurationSetReputationOptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.reputation_metrics_enabled {
object
.key("ReputationMetricsEnabled")
.boolean(input.reputation_metrics_enabled);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_configuration_set_sending_options_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutConfigurationSetSendingOptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.sending_enabled {
object.key("SendingEnabled").boolean(input.sending_enabled);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_configuration_set_suppression_options_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutConfigurationSetSuppressionOptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.suppressed_reasons {
let mut array_102 = object.key("SuppressedReasons").start_array();
for item_103 in var_101 {
{
array_102.value().string(item_103.as_str());
}
}
array_102.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_configuration_set_tracking_options_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutConfigurationSetTrackingOptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_104) = &input.custom_redirect_domain {
object.key("CustomRedirectDomain").string(var_104.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_configuration_set_vdm_options_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutConfigurationSetVdmOptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_105) = &input.vdm_options {
#[allow(unused_mut)]
let mut object_106 = object.key("VdmOptions").start_object();
crate::json_ser::serialize_structure_crate_model_vdm_options(&mut object_106, var_105)?;
object_106.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_dedicated_ip_in_pool_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutDedicatedIpInPoolInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_107) = &input.destination_pool_name {
object.key("DestinationPoolName").string(var_107.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_dedicated_ip_warmup_attributes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutDedicatedIpWarmupAttributesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_108) = &input.warmup_percentage {
object.key("WarmupPercentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_108).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_deliverability_dashboard_option_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutDeliverabilityDashboardOptionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object
.key("DashboardEnabled")
.boolean(input.dashboard_enabled);
}
if let Some(var_109) = &input.subscribed_domains {
let mut array_110 = object.key("SubscribedDomains").start_array();
for item_111 in var_109 {
{
#[allow(unused_mut)]
let mut object_112 = array_110.value().start_object();
crate::json_ser::serialize_structure_crate_model_domain_deliverability_tracking_option(&mut object_112, item_111)?;
object_112.finish();
}
}
array_110.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_email_identity_configuration_set_attributes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutEmailIdentityConfigurationSetAttributesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_113) = &input.configuration_set_name {
object.key("ConfigurationSetName").string(var_113.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_email_identity_dkim_attributes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutEmailIdentityDkimAttributesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.signing_enabled {
object.key("SigningEnabled").boolean(input.signing_enabled);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_email_identity_dkim_signing_attributes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutEmailIdentityDkimSigningAttributesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_114) = &input.signing_attributes {
#[allow(unused_mut)]
let mut object_115 = object.key("SigningAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_dkim_signing_attributes(
&mut object_115,
var_114,
)?;
object_115.finish();
}
if let Some(var_116) = &input.signing_attributes_origin {
object
.key("SigningAttributesOrigin")
.string(var_116.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_email_identity_feedback_attributes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutEmailIdentityFeedbackAttributesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.email_forwarding_enabled {
object
.key("EmailForwardingEnabled")
.boolean(input.email_forwarding_enabled);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_email_identity_mail_from_attributes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutEmailIdentityMailFromAttributesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_117) = &input.behavior_on_mx_failure {
object.key("BehaviorOnMxFailure").string(var_117.as_str());
}
if let Some(var_118) = &input.mail_from_domain {
object.key("MailFromDomain").string(var_118.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_suppressed_destination_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutSuppressedDestinationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_119) = &input.email_address {
object.key("EmailAddress").string(var_119.as_str());
}
if let Some(var_120) = &input.reason {
object.key("Reason").string(var_120.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_send_bulk_email_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SendBulkEmailInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_121) = &input.bulk_email_entries {
let mut array_122 = object.key("BulkEmailEntries").start_array();
for item_123 in var_121 {
{
#[allow(unused_mut)]
let mut object_124 = array_122.value().start_object();
crate::json_ser::serialize_structure_crate_model_bulk_email_entry(
&mut object_124,
item_123,
)?;
object_124.finish();
}
}
array_122.finish();
}
if let Some(var_125) = &input.configuration_set_name {
object.key("ConfigurationSetName").string(var_125.as_str());
}
if let Some(var_126) = &input.default_content {
#[allow(unused_mut)]
let mut object_127 = object.key("DefaultContent").start_object();
crate::json_ser::serialize_structure_crate_model_bulk_email_content(
&mut object_127,
var_126,
)?;
object_127.finish();
}
if let Some(var_128) = &input.default_email_tags {
let mut array_129 = object.key("DefaultEmailTags").start_array();
for item_130 in var_128 {
{
#[allow(unused_mut)]
let mut object_131 = array_129.value().start_object();
crate::json_ser::serialize_structure_crate_model_message_tag(
&mut object_131,
item_130,
)?;
object_131.finish();
}
}
array_129.finish();
}
if let Some(var_132) = &input.feedback_forwarding_email_address {
object
.key("FeedbackForwardingEmailAddress")
.string(var_132.as_str());
}
if let Some(var_133) = &input.feedback_forwarding_email_address_identity_arn {
object
.key("FeedbackForwardingEmailAddressIdentityArn")
.string(var_133.as_str());
}
if let Some(var_134) = &input.from_email_address {
object.key("FromEmailAddress").string(var_134.as_str());
}
if let Some(var_135) = &input.from_email_address_identity_arn {
object
.key("FromEmailAddressIdentityArn")
.string(var_135.as_str());
}
if let Some(var_136) = &input.reply_to_addresses {
let mut array_137 = object.key("ReplyToAddresses").start_array();
for item_138 in var_136 {
{
array_137.value().string(item_138.as_str());
}
}
array_137.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_send_custom_verification_email_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SendCustomVerificationEmailInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_139) = &input.configuration_set_name {
object.key("ConfigurationSetName").string(var_139.as_str());
}
if let Some(var_140) = &input.email_address {
object.key("EmailAddress").string(var_140.as_str());
}
if let Some(var_141) = &input.template_name {
object.key("TemplateName").string(var_141.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_send_email_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SendEmailInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_142) = &input.configuration_set_name {
object.key("ConfigurationSetName").string(var_142.as_str());
}
if let Some(var_143) = &input.content {
#[allow(unused_mut)]
let mut object_144 = object.key("Content").start_object();
crate::json_ser::serialize_structure_crate_model_email_content(&mut object_144, var_143)?;
object_144.finish();
}
if let Some(var_145) = &input.destination {
#[allow(unused_mut)]
let mut object_146 = object.key("Destination").start_object();
crate::json_ser::serialize_structure_crate_model_destination(&mut object_146, var_145)?;
object_146.finish();
}
if let Some(var_147) = &input.email_tags {
let mut array_148 = object.key("EmailTags").start_array();
for item_149 in var_147 {
{
#[allow(unused_mut)]
let mut object_150 = array_148.value().start_object();
crate::json_ser::serialize_structure_crate_model_message_tag(
&mut object_150,
item_149,
)?;
object_150.finish();
}
}
array_148.finish();
}
if let Some(var_151) = &input.feedback_forwarding_email_address {
object
.key("FeedbackForwardingEmailAddress")
.string(var_151.as_str());
}
if let Some(var_152) = &input.feedback_forwarding_email_address_identity_arn {
object
.key("FeedbackForwardingEmailAddressIdentityArn")
.string(var_152.as_str());
}
if let Some(var_153) = &input.from_email_address {
object.key("FromEmailAddress").string(var_153.as_str());
}
if let Some(var_154) = &input.from_email_address_identity_arn {
object
.key("FromEmailAddressIdentityArn")
.string(var_154.as_str());
}
if let Some(var_155) = &input.list_management_options {
#[allow(unused_mut)]
let mut object_156 = object.key("ListManagementOptions").start_object();
crate::json_ser::serialize_structure_crate_model_list_management_options(
&mut object_156,
var_155,
)?;
object_156.finish();
}
if let Some(var_157) = &input.reply_to_addresses {
let mut array_158 = object.key("ReplyToAddresses").start_array();
for item_159 in var_157 {
{
array_158.value().string(item_159.as_str());
}
}
array_158.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_160) = &input.resource_arn {
object.key("ResourceArn").string(var_160.as_str());
}
if let Some(var_161) = &input.tags {
let mut array_162 = object.key("Tags").start_array();
for item_163 in var_161 {
{
#[allow(unused_mut)]
let mut object_164 = array_162.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_164, item_163)?;
object_164.finish();
}
}
array_162.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_test_render_email_template_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TestRenderEmailTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.template_data {
object.key("TemplateData").string(var_165.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_configuration_set_event_destination_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateConfigurationSetEventDestinationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_166) = &input.event_destination {
#[allow(unused_mut)]
let mut object_167 = object.key("EventDestination").start_object();
crate::json_ser::serialize_structure_crate_model_event_destination_definition(
&mut object_167,
var_166,
)?;
object_167.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_contact_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateContactInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_168) = &input.attributes_data {
object.key("AttributesData").string(var_168.as_str());
}
if let Some(var_169) = &input.topic_preferences {
let mut array_170 = object.key("TopicPreferences").start_array();
for item_171 in var_169 {
{
#[allow(unused_mut)]
let mut object_172 = array_170.value().start_object();
crate::json_ser::serialize_structure_crate_model_topic_preference(
&mut object_172,
item_171,
)?;
object_172.finish();
}
}
array_170.finish();
}
if input.unsubscribe_all {
object.key("UnsubscribeAll").boolean(input.unsubscribe_all);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_contact_list_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateContactListInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_173) = &input.description {
object.key("Description").string(var_173.as_str());
}
if let Some(var_174) = &input.topics {
let mut array_175 = object.key("Topics").start_array();
for item_176 in var_174 {
{
#[allow(unused_mut)]
let mut object_177 = array_175.value().start_object();
crate::json_ser::serialize_structure_crate_model_topic(&mut object_177, item_176)?;
object_177.finish();
}
}
array_175.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_custom_verification_email_template_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateCustomVerificationEmailTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_178) = &input.failure_redirection_url {
object.key("FailureRedirectionURL").string(var_178.as_str());
}
if let Some(var_179) = &input.from_email_address {
object.key("FromEmailAddress").string(var_179.as_str());
}
if let Some(var_180) = &input.success_redirection_url {
object.key("SuccessRedirectionURL").string(var_180.as_str());
}
if let Some(var_181) = &input.template_content {
object.key("TemplateContent").string(var_181.as_str());
}
if let Some(var_182) = &input.template_subject {
object.key("TemplateSubject").string(var_182.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_email_identity_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateEmailIdentityPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_183) = &input.policy {
object.key("Policy").string(var_183.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_email_template_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateEmailTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_184) = &input.template_content {
#[allow(unused_mut)]
let mut object_185 = object.key("TemplateContent").start_object();
crate::json_ser::serialize_structure_crate_model_email_template_content(
&mut object_185,
var_184,
)?;
object_185.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_batch_get_metric_data_query(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BatchGetMetricDataQuery,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_186) = &input.id {
object.key("Id").string(var_186.as_str());
}
if let Some(var_187) = &input.namespace {
object.key("Namespace").string(var_187.as_str());
}
if let Some(var_188) = &input.metric {
object.key("Metric").string(var_188.as_str());
}
if let Some(var_189) = &input.dimensions {
#[allow(unused_mut)]
let mut object_190 = object.key("Dimensions").start_object();
for (key_191, value_192) in var_189 {
{
object_190.key(key_191.as_str()).string(value_192.as_str());
}
}
object_190.finish();
}
if let Some(var_193) = &input.start_date {
object
.key("StartDate")
.date_time(var_193, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_194) = &input.end_date {
object
.key("EndDate")
.date_time(var_194, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_delivery_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeliveryOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_195) = &input.tls_policy {
object.key("TlsPolicy").string(var_195.as_str());
}
if let Some(var_196) = &input.sending_pool_name {
object.key("SendingPoolName").string(var_196.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_reputation_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReputationOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.reputation_metrics_enabled {
object
.key("ReputationMetricsEnabled")
.boolean(input.reputation_metrics_enabled);
}
if let Some(var_197) = &input.last_fresh_start {
object
.key("LastFreshStart")
.date_time(var_197, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_sending_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SendingOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.sending_enabled {
object.key("SendingEnabled").boolean(input.sending_enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_suppression_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SuppressionOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_198) = &input.suppressed_reasons {
let mut array_199 = object.key("SuppressedReasons").start_array();
for item_200 in var_198 {
{
array_199.value().string(item_200.as_str());
}
}
array_199.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_201) = &input.key {
object.key("Key").string(var_201.as_str());
}
if let Some(var_202) = &input.value {
object.key("Value").string(var_202.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tracking_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TrackingOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_203) = &input.custom_redirect_domain {
object.key("CustomRedirectDomain").string(var_203.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_vdm_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VdmOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_204) = &input.dashboard_options {
#[allow(unused_mut)]
let mut object_205 = object.key("DashboardOptions").start_object();
crate::json_ser::serialize_structure_crate_model_dashboard_options(
&mut object_205,
var_204,
)?;
object_205.finish();
}
if let Some(var_206) = &input.guardian_options {
#[allow(unused_mut)]
let mut object_207 = object.key("GuardianOptions").start_object();
crate::json_ser::serialize_structure_crate_model_guardian_options(
&mut object_207,
var_206,
)?;
object_207.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_event_destination_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EventDestinationDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enabled {
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_208) = &input.matching_event_types {
let mut array_209 = object.key("MatchingEventTypes").start_array();
for item_210 in var_208 {
{
array_209.value().string(item_210.as_str());
}
}
array_209.finish();
}
if let Some(var_211) = &input.kinesis_firehose_destination {
#[allow(unused_mut)]
let mut object_212 = object.key("KinesisFirehoseDestination").start_object();
crate::json_ser::serialize_structure_crate_model_kinesis_firehose_destination(
&mut object_212,
var_211,
)?;
object_212.finish();
}
if let Some(var_213) = &input.cloud_watch_destination {
#[allow(unused_mut)]
let mut object_214 = object.key("CloudWatchDestination").start_object();
crate::json_ser::serialize_structure_crate_model_cloud_watch_destination(
&mut object_214,
var_213,
)?;
object_214.finish();
}
if let Some(var_215) = &input.sns_destination {
#[allow(unused_mut)]
let mut object_216 = object.key("SnsDestination").start_object();
crate::json_ser::serialize_structure_crate_model_sns_destination(&mut object_216, var_215)?;
object_216.finish();
}
if let Some(var_217) = &input.pinpoint_destination {
#[allow(unused_mut)]
let mut object_218 = object.key("PinpointDestination").start_object();
crate::json_ser::serialize_structure_crate_model_pinpoint_destination(
&mut object_218,
var_217,
)?;
object_218.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_topic_preference(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TopicPreference,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_219) = &input.topic_name {
object.key("TopicName").string(var_219.as_str());
}
if let Some(var_220) = &input.subscription_status {
object.key("SubscriptionStatus").string(var_220.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_topic(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Topic,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_221) = &input.topic_name {
object.key("TopicName").string(var_221.as_str());
}
if let Some(var_222) = &input.display_name {
object.key("DisplayName").string(var_222.as_str());
}
if let Some(var_223) = &input.description {
object.key("Description").string(var_223.as_str());
}
if let Some(var_224) = &input.default_subscription_status {
object
.key("DefaultSubscriptionStatus")
.string(var_224.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_email_content(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EmailContent,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_225) = &input.simple {
#[allow(unused_mut)]
let mut object_226 = object.key("Simple").start_object();
crate::json_ser::serialize_structure_crate_model_message(&mut object_226, var_225)?;
object_226.finish();
}
if let Some(var_227) = &input.raw {
#[allow(unused_mut)]
let mut object_228 = object.key("Raw").start_object();
crate::json_ser::serialize_structure_crate_model_raw_message(&mut object_228, var_227)?;
object_228.finish();
}
if let Some(var_229) = &input.template {
#[allow(unused_mut)]
let mut object_230 = object.key("Template").start_object();
crate::json_ser::serialize_structure_crate_model_template(&mut object_230, var_229)?;
object_230.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_dkim_signing_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DkimSigningAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_231) = &input.domain_signing_selector {
object.key("DomainSigningSelector").string(var_231.as_str());
}
if let Some(var_232) = &input.domain_signing_private_key {
object
.key("DomainSigningPrivateKey")
.string(var_232.as_str());
}
if let Some(var_233) = &input.next_signing_key_length {
object.key("NextSigningKeyLength").string(var_233.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_email_template_content(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EmailTemplateContent,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_234) = &input.subject {
object.key("Subject").string(var_234.as_str());
}
if let Some(var_235) = &input.text {
object.key("Text").string(var_235.as_str());
}
if let Some(var_236) = &input.html {
object.key("Html").string(var_236.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_import_data_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImportDataSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_237) = &input.s3_url {
object.key("S3Url").string(var_237.as_str());
}
if let Some(var_238) = &input.data_format {
object.key("DataFormat").string(var_238.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_import_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImportDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_239) = &input.suppression_list_destination {
#[allow(unused_mut)]
let mut object_240 = object.key("SuppressionListDestination").start_object();
crate::json_ser::serialize_structure_crate_model_suppression_list_destination(
&mut object_240,
var_239,
)?;
object_240.finish();
}
if let Some(var_241) = &input.contact_list_destination {
#[allow(unused_mut)]
let mut object_242 = object.key("ContactListDestination").start_object();
crate::json_ser::serialize_structure_crate_model_contact_list_destination(
&mut object_242,
var_241,
)?;
object_242.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_list_contacts_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListContactsFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_243) = &input.filtered_status {
object.key("FilteredStatus").string(var_243.as_str());
}
if let Some(var_244) = &input.topic_filter {
#[allow(unused_mut)]
let mut object_245 = object.key("TopicFilter").start_object();
crate::json_ser::serialize_structure_crate_model_topic_filter(&mut object_245, var_244)?;
object_245.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_vdm_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VdmAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_246) = &input.vdm_enabled {
object.key("VdmEnabled").string(var_246.as_str());
}
if let Some(var_247) = &input.dashboard_attributes {
#[allow(unused_mut)]
let mut object_248 = object.key("DashboardAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_dashboard_attributes(
&mut object_248,
var_247,
)?;
object_248.finish();
}
if let Some(var_249) = &input.guardian_attributes {
#[allow(unused_mut)]
let mut object_250 = object.key("GuardianAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_guardian_attributes(
&mut object_250,
var_249,
)?;
object_250.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_domain_deliverability_tracking_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DomainDeliverabilityTrackingOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_251) = &input.domain {
object.key("Domain").string(var_251.as_str());
}
if let Some(var_252) = &input.subscription_start_date {
object
.key("SubscriptionStartDate")
.date_time(var_252, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_253) = &input.inbox_placement_tracking_option {
#[allow(unused_mut)]
let mut object_254 = object.key("InboxPlacementTrackingOption").start_object();
crate::json_ser::serialize_structure_crate_model_inbox_placement_tracking_option(
&mut object_254,
var_253,
)?;
object_254.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_bulk_email_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BulkEmailEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_255) = &input.destination {
#[allow(unused_mut)]
let mut object_256 = object.key("Destination").start_object();
crate::json_ser::serialize_structure_crate_model_destination(&mut object_256, var_255)?;
object_256.finish();
}
if let Some(var_257) = &input.replacement_tags {
let mut array_258 = object.key("ReplacementTags").start_array();
for item_259 in var_257 {
{
#[allow(unused_mut)]
let mut object_260 = array_258.value().start_object();
crate::json_ser::serialize_structure_crate_model_message_tag(
&mut object_260,
item_259,
)?;
object_260.finish();
}
}
array_258.finish();
}
if let Some(var_261) = &input.replacement_email_content {
#[allow(unused_mut)]
let mut object_262 = object.key("ReplacementEmailContent").start_object();
crate::json_ser::serialize_structure_crate_model_replacement_email_content(
&mut object_262,
var_261,
)?;
object_262.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_bulk_email_content(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BulkEmailContent,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_263) = &input.template {
#[allow(unused_mut)]
let mut object_264 = object.key("Template").start_object();
crate::json_ser::serialize_structure_crate_model_template(&mut object_264, var_263)?;
object_264.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_message_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MessageTag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_265) = &input.name {
object.key("Name").string(var_265.as_str());
}
if let Some(var_266) = &input.value {
object.key("Value").string(var_266.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Destination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_267) = &input.to_addresses {
let mut array_268 = object.key("ToAddresses").start_array();
for item_269 in var_267 {
{
array_268.value().string(item_269.as_str());
}
}
array_268.finish();
}
if let Some(var_270) = &input.cc_addresses {
let mut array_271 = object.key("CcAddresses").start_array();
for item_272 in var_270 {
{
array_271.value().string(item_272.as_str());
}
}
array_271.finish();
}
if let Some(var_273) = &input.bcc_addresses {
let mut array_274 = object.key("BccAddresses").start_array();
for item_275 in var_273 {
{
array_274.value().string(item_275.as_str());
}
}
array_274.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_list_management_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListManagementOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_276) = &input.contact_list_name {
object.key("ContactListName").string(var_276.as_str());
}
if let Some(var_277) = &input.topic_name {
object.key("TopicName").string(var_277.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dashboard_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DashboardOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_278) = &input.engagement_metrics {
object.key("EngagementMetrics").string(var_278.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_guardian_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GuardianOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_279) = &input.optimized_shared_delivery {
object
.key("OptimizedSharedDelivery")
.string(var_279.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_kinesis_firehose_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KinesisFirehoseDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_280) = &input.iam_role_arn {
object.key("IamRoleArn").string(var_280.as_str());
}
if let Some(var_281) = &input.delivery_stream_arn {
object.key("DeliveryStreamArn").string(var_281.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cloud_watch_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CloudWatchDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_282) = &input.dimension_configurations {
let mut array_283 = object.key("DimensionConfigurations").start_array();
for item_284 in var_282 {
{
#[allow(unused_mut)]
let mut object_285 = array_283.value().start_object();
crate::json_ser::serialize_structure_crate_model_cloud_watch_dimension_configuration(&mut object_285, item_284)?;
object_285.finish();
}
}
array_283.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sns_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SnsDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_286) = &input.topic_arn {
object.key("TopicArn").string(var_286.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_pinpoint_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PinpointDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_287) = &input.application_arn {
object.key("ApplicationArn").string(var_287.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Message,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_288) = &input.subject {
#[allow(unused_mut)]
let mut object_289 = object.key("Subject").start_object();
crate::json_ser::serialize_structure_crate_model_content(&mut object_289, var_288)?;
object_289.finish();
}
if let Some(var_290) = &input.body {
#[allow(unused_mut)]
let mut object_291 = object.key("Body").start_object();
crate::json_ser::serialize_structure_crate_model_body(&mut object_291, var_290)?;
object_291.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_raw_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RawMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_292) = &input.data {
object
.key("Data")
.string_unchecked(&aws_smithy_types::base64::encode(var_292));
}
Ok(())
}
pub fn serialize_structure_crate_model_template(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Template,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_293) = &input.template_name {
object.key("TemplateName").string(var_293.as_str());
}
if let Some(var_294) = &input.template_arn {
object.key("TemplateArn").string(var_294.as_str());
}
if let Some(var_295) = &input.template_data {
object.key("TemplateData").string(var_295.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_suppression_list_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SuppressionListDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_296) = &input.suppression_list_import_action {
object
.key("SuppressionListImportAction")
.string(var_296.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_contact_list_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContactListDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_297) = &input.contact_list_name {
object.key("ContactListName").string(var_297.as_str());
}
if let Some(var_298) = &input.contact_list_import_action {
object
.key("ContactListImportAction")
.string(var_298.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_topic_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TopicFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_299) = &input.topic_name {
object.key("TopicName").string(var_299.as_str());
}
if input.use_default_if_preference_unavailable {
object
.key("UseDefaultIfPreferenceUnavailable")
.boolean(input.use_default_if_preference_unavailable);
}
Ok(())
}
pub fn serialize_structure_crate_model_dashboard_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DashboardAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_300) = &input.engagement_metrics {
object.key("EngagementMetrics").string(var_300.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_guardian_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GuardianAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_301) = &input.optimized_shared_delivery {
object
.key("OptimizedSharedDelivery")
.string(var_301.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_inbox_placement_tracking_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InboxPlacementTrackingOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.global {
object.key("Global").boolean(input.global);
}
if let Some(var_302) = &input.tracked_isps {
let mut array_303 = object.key("TrackedIsps").start_array();
for item_304 in var_302 {
{
array_303.value().string(item_304.as_str());
}
}
array_303.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_replacement_email_content(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReplacementEmailContent,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_305) = &input.replacement_template {
#[allow(unused_mut)]
let mut object_306 = object.key("ReplacementTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_replacement_template(
&mut object_306,
var_305,
)?;
object_306.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_cloud_watch_dimension_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CloudWatchDimensionConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_307) = &input.dimension_name {
object.key("DimensionName").string(var_307.as_str());
}
if let Some(var_308) = &input.dimension_value_source {
object.key("DimensionValueSource").string(var_308.as_str());
}
if let Some(var_309) = &input.default_dimension_value {
object.key("DefaultDimensionValue").string(var_309.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_content(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Content,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_310) = &input.data {
object.key("Data").string(var_310.as_str());
}
if let Some(var_311) = &input.charset {
object.key("Charset").string(var_311.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_body(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Body,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_312) = &input.text {
#[allow(unused_mut)]
let mut object_313 = object.key("Text").start_object();
crate::json_ser::serialize_structure_crate_model_content(&mut object_313, var_312)?;
object_313.finish();
}
if let Some(var_314) = &input.html {
#[allow(unused_mut)]
let mut object_315 = object.key("Html").start_object();
crate::json_ser::serialize_structure_crate_model_content(&mut object_315, var_314)?;
object_315.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_replacement_template(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReplacementTemplate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_316) = &input.replacement_template_data {
object
.key("ReplacementTemplateData")
.string(var_316.as_str());
}
Ok(())
}