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::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::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 {
{
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::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 {
{
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 {
{
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 {
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::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 {
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 {
{
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 {
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::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 {
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 {
{
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 {
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 {
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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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 {
{
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::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::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::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::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 {
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::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 {
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 {
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::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::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 {
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::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 {
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 {
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 {
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::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::SerializationError> {
if let Some(var_146) = &input.subnet_id {
object.key("SubnetId").string(var_146.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::SerializationError> {
if let Some(var_147) = &input.key {
object.key("Key").string(var_147.as_str());
}
if let Some(var_148) = &input.value {
object.key("Value").string(var_148.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::SerializationError> {
if let Some(var_149) = &input.key_id {
object.key("KeyId").string(var_149.as_str());
}
if let Some(var_150) = &input.r#type {
object.key("Type").string(var_150.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::SerializationError> {
if let Some(var_151) = &input.stateless_rule_group_references {
let mut array_152 = object.key("StatelessRuleGroupReferences").start_array();
for item_153 in var_151 {
{
let mut object_154 = array_152.value().start_object();
crate::json_ser::serialize_structure_crate_model_stateless_rule_group_reference(
&mut object_154,
item_153,
)?;
object_154.finish();
}
}
array_152.finish();
}
if let Some(var_155) = &input.stateless_default_actions {
let mut array_156 = object.key("StatelessDefaultActions").start_array();
for item_157 in var_155 {
{
array_156.value().string(item_157.as_str());
}
}
array_156.finish();
}
if let Some(var_158) = &input.stateless_fragment_default_actions {
let mut array_159 = object.key("StatelessFragmentDefaultActions").start_array();
for item_160 in var_158 {
{
array_159.value().string(item_160.as_str());
}
}
array_159.finish();
}
if let Some(var_161) = &input.stateless_custom_actions {
let mut array_162 = object.key("StatelessCustomActions").start_array();
for item_163 in var_161 {
{
let mut object_164 = array_162.value().start_object();
crate::json_ser::serialize_structure_crate_model_custom_action(
&mut object_164,
item_163,
)?;
object_164.finish();
}
}
array_162.finish();
}
if let Some(var_165) = &input.stateful_rule_group_references {
let mut array_166 = object.key("StatefulRuleGroupReferences").start_array();
for item_167 in var_165 {
{
let mut object_168 = array_166.value().start_object();
crate::json_ser::serialize_structure_crate_model_stateful_rule_group_reference(
&mut object_168,
item_167,
)?;
object_168.finish();
}
}
array_166.finish();
}
if let Some(var_169) = &input.stateful_default_actions {
let mut array_170 = object.key("StatefulDefaultActions").start_array();
for item_171 in var_169 {
{
array_170.value().string(item_171.as_str());
}
}
array_170.finish();
}
if let Some(var_172) = &input.stateful_engine_options {
let mut object_173 = object.key("StatefulEngineOptions").start_object();
crate::json_ser::serialize_structure_crate_model_stateful_engine_options(
&mut object_173,
var_172,
)?;
object_173.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::SerializationError> {
if let Some(var_174) = &input.rule_variables {
let mut object_175 = object.key("RuleVariables").start_object();
crate::json_ser::serialize_structure_crate_model_rule_variables(&mut object_175, var_174)?;
object_175.finish();
}
if let Some(var_176) = &input.rules_source {
let mut object_177 = object.key("RulesSource").start_object();
crate::json_ser::serialize_structure_crate_model_rules_source(&mut object_177, var_176)?;
object_177.finish();
}
if let Some(var_178) = &input.stateful_rule_options {
let mut object_179 = object.key("StatefulRuleOptions").start_object();
crate::json_ser::serialize_structure_crate_model_stateful_rule_options(
&mut object_179,
var_178,
)?;
object_179.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::SerializationError> {
if let Some(var_180) = &input.source_arn {
object.key("SourceArn").string(var_180.as_str());
}
if let Some(var_181) = &input.source_update_token {
object.key("SourceUpdateToken").string(var_181.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::SerializationError> {
if let Some(var_182) = &input.log_destination_configs {
let mut array_183 = object.key("LogDestinationConfigs").start_array();
for item_184 in var_182 {
{
let mut object_185 = array_183.value().start_object();
crate::json_ser::serialize_structure_crate_model_log_destination_config(
&mut object_185,
item_184,
)?;
object_185.finish();
}
}
array_183.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::SerializationError> {
if let Some(var_186) = &input.resource_arn {
object.key("ResourceArn").string(var_186.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::SerializationError> {
if let Some(var_187) = &input.action_name {
object.key("ActionName").string(var_187.as_str());
}
if let Some(var_188) = &input.action_definition {
let mut object_189 = object.key("ActionDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_action_definition(
&mut object_189,
var_188,
)?;
object_189.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::SerializationError> {
if let Some(var_190) = &input.resource_arn {
object.key("ResourceArn").string(var_190.as_str());
}
if let Some(var_191) = &input.priority {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_191).into()),
);
}
if let Some(var_192) = &input.r#override {
let mut object_193 = object.key("Override").start_object();
crate::json_ser::serialize_structure_crate_model_stateful_rule_group_override(
&mut object_193,
var_192,
)?;
object_193.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::SerializationError> {
if let Some(var_194) = &input.rule_order {
object.key("RuleOrder").string(var_194.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::SerializationError> {
if let Some(var_195) = &input.ip_sets {
let mut object_196 = object.key("IPSets").start_object();
for (key_197, value_198) in var_195 {
{
let mut object_199 = object_196.key(key_197).start_object();
crate::json_ser::serialize_structure_crate_model_ip_set(
&mut object_199,
value_198,
)?;
object_199.finish();
}
}
object_196.finish();
}
if let Some(var_200) = &input.port_sets {
let mut object_201 = object.key("PortSets").start_object();
for (key_202, value_203) in var_200 {
{
let mut object_204 = object_201.key(key_202).start_object();
crate::json_ser::serialize_structure_crate_model_port_set(
&mut object_204,
value_203,
)?;
object_204.finish();
}
}
object_201.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::SerializationError> {
if let Some(var_205) = &input.rules_string {
object.key("RulesString").string(var_205.as_str());
}
if let Some(var_206) = &input.rules_source_list {
let mut object_207 = object.key("RulesSourceList").start_object();
crate::json_ser::serialize_structure_crate_model_rules_source_list(
&mut object_207,
var_206,
)?;
object_207.finish();
}
if let Some(var_208) = &input.stateful_rules {
let mut array_209 = object.key("StatefulRules").start_array();
for item_210 in var_208 {
{
let mut object_211 = array_209.value().start_object();
crate::json_ser::serialize_structure_crate_model_stateful_rule(
&mut object_211,
item_210,
)?;
object_211.finish();
}
}
array_209.finish();
}
if let Some(var_212) = &input.stateless_rules_and_custom_actions {
let mut object_213 = object.key("StatelessRulesAndCustomActions").start_object();
crate::json_ser::serialize_structure_crate_model_stateless_rules_and_custom_actions(
&mut object_213,
var_212,
)?;
object_213.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::SerializationError> {
if let Some(var_214) = &input.rule_order {
object.key("RuleOrder").string(var_214.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::SerializationError> {
if let Some(var_215) = &input.log_type {
object.key("LogType").string(var_215.as_str());
}
if let Some(var_216) = &input.log_destination_type {
object.key("LogDestinationType").string(var_216.as_str());
}
if let Some(var_217) = &input.log_destination {
let mut object_218 = object.key("LogDestination").start_object();
for (key_219, value_220) in var_217 {
{
object_218.key(key_219).string(value_220.as_str());
}
}
object_218.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::SerializationError> {
if let Some(var_221) = &input.publish_metric_action {
let mut object_222 = object.key("PublishMetricAction").start_object();
crate::json_ser::serialize_structure_crate_model_publish_metric_action(
&mut object_222,
var_221,
)?;
object_222.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::SerializationError> {
if let Some(var_223) = &input.action {
object.key("Action").string(var_223.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::SerializationError> {
if let Some(var_224) = &input.definition {
let mut array_225 = object.key("Definition").start_array();
for item_226 in var_224 {
{
array_225.value().string(item_226.as_str());
}
}
array_225.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::SerializationError> {
if let Some(var_227) = &input.definition {
let mut array_228 = object.key("Definition").start_array();
for item_229 in var_227 {
{
array_228.value().string(item_229.as_str());
}
}
array_228.finish();
}
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::SerializationError> {
if let Some(var_230) = &input.targets {
let mut array_231 = object.key("Targets").start_array();
for item_232 in var_230 {
{
array_231.value().string(item_232.as_str());
}
}
array_231.finish();
}
if let Some(var_233) = &input.target_types {
let mut array_234 = object.key("TargetTypes").start_array();
for item_235 in var_233 {
{
array_234.value().string(item_235.as_str());
}
}
array_234.finish();
}
if let Some(var_236) = &input.generated_rules_type {
object.key("GeneratedRulesType").string(var_236.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::SerializationError> {
if let Some(var_237) = &input.action {
object.key("Action").string(var_237.as_str());
}
if let Some(var_238) = &input.header {
let mut object_239 = object.key("Header").start_object();
crate::json_ser::serialize_structure_crate_model_header(&mut object_239, var_238)?;
object_239.finish();
}
if let Some(var_240) = &input.rule_options {
let mut array_241 = object.key("RuleOptions").start_array();
for item_242 in var_240 {
{
let mut object_243 = array_241.value().start_object();
crate::json_ser::serialize_structure_crate_model_rule_option(
&mut object_243,
item_242,
)?;
object_243.finish();
}
}
array_241.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::SerializationError> {
if let Some(var_244) = &input.stateless_rules {
let mut array_245 = object.key("StatelessRules").start_array();
for item_246 in var_244 {
{
let mut object_247 = array_245.value().start_object();
crate::json_ser::serialize_structure_crate_model_stateless_rule(
&mut object_247,
item_246,
)?;
object_247.finish();
}
}
array_245.finish();
}
if let Some(var_248) = &input.custom_actions {
let mut array_249 = object.key("CustomActions").start_array();
for item_250 in var_248 {
{
let mut object_251 = array_249.value().start_object();
crate::json_ser::serialize_structure_crate_model_custom_action(
&mut object_251,
item_250,
)?;
object_251.finish();
}
}
array_249.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::SerializationError> {
if let Some(var_252) = &input.dimensions {
let mut array_253 = object.key("Dimensions").start_array();
for item_254 in var_252 {
{
let mut object_255 = array_253.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension(
&mut object_255,
item_254,
)?;
object_255.finish();
}
}
array_253.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::SerializationError> {
if let Some(var_256) = &input.protocol {
object.key("Protocol").string(var_256.as_str());
}
if let Some(var_257) = &input.source {
object.key("Source").string(var_257.as_str());
}
if let Some(var_258) = &input.source_port {
object.key("SourcePort").string(var_258.as_str());
}
if let Some(var_259) = &input.direction {
object.key("Direction").string(var_259.as_str());
}
if let Some(var_260) = &input.destination {
object.key("Destination").string(var_260.as_str());
}
if let Some(var_261) = &input.destination_port {
object.key("DestinationPort").string(var_261.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::SerializationError> {
if let Some(var_262) = &input.keyword {
object.key("Keyword").string(var_262.as_str());
}
if let Some(var_263) = &input.settings {
let mut array_264 = object.key("Settings").start_array();
for item_265 in var_263 {
{
array_264.value().string(item_265.as_str());
}
}
array_264.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::SerializationError> {
if let Some(var_266) = &input.rule_definition {
let mut object_267 = object.key("RuleDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_rule_definition(&mut object_267, var_266)?;
object_267.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::SerializationError> {
if let Some(var_268) = &input.value {
object.key("Value").string(var_268.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::SerializationError> {
if let Some(var_269) = &input.match_attributes {
let mut object_270 = object.key("MatchAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_match_attributes(
&mut object_270,
var_269,
)?;
object_270.finish();
}
if let Some(var_271) = &input.actions {
let mut array_272 = object.key("Actions").start_array();
for item_273 in var_271 {
{
array_272.value().string(item_273.as_str());
}
}
array_272.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::SerializationError> {
if let Some(var_274) = &input.sources {
let mut array_275 = object.key("Sources").start_array();
for item_276 in var_274 {
{
let mut object_277 = array_275.value().start_object();
crate::json_ser::serialize_structure_crate_model_address(
&mut object_277,
item_276,
)?;
object_277.finish();
}
}
array_275.finish();
}
if let Some(var_278) = &input.destinations {
let mut array_279 = object.key("Destinations").start_array();
for item_280 in var_278 {
{
let mut object_281 = array_279.value().start_object();
crate::json_ser::serialize_structure_crate_model_address(
&mut object_281,
item_280,
)?;
object_281.finish();
}
}
array_279.finish();
}
if let Some(var_282) = &input.source_ports {
let mut array_283 = object.key("SourcePorts").start_array();
for item_284 in var_282 {
{
let mut object_285 = array_283.value().start_object();
crate::json_ser::serialize_structure_crate_model_port_range(
&mut object_285,
item_284,
)?;
object_285.finish();
}
}
array_283.finish();
}
if let Some(var_286) = &input.destination_ports {
let mut array_287 = object.key("DestinationPorts").start_array();
for item_288 in var_286 {
{
let mut object_289 = array_287.value().start_object();
crate::json_ser::serialize_structure_crate_model_port_range(
&mut object_289,
item_288,
)?;
object_289.finish();
}
}
array_287.finish();
}
if let Some(var_290) = &input.protocols {
let mut array_291 = object.key("Protocols").start_array();
for item_292 in var_290 {
{
array_291.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_292).into()),
);
}
}
array_291.finish();
}
if let Some(var_293) = &input.tcp_flags {
let mut array_294 = object.key("TCPFlags").start_array();
for item_295 in var_293 {
{
let mut object_296 = array_294.value().start_object();
crate::json_ser::serialize_structure_crate_model_tcp_flag_field(
&mut object_296,
item_295,
)?;
object_296.finish();
}
}
array_294.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::SerializationError> {
if let Some(var_297) = &input.address_definition {
object.key("AddressDefinition").string(var_297.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::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::SerializationError> {
if let Some(var_298) = &input.flags {
let mut array_299 = object.key("Flags").start_array();
for item_300 in var_298 {
{
array_299.value().string(item_300.as_str());
}
}
array_299.finish();
}
if let Some(var_301) = &input.masks {
let mut array_302 = object.key("Masks").start_array();
for item_303 in var_301 {
{
array_302.value().string(item_303.as_str());
}
}
array_302.finish();
}
Ok(())
}