#[allow(unused_mut)]
pub fn serialize_structure_crate_model_configuration_set(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ConfigurationSet,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_1 = writer.prefix("Name");
if let Some(var_2) = &input.name {
scope_1.string(var_2);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_event_destination(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::EventDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_3 = writer.prefix("Name");
if let Some(var_4) = &input.name {
scope_3.string(var_4);
}
#[allow(unused_mut)]
let mut scope_5 = writer.prefix("Enabled");
if input.enabled {
scope_5.boolean(input.enabled);
}
#[allow(unused_mut)]
let mut scope_6 = writer.prefix("MatchingEventTypes");
if let Some(var_7) = &input.matching_event_types {
let mut list_9 = scope_6.start_list(false, None);
for item_8 in var_7 {
#[allow(unused_mut)]
let mut entry_10 = list_9.entry();
entry_10.string(item_8.as_str());
}
list_9.finish();
}
#[allow(unused_mut)]
let mut scope_11 = writer.prefix("KinesisFirehoseDestination");
if let Some(var_12) = &input.kinesis_firehose_destination {
crate::query_ser::serialize_structure_crate_model_kinesis_firehose_destination(
scope_11, var_12,
)?;
}
#[allow(unused_mut)]
let mut scope_13 = writer.prefix("CloudWatchDestination");
if let Some(var_14) = &input.cloud_watch_destination {
crate::query_ser::serialize_structure_crate_model_cloud_watch_destination(
scope_13, var_14,
)?;
}
#[allow(unused_mut)]
let mut scope_15 = writer.prefix("SNSDestination");
if let Some(var_16) = &input.sns_destination {
crate::query_ser::serialize_structure_crate_model_sns_destination(scope_15, var_16)?;
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_tracking_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TrackingOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_17 = writer.prefix("CustomRedirectDomain");
if let Some(var_18) = &input.custom_redirect_domain {
scope_17.string(var_18);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_receipt_filter(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ReceiptFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_19 = writer.prefix("Name");
if let Some(var_20) = &input.name {
scope_19.string(var_20);
}
#[allow(unused_mut)]
let mut scope_21 = writer.prefix("IpFilter");
if let Some(var_22) = &input.ip_filter {
crate::query_ser::serialize_structure_crate_model_receipt_ip_filter(scope_21, var_22)?;
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_receipt_rule(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ReceiptRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_23 = writer.prefix("Name");
if let Some(var_24) = &input.name {
scope_23.string(var_24);
}
#[allow(unused_mut)]
let mut scope_25 = writer.prefix("Enabled");
if input.enabled {
scope_25.boolean(input.enabled);
}
#[allow(unused_mut)]
let mut scope_26 = writer.prefix("TlsPolicy");
if let Some(var_27) = &input.tls_policy {
scope_26.string(var_27.as_str());
}
#[allow(unused_mut)]
let mut scope_28 = writer.prefix("Recipients");
if let Some(var_29) = &input.recipients {
let mut list_31 = scope_28.start_list(false, None);
for item_30 in var_29 {
#[allow(unused_mut)]
let mut entry_32 = list_31.entry();
entry_32.string(item_30);
}
list_31.finish();
}
#[allow(unused_mut)]
let mut scope_33 = writer.prefix("Actions");
if let Some(var_34) = &input.actions {
let mut list_36 = scope_33.start_list(false, None);
for item_35 in var_34 {
#[allow(unused_mut)]
let mut entry_37 = list_36.entry();
crate::query_ser::serialize_structure_crate_model_receipt_action(entry_37, item_35)?;
}
list_36.finish();
}
#[allow(unused_mut)]
let mut scope_38 = writer.prefix("ScanEnabled");
if input.scan_enabled {
scope_38.boolean(input.scan_enabled);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_template(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Template,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_39 = writer.prefix("TemplateName");
if let Some(var_40) = &input.template_name {
scope_39.string(var_40);
}
#[allow(unused_mut)]
let mut scope_41 = writer.prefix("SubjectPart");
if let Some(var_42) = &input.subject_part {
scope_41.string(var_42);
}
#[allow(unused_mut)]
let mut scope_43 = writer.prefix("TextPart");
if let Some(var_44) = &input.text_part {
scope_43.string(var_44);
}
#[allow(unused_mut)]
let mut scope_45 = writer.prefix("HtmlPart");
if let Some(var_46) = &input.html_part {
scope_45.string(var_46);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_delivery_options(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::DeliveryOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_47 = writer.prefix("TlsPolicy");
if let Some(var_48) = &input.tls_policy {
scope_47.string(var_48.as_str());
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_message_dsn(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::MessageDsn,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_49 = writer.prefix("ReportingMta");
if let Some(var_50) = &input.reporting_mta {
scope_49.string(var_50);
}
#[allow(unused_mut)]
let mut scope_51 = writer.prefix("ArrivalDate");
if let Some(var_52) = &input.arrival_date {
scope_51.date_time(var_52, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_53 = writer.prefix("ExtensionFields");
if let Some(var_54) = &input.extension_fields {
let mut list_56 = scope_53.start_list(false, None);
for item_55 in var_54 {
#[allow(unused_mut)]
let mut entry_57 = list_56.entry();
crate::query_ser::serialize_structure_crate_model_extension_field(entry_57, item_55)?;
}
list_56.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_bounced_recipient_info(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::BouncedRecipientInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_58 = writer.prefix("Recipient");
if let Some(var_59) = &input.recipient {
scope_58.string(var_59);
}
#[allow(unused_mut)]
let mut scope_60 = writer.prefix("RecipientArn");
if let Some(var_61) = &input.recipient_arn {
scope_60.string(var_61);
}
#[allow(unused_mut)]
let mut scope_62 = writer.prefix("BounceType");
if let Some(var_63) = &input.bounce_type {
scope_62.string(var_63.as_str());
}
#[allow(unused_mut)]
let mut scope_64 = writer.prefix("RecipientDsnFields");
if let Some(var_65) = &input.recipient_dsn_fields {
crate::query_ser::serialize_structure_crate_model_recipient_dsn_fields(scope_64, var_65)?;
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_message_tag(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::MessageTag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_66 = writer.prefix("Name");
if let Some(var_67) = &input.name {
scope_66.string(var_67);
}
#[allow(unused_mut)]
let mut scope_68 = writer.prefix("Value");
if let Some(var_69) = &input.value {
scope_68.string(var_69);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_bulk_email_destination(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::BulkEmailDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_70 = writer.prefix("Destination");
if let Some(var_71) = &input.destination {
crate::query_ser::serialize_structure_crate_model_destination(scope_70, var_71)?;
}
#[allow(unused_mut)]
let mut scope_72 = writer.prefix("ReplacementTags");
if let Some(var_73) = &input.replacement_tags {
let mut list_75 = scope_72.start_list(false, None);
for item_74 in var_73 {
#[allow(unused_mut)]
let mut entry_76 = list_75.entry();
crate::query_ser::serialize_structure_crate_model_message_tag(entry_76, item_74)?;
}
list_75.finish();
}
#[allow(unused_mut)]
let mut scope_77 = writer.prefix("ReplacementTemplateData");
if let Some(var_78) = &input.replacement_template_data {
scope_77.string(var_78);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_destination(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Destination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_79 = writer.prefix("ToAddresses");
if let Some(var_80) = &input.to_addresses {
let mut list_82 = scope_79.start_list(false, None);
for item_81 in var_80 {
#[allow(unused_mut)]
let mut entry_83 = list_82.entry();
entry_83.string(item_81);
}
list_82.finish();
}
#[allow(unused_mut)]
let mut scope_84 = writer.prefix("CcAddresses");
if let Some(var_85) = &input.cc_addresses {
let mut list_87 = scope_84.start_list(false, None);
for item_86 in var_85 {
#[allow(unused_mut)]
let mut entry_88 = list_87.entry();
entry_88.string(item_86);
}
list_87.finish();
}
#[allow(unused_mut)]
let mut scope_89 = writer.prefix("BccAddresses");
if let Some(var_90) = &input.bcc_addresses {
let mut list_92 = scope_89.start_list(false, None);
for item_91 in var_90 {
#[allow(unused_mut)]
let mut entry_93 = list_92.entry();
entry_93.string(item_91);
}
list_92.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_message(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Message,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_94 = writer.prefix("Subject");
if let Some(var_95) = &input.subject {
crate::query_ser::serialize_structure_crate_model_content(scope_94, var_95)?;
}
#[allow(unused_mut)]
let mut scope_96 = writer.prefix("Body");
if let Some(var_97) = &input.body {
crate::query_ser::serialize_structure_crate_model_body(scope_96, var_97)?;
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_raw_message(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::RawMessage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_98 = writer.prefix("Data");
if let Some(var_99) = &input.data {
scope_98.string(&aws_smithy_types::base64::encode(var_99));
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_kinesis_firehose_destination(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::KinesisFirehoseDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_100 = writer.prefix("IAMRoleARN");
if let Some(var_101) = &input.iam_role_arn {
scope_100.string(var_101);
}
#[allow(unused_mut)]
let mut scope_102 = writer.prefix("DeliveryStreamARN");
if let Some(var_103) = &input.delivery_stream_arn {
scope_102.string(var_103);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_cloud_watch_destination(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::CloudWatchDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_104 = writer.prefix("DimensionConfigurations");
if let Some(var_105) = &input.dimension_configurations {
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();
crate::query_ser::serialize_structure_crate_model_cloud_watch_dimension_configuration(
entry_108, item_106,
)?;
}
list_107.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_sns_destination(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SnsDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_109 = writer.prefix("TopicARN");
if let Some(var_110) = &input.topic_arn {
scope_109.string(var_110);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_receipt_ip_filter(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ReceiptIpFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_111 = writer.prefix("Policy");
if let Some(var_112) = &input.policy {
scope_111.string(var_112.as_str());
}
#[allow(unused_mut)]
let mut scope_113 = writer.prefix("Cidr");
if let Some(var_114) = &input.cidr {
scope_113.string(var_114);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_receipt_action(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ReceiptAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_115 = writer.prefix("S3Action");
if let Some(var_116) = &input.s3_action {
crate::query_ser::serialize_structure_crate_model_s3_action(scope_115, var_116)?;
}
#[allow(unused_mut)]
let mut scope_117 = writer.prefix("BounceAction");
if let Some(var_118) = &input.bounce_action {
crate::query_ser::serialize_structure_crate_model_bounce_action(scope_117, var_118)?;
}
#[allow(unused_mut)]
let mut scope_119 = writer.prefix("WorkmailAction");
if let Some(var_120) = &input.workmail_action {
crate::query_ser::serialize_structure_crate_model_workmail_action(scope_119, var_120)?;
}
#[allow(unused_mut)]
let mut scope_121 = writer.prefix("LambdaAction");
if let Some(var_122) = &input.lambda_action {
crate::query_ser::serialize_structure_crate_model_lambda_action(scope_121, var_122)?;
}
#[allow(unused_mut)]
let mut scope_123 = writer.prefix("StopAction");
if let Some(var_124) = &input.stop_action {
crate::query_ser::serialize_structure_crate_model_stop_action(scope_123, var_124)?;
}
#[allow(unused_mut)]
let mut scope_125 = writer.prefix("AddHeaderAction");
if let Some(var_126) = &input.add_header_action {
crate::query_ser::serialize_structure_crate_model_add_header_action(scope_125, var_126)?;
}
#[allow(unused_mut)]
let mut scope_127 = writer.prefix("SNSAction");
if let Some(var_128) = &input.sns_action {
crate::query_ser::serialize_structure_crate_model_sns_action(scope_127, var_128)?;
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_extension_field(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ExtensionField,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_129 = writer.prefix("Name");
if let Some(var_130) = &input.name {
scope_129.string(var_130);
}
#[allow(unused_mut)]
let mut scope_131 = writer.prefix("Value");
if let Some(var_132) = &input.value {
scope_131.string(var_132);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_recipient_dsn_fields(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::RecipientDsnFields,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_133 = writer.prefix("FinalRecipient");
if let Some(var_134) = &input.final_recipient {
scope_133.string(var_134);
}
#[allow(unused_mut)]
let mut scope_135 = writer.prefix("Action");
if let Some(var_136) = &input.action {
scope_135.string(var_136.as_str());
}
#[allow(unused_mut)]
let mut scope_137 = writer.prefix("RemoteMta");
if let Some(var_138) = &input.remote_mta {
scope_137.string(var_138);
}
#[allow(unused_mut)]
let mut scope_139 = writer.prefix("Status");
if let Some(var_140) = &input.status {
scope_139.string(var_140);
}
#[allow(unused_mut)]
let mut scope_141 = writer.prefix("DiagnosticCode");
if let Some(var_142) = &input.diagnostic_code {
scope_141.string(var_142);
}
#[allow(unused_mut)]
let mut scope_143 = writer.prefix("LastAttemptDate");
if let Some(var_144) = &input.last_attempt_date {
scope_143.date_time(var_144, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_145 = writer.prefix("ExtensionFields");
if let Some(var_146) = &input.extension_fields {
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();
crate::query_ser::serialize_structure_crate_model_extension_field(entry_149, item_147)?;
}
list_148.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_content(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Content,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_150 = writer.prefix("Data");
if let Some(var_151) = &input.data {
scope_150.string(var_151);
}
#[allow(unused_mut)]
let mut scope_152 = writer.prefix("Charset");
if let Some(var_153) = &input.charset {
scope_152.string(var_153);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_body(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Body,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_154 = writer.prefix("Text");
if let Some(var_155) = &input.text {
crate::query_ser::serialize_structure_crate_model_content(scope_154, var_155)?;
}
#[allow(unused_mut)]
let mut scope_156 = writer.prefix("Html");
if let Some(var_157) = &input.html {
crate::query_ser::serialize_structure_crate_model_content(scope_156, var_157)?;
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_cloud_watch_dimension_configuration(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::CloudWatchDimensionConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_158 = writer.prefix("DimensionName");
if let Some(var_159) = &input.dimension_name {
scope_158.string(var_159);
}
#[allow(unused_mut)]
let mut scope_160 = writer.prefix("DimensionValueSource");
if let Some(var_161) = &input.dimension_value_source {
scope_160.string(var_161.as_str());
}
#[allow(unused_mut)]
let mut scope_162 = writer.prefix("DefaultDimensionValue");
if let Some(var_163) = &input.default_dimension_value {
scope_162.string(var_163);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_s3_action(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::S3Action,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_164 = writer.prefix("TopicArn");
if let Some(var_165) = &input.topic_arn {
scope_164.string(var_165);
}
#[allow(unused_mut)]
let mut scope_166 = writer.prefix("BucketName");
if let Some(var_167) = &input.bucket_name {
scope_166.string(var_167);
}
#[allow(unused_mut)]
let mut scope_168 = writer.prefix("ObjectKeyPrefix");
if let Some(var_169) = &input.object_key_prefix {
scope_168.string(var_169);
}
#[allow(unused_mut)]
let mut scope_170 = writer.prefix("KmsKeyArn");
if let Some(var_171) = &input.kms_key_arn {
scope_170.string(var_171);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_bounce_action(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::BounceAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_172 = writer.prefix("TopicArn");
if let Some(var_173) = &input.topic_arn {
scope_172.string(var_173);
}
#[allow(unused_mut)]
let mut scope_174 = writer.prefix("SmtpReplyCode");
if let Some(var_175) = &input.smtp_reply_code {
scope_174.string(var_175);
}
#[allow(unused_mut)]
let mut scope_176 = writer.prefix("StatusCode");
if let Some(var_177) = &input.status_code {
scope_176.string(var_177);
}
#[allow(unused_mut)]
let mut scope_178 = writer.prefix("Message");
if let Some(var_179) = &input.message {
scope_178.string(var_179);
}
#[allow(unused_mut)]
let mut scope_180 = writer.prefix("Sender");
if let Some(var_181) = &input.sender {
scope_180.string(var_181);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_workmail_action(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::WorkmailAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_182 = writer.prefix("TopicArn");
if let Some(var_183) = &input.topic_arn {
scope_182.string(var_183);
}
#[allow(unused_mut)]
let mut scope_184 = writer.prefix("OrganizationArn");
if let Some(var_185) = &input.organization_arn {
scope_184.string(var_185);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_lambda_action(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LambdaAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_186 = writer.prefix("TopicArn");
if let Some(var_187) = &input.topic_arn {
scope_186.string(var_187);
}
#[allow(unused_mut)]
let mut scope_188 = writer.prefix("FunctionArn");
if let Some(var_189) = &input.function_arn {
scope_188.string(var_189);
}
#[allow(unused_mut)]
let mut scope_190 = writer.prefix("InvocationType");
if let Some(var_191) = &input.invocation_type {
scope_190.string(var_191.as_str());
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_stop_action(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::StopAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_192 = writer.prefix("Scope");
if let Some(var_193) = &input.scope {
scope_192.string(var_193.as_str());
}
#[allow(unused_mut)]
let mut scope_194 = writer.prefix("TopicArn");
if let Some(var_195) = &input.topic_arn {
scope_194.string(var_195);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_add_header_action(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::AddHeaderAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_196 = writer.prefix("HeaderName");
if let Some(var_197) = &input.header_name {
scope_196.string(var_197);
}
#[allow(unused_mut)]
let mut scope_198 = writer.prefix("HeaderValue");
if let Some(var_199) = &input.header_value {
scope_198.string(var_199);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_sns_action(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SnsAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_200 = writer.prefix("TopicArn");
if let Some(var_201) = &input.topic_arn {
scope_200.string(var_201);
}
#[allow(unused_mut)]
let mut scope_202 = writer.prefix("Encoding");
if let Some(var_203) = &input.encoding {
scope_202.string(var_203.as_str());
}
Ok(())
}