pub fn serialize_structure_crate_input_associate_firewall_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateFirewallPolicyInput,
) {
if let Some(var_1) = &input.update_token {
object.key("UpdateToken").string(var_1);
}
if let Some(var_2) = &input.firewall_arn {
object.key("FirewallArn").string(var_2);
}
if let Some(var_3) = &input.firewall_name {
object.key("FirewallName").string(var_3);
}
if let Some(var_4) = &input.firewall_policy_arn {
object.key("FirewallPolicyArn").string(var_4);
}
}
pub fn serialize_structure_crate_input_associate_subnets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateSubnetsInput,
) {
if let Some(var_5) = &input.update_token {
object.key("UpdateToken").string(var_5);
}
if let Some(var_6) = &input.firewall_arn {
object.key("FirewallArn").string(var_6);
}
if let Some(var_7) = &input.firewall_name {
object.key("FirewallName").string(var_7);
}
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();
}
}
pub fn serialize_structure_crate_input_create_firewall_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFirewallInput,
) {
if let Some(var_12) = &input.firewall_name {
object.key("FirewallName").string(var_12);
}
if let Some(var_13) = &input.firewall_policy_arn {
object.key("FirewallPolicyArn").string(var_13);
}
if let Some(var_14) = &input.vpc_id {
object.key("VpcId").string(var_14);
}
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);
}
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();
}
}
pub fn serialize_structure_crate_input_create_firewall_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFirewallPolicyInput,
) {
if let Some(var_24) = &input.firewall_policy_name {
object.key("FirewallPolicyName").string(var_24);
}
if let Some(var_25) = &input.firewall_policy {
let mut object_26 = object.key("FirewallPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_firewall_policy(&mut object_26, var_25);
object_26.finish();
}
if let Some(var_27) = &input.description {
object.key("Description").string(var_27);
}
if let Some(var_28) = &input.tags {
let mut array_29 = object.key("Tags").start_array();
for item_30 in var_28 {
{
let mut object_31 = array_29.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_31, item_30);
object_31.finish();
}
}
array_29.finish();
}
if input.dry_run {
object.key("DryRun").boolean(input.dry_run);
}
}
pub fn serialize_structure_crate_input_create_rule_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateRuleGroupInput,
) {
if let Some(var_32) = &input.rule_group_name {
object.key("RuleGroupName").string(var_32);
}
if let Some(var_33) = &input.rule_group {
let mut object_34 = object.key("RuleGroup").start_object();
crate::json_ser::serialize_structure_crate_model_rule_group(&mut object_34, var_33);
object_34.finish();
}
if let Some(var_35) = &input.rules {
object.key("Rules").string(var_35);
}
if let Some(var_36) = &input.r#type {
object.key("Type").string(var_36.as_str());
}
if let Some(var_37) = &input.description {
object.key("Description").string(var_37);
}
if let Some(var_38) = &input.capacity {
object.key("Capacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_38).into()),
);
}
if let Some(var_39) = &input.tags {
let mut array_40 = object.key("Tags").start_array();
for item_41 in var_39 {
{
let mut object_42 = array_40.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_42, item_41);
object_42.finish();
}
}
array_40.finish();
}
if input.dry_run {
object.key("DryRun").boolean(input.dry_run);
}
}
pub fn serialize_structure_crate_input_delete_firewall_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteFirewallInput,
) {
if let Some(var_43) = &input.firewall_name {
object.key("FirewallName").string(var_43);
}
if let Some(var_44) = &input.firewall_arn {
object.key("FirewallArn").string(var_44);
}
}
pub fn serialize_structure_crate_input_delete_firewall_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteFirewallPolicyInput,
) {
if let Some(var_45) = &input.firewall_policy_name {
object.key("FirewallPolicyName").string(var_45);
}
if let Some(var_46) = &input.firewall_policy_arn {
object.key("FirewallPolicyArn").string(var_46);
}
}
pub fn serialize_structure_crate_input_delete_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteResourcePolicyInput,
) {
if let Some(var_47) = &input.resource_arn {
object.key("ResourceArn").string(var_47);
}
}
pub fn serialize_structure_crate_input_delete_rule_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteRuleGroupInput,
) {
if let Some(var_48) = &input.rule_group_name {
object.key("RuleGroupName").string(var_48);
}
if let Some(var_49) = &input.rule_group_arn {
object.key("RuleGroupArn").string(var_49);
}
if let Some(var_50) = &input.r#type {
object.key("Type").string(var_50.as_str());
}
}
pub fn serialize_structure_crate_input_describe_firewall_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFirewallInput,
) {
if let Some(var_51) = &input.firewall_name {
object.key("FirewallName").string(var_51);
}
if let Some(var_52) = &input.firewall_arn {
object.key("FirewallArn").string(var_52);
}
}
pub fn serialize_structure_crate_input_describe_firewall_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFirewallPolicyInput,
) {
if let Some(var_53) = &input.firewall_policy_name {
object.key("FirewallPolicyName").string(var_53);
}
if let Some(var_54) = &input.firewall_policy_arn {
object.key("FirewallPolicyArn").string(var_54);
}
}
pub fn serialize_structure_crate_input_describe_logging_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeLoggingConfigurationInput,
) {
if let Some(var_55) = &input.firewall_arn {
object.key("FirewallArn").string(var_55);
}
if let Some(var_56) = &input.firewall_name {
object.key("FirewallName").string(var_56);
}
}
pub fn serialize_structure_crate_input_describe_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeResourcePolicyInput,
) {
if let Some(var_57) = &input.resource_arn {
object.key("ResourceArn").string(var_57);
}
}
pub fn serialize_structure_crate_input_describe_rule_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeRuleGroupInput,
) {
if let Some(var_58) = &input.rule_group_name {
object.key("RuleGroupName").string(var_58);
}
if let Some(var_59) = &input.rule_group_arn {
object.key("RuleGroupArn").string(var_59);
}
if let Some(var_60) = &input.r#type {
object.key("Type").string(var_60.as_str());
}
}
pub fn serialize_structure_crate_input_disassociate_subnets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateSubnetsInput,
) {
if let Some(var_61) = &input.update_token {
object.key("UpdateToken").string(var_61);
}
if let Some(var_62) = &input.firewall_arn {
object.key("FirewallArn").string(var_62);
}
if let Some(var_63) = &input.firewall_name {
object.key("FirewallName").string(var_63);
}
if let Some(var_64) = &input.subnet_ids {
let mut array_65 = object.key("SubnetIds").start_array();
for item_66 in var_64 {
{
array_65.value().string(item_66);
}
}
array_65.finish();
}
}
pub fn serialize_structure_crate_input_list_firewall_policies_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFirewallPoliciesInput,
) {
if let Some(var_67) = &input.next_token {
object.key("NextToken").string(var_67);
}
if let Some(var_68) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_68).into()),
);
}
}
pub fn serialize_structure_crate_input_list_firewalls_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFirewallsInput,
) {
if let Some(var_69) = &input.next_token {
object.key("NextToken").string(var_69);
}
if let Some(var_70) = &input.vpc_ids {
let mut array_71 = object.key("VpcIds").start_array();
for item_72 in var_70 {
{
array_71.value().string(item_72);
}
}
array_71.finish();
}
if let Some(var_73) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_73).into()),
);
}
}
pub fn serialize_structure_crate_input_list_rule_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListRuleGroupsInput,
) {
if let Some(var_74) = &input.next_token {
object.key("NextToken").string(var_74);
}
if let Some(var_75) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_75).into()),
);
}
}
pub fn serialize_structure_crate_input_list_tags_for_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsForResourceInput,
) {
if let Some(var_76) = &input.next_token {
object.key("NextToken").string(var_76);
}
if let Some(var_77) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_77).into()),
);
}
if let Some(var_78) = &input.resource_arn {
object.key("ResourceArn").string(var_78);
}
}
pub fn serialize_structure_crate_input_put_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutResourcePolicyInput,
) {
if let Some(var_79) = &input.resource_arn {
object.key("ResourceArn").string(var_79);
}
if let Some(var_80) = &input.policy {
object.key("Policy").string(var_80);
}
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) {
if let Some(var_81) = &input.resource_arn {
object.key("ResourceArn").string(var_81);
}
if let Some(var_82) = &input.tags {
let mut array_83 = object.key("Tags").start_array();
for item_84 in var_82 {
{
let mut object_85 = array_83.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_85, item_84);
object_85.finish();
}
}
array_83.finish();
}
}
pub fn serialize_structure_crate_input_untag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UntagResourceInput,
) {
if let Some(var_86) = &input.resource_arn {
object.key("ResourceArn").string(var_86);
}
if let Some(var_87) = &input.tag_keys {
let mut array_88 = object.key("TagKeys").start_array();
for item_89 in var_87 {
{
array_88.value().string(item_89);
}
}
array_88.finish();
}
}
pub fn serialize_structure_crate_input_update_firewall_delete_protection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFirewallDeleteProtectionInput,
) {
if let Some(var_90) = &input.update_token {
object.key("UpdateToken").string(var_90);
}
if let Some(var_91) = &input.firewall_arn {
object.key("FirewallArn").string(var_91);
}
if let Some(var_92) = &input.firewall_name {
object.key("FirewallName").string(var_92);
}
{
object
.key("DeleteProtection")
.boolean(input.delete_protection);
}
}
pub fn serialize_structure_crate_input_update_firewall_description_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFirewallDescriptionInput,
) {
if let Some(var_93) = &input.update_token {
object.key("UpdateToken").string(var_93);
}
if let Some(var_94) = &input.firewall_arn {
object.key("FirewallArn").string(var_94);
}
if let Some(var_95) = &input.firewall_name {
object.key("FirewallName").string(var_95);
}
if let Some(var_96) = &input.description {
object.key("Description").string(var_96);
}
}
pub fn serialize_structure_crate_input_update_firewall_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFirewallPolicyInput,
) {
if let Some(var_97) = &input.update_token {
object.key("UpdateToken").string(var_97);
}
if let Some(var_98) = &input.firewall_policy_arn {
object.key("FirewallPolicyArn").string(var_98);
}
if let Some(var_99) = &input.firewall_policy_name {
object.key("FirewallPolicyName").string(var_99);
}
if let Some(var_100) = &input.firewall_policy {
let mut object_101 = object.key("FirewallPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_firewall_policy(&mut object_101, var_100);
object_101.finish();
}
if let Some(var_102) = &input.description {
object.key("Description").string(var_102);
}
if input.dry_run {
object.key("DryRun").boolean(input.dry_run);
}
}
pub fn serialize_structure_crate_input_update_firewall_policy_change_protection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFirewallPolicyChangeProtectionInput,
) {
if let Some(var_103) = &input.update_token {
object.key("UpdateToken").string(var_103);
}
if let Some(var_104) = &input.firewall_arn {
object.key("FirewallArn").string(var_104);
}
if let Some(var_105) = &input.firewall_name {
object.key("FirewallName").string(var_105);
}
{
object
.key("FirewallPolicyChangeProtection")
.boolean(input.firewall_policy_change_protection);
}
}
pub fn serialize_structure_crate_input_update_logging_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateLoggingConfigurationInput,
) {
if let Some(var_106) = &input.firewall_arn {
object.key("FirewallArn").string(var_106);
}
if let Some(var_107) = &input.firewall_name {
object.key("FirewallName").string(var_107);
}
if let Some(var_108) = &input.logging_configuration {
let mut object_109 = object.key("LoggingConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_logging_configuration(
&mut object_109,
var_108,
);
object_109.finish();
}
}
pub fn serialize_structure_crate_input_update_rule_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRuleGroupInput,
) {
if let Some(var_110) = &input.update_token {
object.key("UpdateToken").string(var_110);
}
if let Some(var_111) = &input.rule_group_arn {
object.key("RuleGroupArn").string(var_111);
}
if let Some(var_112) = &input.rule_group_name {
object.key("RuleGroupName").string(var_112);
}
if let Some(var_113) = &input.rule_group {
let mut object_114 = object.key("RuleGroup").start_object();
crate::json_ser::serialize_structure_crate_model_rule_group(&mut object_114, var_113);
object_114.finish();
}
if let Some(var_115) = &input.rules {
object.key("Rules").string(var_115);
}
if let Some(var_116) = &input.r#type {
object.key("Type").string(var_116.as_str());
}
if let Some(var_117) = &input.description {
object.key("Description").string(var_117);
}
if input.dry_run {
object.key("DryRun").boolean(input.dry_run);
}
}
pub fn serialize_structure_crate_input_update_subnet_change_protection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSubnetChangeProtectionInput,
) {
if let Some(var_118) = &input.update_token {
object.key("UpdateToken").string(var_118);
}
if let Some(var_119) = &input.firewall_arn {
object.key("FirewallArn").string(var_119);
}
if let Some(var_120) = &input.firewall_name {
object.key("FirewallName").string(var_120);
}
{
object
.key("SubnetChangeProtection")
.boolean(input.subnet_change_protection);
}
}
pub fn serialize_structure_crate_model_subnet_mapping(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SubnetMapping,
) {
if let Some(var_121) = &input.subnet_id {
object.key("SubnetId").string(var_121);
}
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) {
if let Some(var_122) = &input.key {
object.key("Key").string(var_122);
}
if let Some(var_123) = &input.value {
object.key("Value").string(var_123);
}
}
pub fn serialize_structure_crate_model_firewall_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FirewallPolicy,
) {
if let Some(var_124) = &input.stateless_rule_group_references {
let mut array_125 = object.key("StatelessRuleGroupReferences").start_array();
for item_126 in var_124 {
{
let mut object_127 = array_125.value().start_object();
crate::json_ser::serialize_structure_crate_model_stateless_rule_group_reference(
&mut object_127,
item_126,
);
object_127.finish();
}
}
array_125.finish();
}
if let Some(var_128) = &input.stateless_default_actions {
let mut array_129 = object.key("StatelessDefaultActions").start_array();
for item_130 in var_128 {
{
array_129.value().string(item_130);
}
}
array_129.finish();
}
if let Some(var_131) = &input.stateless_fragment_default_actions {
let mut array_132 = object.key("StatelessFragmentDefaultActions").start_array();
for item_133 in var_131 {
{
array_132.value().string(item_133);
}
}
array_132.finish();
}
if let Some(var_134) = &input.stateless_custom_actions {
let mut array_135 = object.key("StatelessCustomActions").start_array();
for item_136 in var_134 {
{
let mut object_137 = array_135.value().start_object();
crate::json_ser::serialize_structure_crate_model_custom_action(
&mut object_137,
item_136,
);
object_137.finish();
}
}
array_135.finish();
}
if let Some(var_138) = &input.stateful_rule_group_references {
let mut array_139 = object.key("StatefulRuleGroupReferences").start_array();
for item_140 in var_138 {
{
let mut object_141 = array_139.value().start_object();
crate::json_ser::serialize_structure_crate_model_stateful_rule_group_reference(
&mut object_141,
item_140,
);
object_141.finish();
}
}
array_139.finish();
}
if let Some(var_142) = &input.stateful_default_actions {
let mut array_143 = object.key("StatefulDefaultActions").start_array();
for item_144 in var_142 {
{
array_143.value().string(item_144);
}
}
array_143.finish();
}
if let Some(var_145) = &input.stateful_engine_options {
let mut object_146 = object.key("StatefulEngineOptions").start_object();
crate::json_ser::serialize_structure_crate_model_stateful_engine_options(
&mut object_146,
var_145,
);
object_146.finish();
}
}
pub fn serialize_structure_crate_model_rule_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleGroup,
) {
if let Some(var_147) = &input.rule_variables {
let mut object_148 = object.key("RuleVariables").start_object();
crate::json_ser::serialize_structure_crate_model_rule_variables(&mut object_148, var_147);
object_148.finish();
}
if let Some(var_149) = &input.rules_source {
let mut object_150 = object.key("RulesSource").start_object();
crate::json_ser::serialize_structure_crate_model_rules_source(&mut object_150, var_149);
object_150.finish();
}
if let Some(var_151) = &input.stateful_rule_options {
let mut object_152 = object.key("StatefulRuleOptions").start_object();
crate::json_ser::serialize_structure_crate_model_stateful_rule_options(
&mut object_152,
var_151,
);
object_152.finish();
}
}
pub fn serialize_structure_crate_model_logging_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoggingConfiguration,
) {
if let Some(var_153) = &input.log_destination_configs {
let mut array_154 = object.key("LogDestinationConfigs").start_array();
for item_155 in var_153 {
{
let mut object_156 = array_154.value().start_object();
crate::json_ser::serialize_structure_crate_model_log_destination_config(
&mut object_156,
item_155,
);
object_156.finish();
}
}
array_154.finish();
}
}
pub fn serialize_structure_crate_model_stateless_rule_group_reference(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatelessRuleGroupReference,
) {
if let Some(var_157) = &input.resource_arn {
object.key("ResourceArn").string(var_157);
}
{
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.priority).into()),
);
}
}
pub fn serialize_structure_crate_model_custom_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomAction,
) {
if let Some(var_158) = &input.action_name {
object.key("ActionName").string(var_158);
}
if let Some(var_159) = &input.action_definition {
let mut object_160 = object.key("ActionDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_action_definition(
&mut object_160,
var_159,
);
object_160.finish();
}
}
pub fn serialize_structure_crate_model_stateful_rule_group_reference(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatefulRuleGroupReference,
) {
if let Some(var_161) = &input.resource_arn {
object.key("ResourceArn").string(var_161);
}
if let Some(var_162) = &input.priority {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_162).into()),
);
}
}
pub fn serialize_structure_crate_model_stateful_engine_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatefulEngineOptions,
) {
if let Some(var_163) = &input.rule_order {
object.key("RuleOrder").string(var_163.as_str());
}
}
pub fn serialize_structure_crate_model_rule_variables(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleVariables,
) {
if let Some(var_164) = &input.ip_sets {
let mut object_165 = object.key("IPSets").start_object();
for (key_166, value_167) in var_164 {
{
let mut object_168 = object_165.key(key_166).start_object();
crate::json_ser::serialize_structure_crate_model_ip_set(&mut object_168, value_167);
object_168.finish();
}
}
object_165.finish();
}
if let Some(var_169) = &input.port_sets {
let mut object_170 = object.key("PortSets").start_object();
for (key_171, value_172) in var_169 {
{
let mut object_173 = object_170.key(key_171).start_object();
crate::json_ser::serialize_structure_crate_model_port_set(
&mut object_173,
value_172,
);
object_173.finish();
}
}
object_170.finish();
}
}
pub fn serialize_structure_crate_model_rules_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RulesSource,
) {
if let Some(var_174) = &input.rules_string {
object.key("RulesString").string(var_174);
}
if let Some(var_175) = &input.rules_source_list {
let mut object_176 = object.key("RulesSourceList").start_object();
crate::json_ser::serialize_structure_crate_model_rules_source_list(
&mut object_176,
var_175,
);
object_176.finish();
}
if let Some(var_177) = &input.stateful_rules {
let mut array_178 = object.key("StatefulRules").start_array();
for item_179 in var_177 {
{
let mut object_180 = array_178.value().start_object();
crate::json_ser::serialize_structure_crate_model_stateful_rule(
&mut object_180,
item_179,
);
object_180.finish();
}
}
array_178.finish();
}
if let Some(var_181) = &input.stateless_rules_and_custom_actions {
let mut object_182 = object.key("StatelessRulesAndCustomActions").start_object();
crate::json_ser::serialize_structure_crate_model_stateless_rules_and_custom_actions(
&mut object_182,
var_181,
);
object_182.finish();
}
}
pub fn serialize_structure_crate_model_stateful_rule_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatefulRuleOptions,
) {
if let Some(var_183) = &input.rule_order {
object.key("RuleOrder").string(var_183.as_str());
}
}
pub fn serialize_structure_crate_model_log_destination_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LogDestinationConfig,
) {
if let Some(var_184) = &input.log_type {
object.key("LogType").string(var_184.as_str());
}
if let Some(var_185) = &input.log_destination_type {
object.key("LogDestinationType").string(var_185.as_str());
}
if let Some(var_186) = &input.log_destination {
let mut object_187 = object.key("LogDestination").start_object();
for (key_188, value_189) in var_186 {
{
object_187.key(key_188).string(value_189);
}
}
object_187.finish();
}
}
pub fn serialize_structure_crate_model_action_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionDefinition,
) {
if let Some(var_190) = &input.publish_metric_action {
let mut object_191 = object.key("PublishMetricAction").start_object();
crate::json_ser::serialize_structure_crate_model_publish_metric_action(
&mut object_191,
var_190,
);
object_191.finish();
}
}
pub fn serialize_structure_crate_model_ip_set(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IpSet,
) {
if let Some(var_192) = &input.definition {
let mut array_193 = object.key("Definition").start_array();
for item_194 in var_192 {
{
array_193.value().string(item_194);
}
}
array_193.finish();
}
}
pub fn serialize_structure_crate_model_port_set(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PortSet,
) {
if let Some(var_195) = &input.definition {
let mut array_196 = object.key("Definition").start_array();
for item_197 in var_195 {
{
array_196.value().string(item_197);
}
}
array_196.finish();
}
}
pub fn serialize_structure_crate_model_rules_source_list(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RulesSourceList,
) {
if let Some(var_198) = &input.targets {
let mut array_199 = object.key("Targets").start_array();
for item_200 in var_198 {
{
array_199.value().string(item_200);
}
}
array_199.finish();
}
if let Some(var_201) = &input.target_types {
let mut array_202 = object.key("TargetTypes").start_array();
for item_203 in var_201 {
{
array_202.value().string(item_203.as_str());
}
}
array_202.finish();
}
if let Some(var_204) = &input.generated_rules_type {
object.key("GeneratedRulesType").string(var_204.as_str());
}
}
pub fn serialize_structure_crate_model_stateful_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatefulRule,
) {
if let Some(var_205) = &input.action {
object.key("Action").string(var_205.as_str());
}
if let Some(var_206) = &input.header {
let mut object_207 = object.key("Header").start_object();
crate::json_ser::serialize_structure_crate_model_header(&mut object_207, var_206);
object_207.finish();
}
if let Some(var_208) = &input.rule_options {
let mut array_209 = object.key("RuleOptions").start_array();
for item_210 in var_208 {
{
let mut object_211 = array_209.value().start_object();
crate::json_ser::serialize_structure_crate_model_rule_option(
&mut object_211,
item_210,
);
object_211.finish();
}
}
array_209.finish();
}
}
pub fn serialize_structure_crate_model_stateless_rules_and_custom_actions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatelessRulesAndCustomActions,
) {
if let Some(var_212) = &input.stateless_rules {
let mut array_213 = object.key("StatelessRules").start_array();
for item_214 in var_212 {
{
let mut object_215 = array_213.value().start_object();
crate::json_ser::serialize_structure_crate_model_stateless_rule(
&mut object_215,
item_214,
);
object_215.finish();
}
}
array_213.finish();
}
if let Some(var_216) = &input.custom_actions {
let mut array_217 = object.key("CustomActions").start_array();
for item_218 in var_216 {
{
let mut object_219 = array_217.value().start_object();
crate::json_ser::serialize_structure_crate_model_custom_action(
&mut object_219,
item_218,
);
object_219.finish();
}
}
array_217.finish();
}
}
pub fn serialize_structure_crate_model_publish_metric_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PublishMetricAction,
) {
if let Some(var_220) = &input.dimensions {
let mut array_221 = object.key("Dimensions").start_array();
for item_222 in var_220 {
{
let mut object_223 = array_221.value().start_object();
crate::json_ser::serialize_structure_crate_model_dimension(
&mut object_223,
item_222,
);
object_223.finish();
}
}
array_221.finish();
}
}
pub fn serialize_structure_crate_model_header(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Header,
) {
if let Some(var_224) = &input.protocol {
object.key("Protocol").string(var_224.as_str());
}
if let Some(var_225) = &input.source {
object.key("Source").string(var_225);
}
if let Some(var_226) = &input.source_port {
object.key("SourcePort").string(var_226);
}
if let Some(var_227) = &input.direction {
object.key("Direction").string(var_227.as_str());
}
if let Some(var_228) = &input.destination {
object.key("Destination").string(var_228);
}
if let Some(var_229) = &input.destination_port {
object.key("DestinationPort").string(var_229);
}
}
pub fn serialize_structure_crate_model_rule_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleOption,
) {
if let Some(var_230) = &input.keyword {
object.key("Keyword").string(var_230);
}
if let Some(var_231) = &input.settings {
let mut array_232 = object.key("Settings").start_array();
for item_233 in var_231 {
{
array_232.value().string(item_233);
}
}
array_232.finish();
}
}
pub fn serialize_structure_crate_model_stateless_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatelessRule,
) {
if let Some(var_234) = &input.rule_definition {
let mut object_235 = object.key("RuleDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_rule_definition(&mut object_235, var_234);
object_235.finish();
}
{
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.priority).into()),
);
}
}
pub fn serialize_structure_crate_model_dimension(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Dimension,
) {
if let Some(var_236) = &input.value {
object.key("Value").string(var_236);
}
}
pub fn serialize_structure_crate_model_rule_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleDefinition,
) {
if let Some(var_237) = &input.match_attributes {
let mut object_238 = object.key("MatchAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_match_attributes(&mut object_238, var_237);
object_238.finish();
}
if let Some(var_239) = &input.actions {
let mut array_240 = object.key("Actions").start_array();
for item_241 in var_239 {
{
array_240.value().string(item_241);
}
}
array_240.finish();
}
}
pub fn serialize_structure_crate_model_match_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MatchAttributes,
) {
if let Some(var_242) = &input.sources {
let mut array_243 = object.key("Sources").start_array();
for item_244 in var_242 {
{
let mut object_245 = array_243.value().start_object();
crate::json_ser::serialize_structure_crate_model_address(&mut object_245, item_244);
object_245.finish();
}
}
array_243.finish();
}
if let Some(var_246) = &input.destinations {
let mut array_247 = object.key("Destinations").start_array();
for item_248 in var_246 {
{
let mut object_249 = array_247.value().start_object();
crate::json_ser::serialize_structure_crate_model_address(&mut object_249, item_248);
object_249.finish();
}
}
array_247.finish();
}
if let Some(var_250) = &input.source_ports {
let mut array_251 = object.key("SourcePorts").start_array();
for item_252 in var_250 {
{
let mut object_253 = array_251.value().start_object();
crate::json_ser::serialize_structure_crate_model_port_range(
&mut object_253,
item_252,
);
object_253.finish();
}
}
array_251.finish();
}
if let Some(var_254) = &input.destination_ports {
let mut array_255 = object.key("DestinationPorts").start_array();
for item_256 in var_254 {
{
let mut object_257 = array_255.value().start_object();
crate::json_ser::serialize_structure_crate_model_port_range(
&mut object_257,
item_256,
);
object_257.finish();
}
}
array_255.finish();
}
if let Some(var_258) = &input.protocols {
let mut array_259 = object.key("Protocols").start_array();
for item_260 in var_258 {
{
array_259.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_260).into()),
);
}
}
array_259.finish();
}
if let Some(var_261) = &input.tcp_flags {
let mut array_262 = object.key("TCPFlags").start_array();
for item_263 in var_261 {
{
let mut object_264 = array_262.value().start_object();
crate::json_ser::serialize_structure_crate_model_tcp_flag_field(
&mut object_264,
item_263,
);
object_264.finish();
}
}
array_262.finish();
}
}
pub fn serialize_structure_crate_model_address(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Address,
) {
if let Some(var_265) = &input.address_definition {
object.key("AddressDefinition").string(var_265);
}
}
pub fn serialize_structure_crate_model_port_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PortRange,
) {
{
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()),
);
}
}
pub fn serialize_structure_crate_model_tcp_flag_field(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TcpFlagField,
) {
if let Some(var_266) = &input.flags {
let mut array_267 = object.key("Flags").start_array();
for item_268 in var_266 {
{
array_267.value().string(item_268.as_str());
}
}
array_267.finish();
}
if let Some(var_269) = &input.masks {
let mut array_270 = object.key("Masks").start_array();
for item_271 in var_269 {
{
array_270.value().string(item_271.as_str());
}
}
array_270.finish();
}
}