pub fn serialize_structure_crate_input_associate_firewall_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateFirewallPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.update_token {
object.key("UpdateToken").string(var_1.as_str());
}
if let Some(var_2) = &input.firewall_arn {
object.key("FirewallArn").string(var_2.as_str());
}
if let Some(var_3) = &input.firewall_name {
object.key("FirewallName").string(var_3.as_str());
}
if let Some(var_4) = &input.firewall_policy_arn {
object.key("FirewallPolicyArn").string(var_4.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_subnets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateSubnetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_5) = &input.update_token {
object.key("UpdateToken").string(var_5.as_str());
}
if let Some(var_6) = &input.firewall_arn {
object.key("FirewallArn").string(var_6.as_str());
}
if let Some(var_7) = &input.firewall_name {
object.key("FirewallName").string(var_7.as_str());
}
if let Some(var_8) = &input.subnet_mappings {
let mut array_9 = object.key("SubnetMappings").start_array();
for item_10 in var_8 {
{
#[allow(unused_mut)]
let mut object_11 = array_9.value().start_object();
crate::json_ser::serialize_structure_crate_model_subnet_mapping(
&mut object_11,
item_10,
)?;
object_11.finish();
}
}
array_9.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_firewall_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFirewallInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.firewall_name {
object.key("FirewallName").string(var_12.as_str());
}
if let Some(var_13) = &input.firewall_policy_arn {
object.key("FirewallPolicyArn").string(var_13.as_str());
}
if let Some(var_14) = &input.vpc_id {
object.key("VpcId").string(var_14.as_str());
}
if let Some(var_15) = &input.subnet_mappings {
let mut array_16 = object.key("SubnetMappings").start_array();
for item_17 in var_15 {
{
#[allow(unused_mut)]
let mut object_18 = array_16.value().start_object();
crate::json_ser::serialize_structure_crate_model_subnet_mapping(
&mut object_18,
item_17,
)?;
object_18.finish();
}
}
array_16.finish();
}
if input.delete_protection {
object
.key("DeleteProtection")
.boolean(input.delete_protection);
}
if input.subnet_change_protection {
object
.key("SubnetChangeProtection")
.boolean(input.subnet_change_protection);
}
if input.firewall_policy_change_protection {
object
.key("FirewallPolicyChangeProtection")
.boolean(input.firewall_policy_change_protection);
}
if let Some(var_19) = &input.description {
object.key("Description").string(var_19.as_str());
}
if let Some(var_20) = &input.tags {
let mut array_21 = object.key("Tags").start_array();
for item_22 in var_20 {
{
#[allow(unused_mut)]
let mut object_23 = array_21.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_23, item_22)?;
object_23.finish();
}
}
array_21.finish();
}
if let Some(var_24) = &input.encryption_configuration {
#[allow(unused_mut)]
let mut object_25 = object.key("EncryptionConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_configuration(
&mut object_25,
var_24,
)?;
object_25.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_firewall_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFirewallPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_26) = &input.firewall_policy_name {
object.key("FirewallPolicyName").string(var_26.as_str());
}
if let Some(var_27) = &input.firewall_policy {
#[allow(unused_mut)]
let mut object_28 = object.key("FirewallPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_firewall_policy(&mut object_28, var_27)?;
object_28.finish();
}
if let Some(var_29) = &input.description {
object.key("Description").string(var_29.as_str());
}
if let Some(var_30) = &input.tags {
let mut array_31 = object.key("Tags").start_array();
for item_32 in var_30 {
{
#[allow(unused_mut)]
let mut object_33 = array_31.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_33, item_32)?;
object_33.finish();
}
}
array_31.finish();
}
if input.dry_run {
object.key("DryRun").boolean(input.dry_run);
}
if let Some(var_34) = &input.encryption_configuration {
#[allow(unused_mut)]
let mut object_35 = object.key("EncryptionConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_configuration(
&mut object_35,
var_34,
)?;
object_35.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_rule_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateRuleGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_36) = &input.rule_group_name {
object.key("RuleGroupName").string(var_36.as_str());
}
if let Some(var_37) = &input.rule_group {
#[allow(unused_mut)]
let mut object_38 = object.key("RuleGroup").start_object();
crate::json_ser::serialize_structure_crate_model_rule_group(&mut object_38, var_37)?;
object_38.finish();
}
if let Some(var_39) = &input.rules {
object.key("Rules").string(var_39.as_str());
}
if let Some(var_40) = &input.r#type {
object.key("Type").string(var_40.as_str());
}
if let Some(var_41) = &input.description {
object.key("Description").string(var_41.as_str());
}
if let Some(var_42) = &input.capacity {
object.key("Capacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_42).into()),
);
}
if let Some(var_43) = &input.tags {
let mut array_44 = object.key("Tags").start_array();
for item_45 in var_43 {
{
#[allow(unused_mut)]
let mut object_46 = array_44.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_46, item_45)?;
object_46.finish();
}
}
array_44.finish();
}
if input.dry_run {
object.key("DryRun").boolean(input.dry_run);
}
if let Some(var_47) = &input.encryption_configuration {
#[allow(unused_mut)]
let mut object_48 = object.key("EncryptionConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_configuration(
&mut object_48,
var_47,
)?;
object_48.finish();
}
if let Some(var_49) = &input.source_metadata {
#[allow(unused_mut)]
let mut object_50 = object.key("SourceMetadata").start_object();
crate::json_ser::serialize_structure_crate_model_source_metadata(&mut object_50, var_49)?;
object_50.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_firewall_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteFirewallInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_51) = &input.firewall_name {
object.key("FirewallName").string(var_51.as_str());
}
if let Some(var_52) = &input.firewall_arn {
object.key("FirewallArn").string(var_52.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_firewall_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteFirewallPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_53) = &input.firewall_policy_name {
object.key("FirewallPolicyName").string(var_53.as_str());
}
if let Some(var_54) = &input.firewall_policy_arn {
object.key("FirewallPolicyArn").string(var_54.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteResourcePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_55) = &input.resource_arn {
object.key("ResourceArn").string(var_55.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_rule_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteRuleGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.rule_group_name {
object.key("RuleGroupName").string(var_56.as_str());
}
if let Some(var_57) = &input.rule_group_arn {
object.key("RuleGroupArn").string(var_57.as_str());
}
if let Some(var_58) = &input.r#type {
object.key("Type").string(var_58.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_firewall_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFirewallInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_59) = &input.firewall_name {
object.key("FirewallName").string(var_59.as_str());
}
if let Some(var_60) = &input.firewall_arn {
object.key("FirewallArn").string(var_60.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_firewall_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFirewallPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_61) = &input.firewall_policy_name {
object.key("FirewallPolicyName").string(var_61.as_str());
}
if let Some(var_62) = &input.firewall_policy_arn {
object.key("FirewallPolicyArn").string(var_62.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_logging_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeLoggingConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_63) = &input.firewall_arn {
object.key("FirewallArn").string(var_63.as_str());
}
if let Some(var_64) = &input.firewall_name {
object.key("FirewallName").string(var_64.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeResourcePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_65) = &input.resource_arn {
object.key("ResourceArn").string(var_65.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_rule_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeRuleGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.rule_group_name {
object.key("RuleGroupName").string(var_66.as_str());
}
if let Some(var_67) = &input.rule_group_arn {
object.key("RuleGroupArn").string(var_67.as_str());
}
if let Some(var_68) = &input.r#type {
object.key("Type").string(var_68.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_rule_group_metadata_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeRuleGroupMetadataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_69) = &input.rule_group_name {
object.key("RuleGroupName").string(var_69.as_str());
}
if let Some(var_70) = &input.rule_group_arn {
object.key("RuleGroupArn").string(var_70.as_str());
}
if let Some(var_71) = &input.r#type {
object.key("Type").string(var_71.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_subnets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateSubnetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_72) = &input.update_token {
object.key("UpdateToken").string(var_72.as_str());
}
if let Some(var_73) = &input.firewall_arn {
object.key("FirewallArn").string(var_73.as_str());
}
if let Some(var_74) = &input.firewall_name {
object.key("FirewallName").string(var_74.as_str());
}
if let Some(var_75) = &input.subnet_ids {
let mut array_76 = object.key("SubnetIds").start_array();
for item_77 in var_75 {
{
array_76.value().string(item_77.as_str());
}
}
array_76.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_firewall_policies_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFirewallPoliciesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_78) = &input.next_token {
object.key("NextToken").string(var_78.as_str());
}
if let Some(var_79) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_79).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_firewalls_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFirewallsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.next_token {
object.key("NextToken").string(var_80.as_str());
}
if let Some(var_81) = &input.vpc_ids {
let mut array_82 = object.key("VpcIds").start_array();
for item_83 in var_81 {
{
array_82.value().string(item_83.as_str());
}
}
array_82.finish();
}
if let Some(var_84) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_84).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_rule_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListRuleGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.next_token {
object.key("NextToken").string(var_85.as_str());
}
if let Some(var_86) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_86).into()),
);
}
if let Some(var_87) = &input.scope {
object.key("Scope").string(var_87.as_str());
}
if let Some(var_88) = &input.managed_type {
object.key("ManagedType").string(var_88.as_str());
}
if let Some(var_89) = &input.r#type {
object.key("Type").string(var_89.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_for_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsForResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_90) = &input.next_token {
object.key("NextToken").string(var_90.as_str());
}
if let Some(var_91) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_91).into()),
);
}
if let Some(var_92) = &input.resource_arn {
object.key("ResourceArn").string(var_92.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutResourcePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.resource_arn {
object.key("ResourceArn").string(var_93.as_str());
}
if let Some(var_94) = &input.policy {
object.key("Policy").string(var_94.as_str());
}
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_95) = &input.resource_arn {
object.key("ResourceArn").string(var_95.as_str());
}
if let Some(var_96) = &input.tags {
let mut array_97 = object.key("Tags").start_array();
for item_98 in var_96 {
{
#[allow(unused_mut)]
let mut object_99 = array_97.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_99, item_98)?;
object_99.finish();
}
}
array_97.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_untag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_100) = &input.resource_arn {
object.key("ResourceArn").string(var_100.as_str());
}
if let Some(var_101) = &input.tag_keys {
let mut array_102 = object.key("TagKeys").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_update_firewall_delete_protection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFirewallDeleteProtectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_104) = &input.update_token {
object.key("UpdateToken").string(var_104.as_str());
}
if let Some(var_105) = &input.firewall_arn {
object.key("FirewallArn").string(var_105.as_str());
}
if let Some(var_106) = &input.firewall_name {
object.key("FirewallName").string(var_106.as_str());
}
{
object
.key("DeleteProtection")
.boolean(input.delete_protection);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_firewall_description_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFirewallDescriptionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_107) = &input.update_token {
object.key("UpdateToken").string(var_107.as_str());
}
if let Some(var_108) = &input.firewall_arn {
object.key("FirewallArn").string(var_108.as_str());
}
if let Some(var_109) = &input.firewall_name {
object.key("FirewallName").string(var_109.as_str());
}
if let Some(var_110) = &input.description {
object.key("Description").string(var_110.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_firewall_encryption_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFirewallEncryptionConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_111) = &input.update_token {
object.key("UpdateToken").string(var_111.as_str());
}
if let Some(var_112) = &input.firewall_arn {
object.key("FirewallArn").string(var_112.as_str());
}
if let Some(var_113) = &input.firewall_name {
object.key("FirewallName").string(var_113.as_str());
}
if let Some(var_114) = &input.encryption_configuration {
#[allow(unused_mut)]
let mut object_115 = object.key("EncryptionConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_configuration(
&mut object_115,
var_114,
)?;
object_115.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_firewall_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFirewallPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_116) = &input.update_token {
object.key("UpdateToken").string(var_116.as_str());
}
if let Some(var_117) = &input.firewall_policy_arn {
object.key("FirewallPolicyArn").string(var_117.as_str());
}
if let Some(var_118) = &input.firewall_policy_name {
object.key("FirewallPolicyName").string(var_118.as_str());
}
if let Some(var_119) = &input.firewall_policy {
#[allow(unused_mut)]
let mut object_120 = object.key("FirewallPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_firewall_policy(&mut object_120, var_119)?;
object_120.finish();
}
if let Some(var_121) = &input.description {
object.key("Description").string(var_121.as_str());
}
if input.dry_run {
object.key("DryRun").boolean(input.dry_run);
}
if let Some(var_122) = &input.encryption_configuration {
#[allow(unused_mut)]
let mut object_123 = object.key("EncryptionConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_configuration(
&mut object_123,
var_122,
)?;
object_123.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_firewall_policy_change_protection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFirewallPolicyChangeProtectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_124) = &input.update_token {
object.key("UpdateToken").string(var_124.as_str());
}
if let Some(var_125) = &input.firewall_arn {
object.key("FirewallArn").string(var_125.as_str());
}
if let Some(var_126) = &input.firewall_name {
object.key("FirewallName").string(var_126.as_str());
}
{
object
.key("FirewallPolicyChangeProtection")
.boolean(input.firewall_policy_change_protection);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_logging_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateLoggingConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_127) = &input.firewall_arn {
object.key("FirewallArn").string(var_127.as_str());
}
if let Some(var_128) = &input.firewall_name {
object.key("FirewallName").string(var_128.as_str());
}
if let Some(var_129) = &input.logging_configuration {
#[allow(unused_mut)]
let mut object_130 = object.key("LoggingConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_logging_configuration(
&mut object_130,
var_129,
)?;
object_130.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_rule_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRuleGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_131) = &input.update_token {
object.key("UpdateToken").string(var_131.as_str());
}
if let Some(var_132) = &input.rule_group_arn {
object.key("RuleGroupArn").string(var_132.as_str());
}
if let Some(var_133) = &input.rule_group_name {
object.key("RuleGroupName").string(var_133.as_str());
}
if let Some(var_134) = &input.rule_group {
#[allow(unused_mut)]
let mut object_135 = object.key("RuleGroup").start_object();
crate::json_ser::serialize_structure_crate_model_rule_group(&mut object_135, var_134)?;
object_135.finish();
}
if let Some(var_136) = &input.rules {
object.key("Rules").string(var_136.as_str());
}
if let Some(var_137) = &input.r#type {
object.key("Type").string(var_137.as_str());
}
if let Some(var_138) = &input.description {
object.key("Description").string(var_138.as_str());
}
if input.dry_run {
object.key("DryRun").boolean(input.dry_run);
}
if let Some(var_139) = &input.encryption_configuration {
#[allow(unused_mut)]
let mut object_140 = object.key("EncryptionConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_configuration(
&mut object_140,
var_139,
)?;
object_140.finish();
}
if let Some(var_141) = &input.source_metadata {
#[allow(unused_mut)]
let mut object_142 = object.key("SourceMetadata").start_object();
crate::json_ser::serialize_structure_crate_model_source_metadata(&mut object_142, var_141)?;
object_142.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_subnet_change_protection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSubnetChangeProtectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_143) = &input.update_token {
object.key("UpdateToken").string(var_143.as_str());
}
if let Some(var_144) = &input.firewall_arn {
object.key("FirewallArn").string(var_144.as_str());
}
if let Some(var_145) = &input.firewall_name {
object.key("FirewallName").string(var_145.as_str());
}
{
object
.key("SubnetChangeProtection")
.boolean(input.subnet_change_protection);
}
Ok(())
}
pub fn serialize_structure_crate_model_subnet_mapping(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SubnetMapping,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.subnet_id {
object.key("SubnetId").string(var_146.as_str());
}
if let Some(var_147) = &input.ip_address_type {
object.key("IPAddressType").string(var_147.as_str());
}
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_148) = &input.key {
object.key("Key").string(var_148.as_str());
}
if let Some(var_149) = &input.value {
object.key("Value").string(var_149.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_encryption_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EncryptionConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_150) = &input.key_id {
object.key("KeyId").string(var_150.as_str());
}
if let Some(var_151) = &input.r#type {
object.key("Type").string(var_151.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_firewall_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FirewallPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_152) = &input.stateless_rule_group_references {
let mut array_153 = object.key("StatelessRuleGroupReferences").start_array();
for item_154 in var_152 {
{
#[allow(unused_mut)]
let mut object_155 = array_153.value().start_object();
crate::json_ser::serialize_structure_crate_model_stateless_rule_group_reference(
&mut object_155,
item_154,
)?;
object_155.finish();
}
}
array_153.finish();
}
if let Some(var_156) = &input.stateless_default_actions {
let mut array_157 = object.key("StatelessDefaultActions").start_array();
for item_158 in var_156 {
{
array_157.value().string(item_158.as_str());
}
}
array_157.finish();
}
if let Some(var_159) = &input.stateless_fragment_default_actions {
let mut array_160 = object.key("StatelessFragmentDefaultActions").start_array();
for item_161 in var_159 {
{
array_160.value().string(item_161.as_str());
}
}
array_160.finish();
}
if let Some(var_162) = &input.stateless_custom_actions {
let mut array_163 = object.key("StatelessCustomActions").start_array();
for item_164 in var_162 {
{
#[allow(unused_mut)]
let mut object_165 = array_163.value().start_object();
crate::json_ser::serialize_structure_crate_model_custom_action(
&mut object_165,
item_164,
)?;
object_165.finish();
}
}
array_163.finish();
}
if let Some(var_166) = &input.stateful_rule_group_references {
let mut array_167 = object.key("StatefulRuleGroupReferences").start_array();
for item_168 in var_166 {
{
#[allow(unused_mut)]
let mut object_169 = array_167.value().start_object();
crate::json_ser::serialize_structure_crate_model_stateful_rule_group_reference(
&mut object_169,
item_168,
)?;
object_169.finish();
}
}
array_167.finish();
}
if let Some(var_170) = &input.stateful_default_actions {
let mut array_171 = object.key("StatefulDefaultActions").start_array();
for item_172 in var_170 {
{
array_171.value().string(item_172.as_str());
}
}
array_171.finish();
}
if let Some(var_173) = &input.stateful_engine_options {
#[allow(unused_mut)]
let mut object_174 = object.key("StatefulEngineOptions").start_object();
crate::json_ser::serialize_structure_crate_model_stateful_engine_options(
&mut object_174,
var_173,
)?;
object_174.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_175) = &input.rule_variables {
#[allow(unused_mut)]
let mut object_176 = object.key("RuleVariables").start_object();
crate::json_ser::serialize_structure_crate_model_rule_variables(&mut object_176, var_175)?;
object_176.finish();
}
if let Some(var_177) = &input.reference_sets {
#[allow(unused_mut)]
let mut object_178 = object.key("ReferenceSets").start_object();
crate::json_ser::serialize_structure_crate_model_reference_sets(&mut object_178, var_177)?;
object_178.finish();
}
if let Some(var_179) = &input.rules_source {
#[allow(unused_mut)]
let mut object_180 = object.key("RulesSource").start_object();
crate::json_ser::serialize_structure_crate_model_rules_source(&mut object_180, var_179)?;
object_180.finish();
}
if let Some(var_181) = &input.stateful_rule_options {
#[allow(unused_mut)]
let mut object_182 = object.key("StatefulRuleOptions").start_object();
crate::json_ser::serialize_structure_crate_model_stateful_rule_options(
&mut object_182,
var_181,
)?;
object_182.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_source_metadata(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SourceMetadata,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_183) = &input.source_arn {
object.key("SourceArn").string(var_183.as_str());
}
if let Some(var_184) = &input.source_update_token {
object.key("SourceUpdateToken").string(var_184.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_logging_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoggingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_185) = &input.log_destination_configs {
let mut array_186 = object.key("LogDestinationConfigs").start_array();
for item_187 in var_185 {
{
#[allow(unused_mut)]
let mut object_188 = array_186.value().start_object();
crate::json_ser::serialize_structure_crate_model_log_destination_config(
&mut object_188,
item_187,
)?;
object_188.finish();
}
}
array_186.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_stateless_rule_group_reference(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatelessRuleGroupReference,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_189) = &input.resource_arn {
object.key("ResourceArn").string(var_189.as_str());
}
{
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.priority).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_190) = &input.action_name {
object.key("ActionName").string(var_190.as_str());
}
if let Some(var_191) = &input.action_definition {
#[allow(unused_mut)]
let mut object_192 = object.key("ActionDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_action_definition(
&mut object_192,
var_191,
)?;
object_192.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_stateful_rule_group_reference(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatefulRuleGroupReference,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_193) = &input.resource_arn {
object.key("ResourceArn").string(var_193.as_str());
}
if let Some(var_194) = &input.priority {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_194).into()),
);
}
if let Some(var_195) = &input.r#override {
#[allow(unused_mut)]
let mut object_196 = object.key("Override").start_object();
crate::json_ser::serialize_structure_crate_model_stateful_rule_group_override(
&mut object_196,
var_195,
)?;
object_196.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_stateful_engine_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatefulEngineOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.rule_order {
object.key("RuleOrder").string(var_197.as_str());
}
if let Some(var_198) = &input.stream_exception_policy {
object.key("StreamExceptionPolicy").string(var_198.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_variables(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleVariables,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_199) = &input.ip_sets {
#[allow(unused_mut)]
let mut object_200 = object.key("IPSets").start_object();
for (key_201, value_202) in var_199 {
{
#[allow(unused_mut)]
let mut object_203 = object_200.key(key_201.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_ip_set(
&mut object_203,
value_202,
)?;
object_203.finish();
}
}
object_200.finish();
}
if let Some(var_204) = &input.port_sets {
#[allow(unused_mut)]
let mut object_205 = object.key("PortSets").start_object();
for (key_206, value_207) in var_204 {
{
#[allow(unused_mut)]
let mut object_208 = object_205.key(key_206.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_port_set(
&mut object_208,
value_207,
)?;
object_208.finish();
}
}
object_205.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_reference_sets(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReferenceSets,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_209) = &input.ip_set_references {
#[allow(unused_mut)]
let mut object_210 = object.key("IPSetReferences").start_object();
for (key_211, value_212) in var_209 {
{
#[allow(unused_mut)]
let mut object_213 = object_210.key(key_211.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_ip_set_reference(
&mut object_213,
value_212,
)?;
object_213.finish();
}
}
object_210.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_rules_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RulesSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_214) = &input.rules_string {
object.key("RulesString").string(var_214.as_str());
}
if let Some(var_215) = &input.rules_source_list {
#[allow(unused_mut)]
let mut object_216 = object.key("RulesSourceList").start_object();
crate::json_ser::serialize_structure_crate_model_rules_source_list(
&mut object_216,
var_215,
)?;
object_216.finish();
}
if let Some(var_217) = &input.stateful_rules {
let mut array_218 = object.key("StatefulRules").start_array();
for item_219 in var_217 {
{
#[allow(unused_mut)]
let mut object_220 = array_218.value().start_object();
crate::json_ser::serialize_structure_crate_model_stateful_rule(
&mut object_220,
item_219,
)?;
object_220.finish();
}
}
array_218.finish();
}
if let Some(var_221) = &input.stateless_rules_and_custom_actions {
#[allow(unused_mut)]
let mut object_222 = object.key("StatelessRulesAndCustomActions").start_object();
crate::json_ser::serialize_structure_crate_model_stateless_rules_and_custom_actions(
&mut object_222,
var_221,
)?;
object_222.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_stateful_rule_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatefulRuleOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_223) = &input.rule_order {
object.key("RuleOrder").string(var_223.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_log_destination_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LogDestinationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_224) = &input.log_type {
object.key("LogType").string(var_224.as_str());
}
if let Some(var_225) = &input.log_destination_type {
object.key("LogDestinationType").string(var_225.as_str());
}
if let Some(var_226) = &input.log_destination {
#[allow(unused_mut)]
let mut object_227 = object.key("LogDestination").start_object();
for (key_228, value_229) in var_226 {
{
object_227.key(key_228.as_str()).string(value_229.as_str());
}
}
object_227.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_action_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_230) = &input.publish_metric_action {
#[allow(unused_mut)]
let mut object_231 = object.key("PublishMetricAction").start_object();
crate::json_ser::serialize_structure_crate_model_publish_metric_action(
&mut object_231,
var_230,
)?;
object_231.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_stateful_rule_group_override(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatefulRuleGroupOverride,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_232) = &input.action {
object.key("Action").string(var_232.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ip_set(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IpSet,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_233) = &input.definition {
let mut array_234 = object.key("Definition").start_array();
for item_235 in var_233 {
{
array_234.value().string(item_235.as_str());
}
}
array_234.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_port_set(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PortSet,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_236) = &input.definition {
let mut array_237 = object.key("Definition").start_array();
for item_238 in var_236 {
{
array_237.value().string(item_238.as_str());
}
}
array_237.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_ip_set_reference(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IpSetReference,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_239) = &input.reference_arn {
object.key("ReferenceArn").string(var_239.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_rules_source_list(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RulesSourceList,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_240) = &input.targets {
let mut array_241 = object.key("Targets").start_array();
for item_242 in var_240 {
{
array_241.value().string(item_242.as_str());
}
}
array_241.finish();
}
if let Some(var_243) = &input.target_types {
let mut array_244 = object.key("TargetTypes").start_array();
for item_245 in var_243 {
{
array_244.value().string(item_245.as_str());
}
}
array_244.finish();
}
if let Some(var_246) = &input.generated_rules_type {
object.key("GeneratedRulesType").string(var_246.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_stateful_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatefulRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_247) = &input.action {
object.key("Action").string(var_247.as_str());
}
if let Some(var_248) = &input.header {
#[allow(unused_mut)]
let mut object_249 = object.key("Header").start_object();
crate::json_ser::serialize_structure_crate_model_header(&mut object_249, var_248)?;
object_249.finish();
}
if let Some(var_250) = &input.rule_options {
let mut array_251 = object.key("RuleOptions").start_array();
for item_252 in var_250 {
{
#[allow(unused_mut)]
let mut object_253 = array_251.value().start_object();
crate::json_ser::serialize_structure_crate_model_rule_option(
&mut object_253,
item_252,
)?;
object_253.finish();
}
}
array_251.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_stateless_rules_and_custom_actions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatelessRulesAndCustomActions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_254) = &input.stateless_rules {
let mut array_255 = object.key("StatelessRules").start_array();
for item_256 in var_254 {
{
#[allow(unused_mut)]
let mut object_257 = array_255.value().start_object();
crate::json_ser::serialize_structure_crate_model_stateless_rule(
&mut object_257,
item_256,
)?;
object_257.finish();
}
}
array_255.finish();
}
if let Some(var_258) = &input.custom_actions {
let mut array_259 = object.key("CustomActions").start_array();
for item_260 in var_258 {
{
#[allow(unused_mut)]
let mut object_261 = array_259.value().start_object();
crate::json_ser::serialize_structure_crate_model_custom_action(
&mut object_261,
item_260,
)?;
object_261.finish();
}
}
array_259.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_publish_metric_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PublishMetricAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_262) = &input.dimensions {
let mut array_263 = object.key("Dimensions").start_array();
for item_264 in var_262 {
{
#[allow(unused_mut)]
let mut object_265 = array_263.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension(
&mut object_265,
item_264,
)?;
object_265.finish();
}
}
array_263.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_header(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Header,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_266) = &input.protocol {
object.key("Protocol").string(var_266.as_str());
}
if let Some(var_267) = &input.source {
object.key("Source").string(var_267.as_str());
}
if let Some(var_268) = &input.source_port {
object.key("SourcePort").string(var_268.as_str());
}
if let Some(var_269) = &input.direction {
object.key("Direction").string(var_269.as_str());
}
if let Some(var_270) = &input.destination {
object.key("Destination").string(var_270.as_str());
}
if let Some(var_271) = &input.destination_port {
object.key("DestinationPort").string(var_271.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_272) = &input.keyword {
object.key("Keyword").string(var_272.as_str());
}
if let Some(var_273) = &input.settings {
let mut array_274 = object.key("Settings").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_stateless_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatelessRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_276) = &input.rule_definition {
#[allow(unused_mut)]
let mut object_277 = object.key("RuleDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_rule_definition(&mut object_277, var_276)?;
object_277.finish();
}
{
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.priority).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_dimension(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Dimension,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_278) = &input.value {
object.key("Value").string(var_278.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_279) = &input.match_attributes {
#[allow(unused_mut)]
let mut object_280 = object.key("MatchAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_match_attributes(
&mut object_280,
var_279,
)?;
object_280.finish();
}
if let Some(var_281) = &input.actions {
let mut array_282 = object.key("Actions").start_array();
for item_283 in var_281 {
{
array_282.value().string(item_283.as_str());
}
}
array_282.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_match_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MatchAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_284) = &input.sources {
let mut array_285 = object.key("Sources").start_array();
for item_286 in var_284 {
{
#[allow(unused_mut)]
let mut object_287 = array_285.value().start_object();
crate::json_ser::serialize_structure_crate_model_address(
&mut object_287,
item_286,
)?;
object_287.finish();
}
}
array_285.finish();
}
if let Some(var_288) = &input.destinations {
let mut array_289 = object.key("Destinations").start_array();
for item_290 in var_288 {
{
#[allow(unused_mut)]
let mut object_291 = array_289.value().start_object();
crate::json_ser::serialize_structure_crate_model_address(
&mut object_291,
item_290,
)?;
object_291.finish();
}
}
array_289.finish();
}
if let Some(var_292) = &input.source_ports {
let mut array_293 = object.key("SourcePorts").start_array();
for item_294 in var_292 {
{
#[allow(unused_mut)]
let mut object_295 = array_293.value().start_object();
crate::json_ser::serialize_structure_crate_model_port_range(
&mut object_295,
item_294,
)?;
object_295.finish();
}
}
array_293.finish();
}
if let Some(var_296) = &input.destination_ports {
let mut array_297 = object.key("DestinationPorts").start_array();
for item_298 in var_296 {
{
#[allow(unused_mut)]
let mut object_299 = array_297.value().start_object();
crate::json_ser::serialize_structure_crate_model_port_range(
&mut object_299,
item_298,
)?;
object_299.finish();
}
}
array_297.finish();
}
if let Some(var_300) = &input.protocols {
let mut array_301 = object.key("Protocols").start_array();
for item_302 in var_300 {
{
array_301.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_302).into()),
);
}
}
array_301.finish();
}
if let Some(var_303) = &input.tcp_flags {
let mut array_304 = object.key("TCPFlags").start_array();
for item_305 in var_303 {
{
#[allow(unused_mut)]
let mut object_306 = array_304.value().start_object();
crate::json_ser::serialize_structure_crate_model_tcp_flag_field(
&mut object_306,
item_305,
)?;
object_306.finish();
}
}
array_304.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_address(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Address,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_307) = &input.address_definition {
object.key("AddressDefinition").string(var_307.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_port_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PortRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("FromPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.from_port).into()),
);
}
{
object.key("ToPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.to_port).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_tcp_flag_field(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TcpFlagField,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_308) = &input.flags {
let mut array_309 = object.key("Flags").start_array();
for item_310 in var_308 {
{
array_309.value().string(item_310.as_str());
}
}
array_309.finish();
}
if let Some(var_311) = &input.masks {
let mut array_312 = object.key("Masks").start_array();
for item_313 in var_311 {
{
array_312.value().string(item_313.as_str());
}
}
array_312.finish();
}
Ok(())
}