pub fn serialize_structure_crate_input_associate_firewall_rule_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateFirewallRuleGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.creator_request_id {
object.key("CreatorRequestId").string(var_1.as_str());
}
if let Some(var_2) = &input.firewall_rule_group_id {
object.key("FirewallRuleGroupId").string(var_2.as_str());
}
if let Some(var_3) = &input.vpc_id {
object.key("VpcId").string(var_3.as_str());
}
if let Some(var_4) = &input.priority {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_4).into()),
);
}
if let Some(var_5) = &input.name {
object.key("Name").string(var_5.as_str());
}
if let Some(var_6) = &input.mutation_protection {
object.key("MutationProtection").string(var_6.as_str());
}
if let Some(var_7) = &input.tags {
let mut array_8 = object.key("Tags").start_array();
for item_9 in var_7 {
{
#[allow(unused_mut)]
let mut object_10 = array_8.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_10, item_9)?;
object_10.finish();
}
}
array_8.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_resolver_endpoint_ip_address_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateResolverEndpointIpAddressInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_11) = &input.resolver_endpoint_id {
object.key("ResolverEndpointId").string(var_11.as_str());
}
if let Some(var_12) = &input.ip_address {
#[allow(unused_mut)]
let mut object_13 = object.key("IpAddress").start_object();
crate::json_ser::serialize_structure_crate_model_ip_address_update(&mut object_13, var_12)?;
object_13.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_resolver_query_log_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateResolverQueryLogConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.resolver_query_log_config_id {
object
.key("ResolverQueryLogConfigId")
.string(var_14.as_str());
}
if let Some(var_15) = &input.resource_id {
object.key("ResourceId").string(var_15.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_resolver_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateResolverRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.resolver_rule_id {
object.key("ResolverRuleId").string(var_16.as_str());
}
if let Some(var_17) = &input.name {
object.key("Name").string(var_17.as_str());
}
if let Some(var_18) = &input.vpc_id {
object.key("VPCId").string(var_18.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_firewall_domain_list_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFirewallDomainListInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_19) = &input.creator_request_id {
object.key("CreatorRequestId").string(var_19.as_str());
}
if let Some(var_20) = &input.name {
object.key("Name").string(var_20.as_str());
}
if let Some(var_21) = &input.tags {
let mut array_22 = object.key("Tags").start_array();
for item_23 in var_21 {
{
#[allow(unused_mut)]
let mut object_24 = array_22.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_24, item_23)?;
object_24.finish();
}
}
array_22.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_firewall_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFirewallRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_25) = &input.creator_request_id {
object.key("CreatorRequestId").string(var_25.as_str());
}
if let Some(var_26) = &input.firewall_rule_group_id {
object.key("FirewallRuleGroupId").string(var_26.as_str());
}
if let Some(var_27) = &input.firewall_domain_list_id {
object.key("FirewallDomainListId").string(var_27.as_str());
}
if let Some(var_28) = &input.priority {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_28).into()),
);
}
if let Some(var_29) = &input.action {
object.key("Action").string(var_29.as_str());
}
if let Some(var_30) = &input.block_response {
object.key("BlockResponse").string(var_30.as_str());
}
if let Some(var_31) = &input.block_override_domain {
object.key("BlockOverrideDomain").string(var_31.as_str());
}
if let Some(var_32) = &input.block_override_dns_type {
object.key("BlockOverrideDnsType").string(var_32.as_str());
}
if let Some(var_33) = &input.block_override_ttl {
object.key("BlockOverrideTtl").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_33).into()),
);
}
if let Some(var_34) = &input.name {
object.key("Name").string(var_34.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_firewall_rule_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFirewallRuleGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.creator_request_id {
object.key("CreatorRequestId").string(var_35.as_str());
}
if let Some(var_36) = &input.name {
object.key("Name").string(var_36.as_str());
}
if let Some(var_37) = &input.tags {
let mut array_38 = object.key("Tags").start_array();
for item_39 in var_37 {
{
#[allow(unused_mut)]
let mut object_40 = array_38.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_40, item_39)?;
object_40.finish();
}
}
array_38.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_resolver_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateResolverEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_41) = &input.creator_request_id {
object.key("CreatorRequestId").string(var_41.as_str());
}
if let Some(var_42) = &input.name {
object.key("Name").string(var_42.as_str());
}
if let Some(var_43) = &input.security_group_ids {
let mut array_44 = object.key("SecurityGroupIds").start_array();
for item_45 in var_43 {
{
array_44.value().string(item_45.as_str());
}
}
array_44.finish();
}
if let Some(var_46) = &input.direction {
object.key("Direction").string(var_46.as_str());
}
if let Some(var_47) = &input.ip_addresses {
let mut array_48 = object.key("IpAddresses").start_array();
for item_49 in var_47 {
{
#[allow(unused_mut)]
let mut object_50 = array_48.value().start_object();
crate::json_ser::serialize_structure_crate_model_ip_address_request(
&mut object_50,
item_49,
)?;
object_50.finish();
}
}
array_48.finish();
}
if let Some(var_51) = &input.tags {
let mut array_52 = object.key("Tags").start_array();
for item_53 in var_51 {
{
#[allow(unused_mut)]
let mut object_54 = array_52.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_54, item_53)?;
object_54.finish();
}
}
array_52.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_resolver_query_log_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateResolverQueryLogConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_55) = &input.name {
object.key("Name").string(var_55.as_str());
}
if let Some(var_56) = &input.destination_arn {
object.key("DestinationArn").string(var_56.as_str());
}
if let Some(var_57) = &input.creator_request_id {
object.key("CreatorRequestId").string(var_57.as_str());
}
if let Some(var_58) = &input.tags {
let mut array_59 = object.key("Tags").start_array();
for item_60 in var_58 {
{
#[allow(unused_mut)]
let mut object_61 = array_59.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_61, item_60)?;
object_61.finish();
}
}
array_59.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_resolver_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateResolverRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_62) = &input.creator_request_id {
object.key("CreatorRequestId").string(var_62.as_str());
}
if let Some(var_63) = &input.name {
object.key("Name").string(var_63.as_str());
}
if let Some(var_64) = &input.rule_type {
object.key("RuleType").string(var_64.as_str());
}
if let Some(var_65) = &input.domain_name {
object.key("DomainName").string(var_65.as_str());
}
if let Some(var_66) = &input.target_ips {
let mut array_67 = object.key("TargetIps").start_array();
for item_68 in var_66 {
{
#[allow(unused_mut)]
let mut object_69 = array_67.value().start_object();
crate::json_ser::serialize_structure_crate_model_target_address(
&mut object_69,
item_68,
)?;
object_69.finish();
}
}
array_67.finish();
}
if let Some(var_70) = &input.resolver_endpoint_id {
object.key("ResolverEndpointId").string(var_70.as_str());
}
if let Some(var_71) = &input.tags {
let mut array_72 = object.key("Tags").start_array();
for item_73 in var_71 {
{
#[allow(unused_mut)]
let mut object_74 = array_72.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_74, item_73)?;
object_74.finish();
}
}
array_72.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_firewall_domain_list_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteFirewallDomainListInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_75) = &input.firewall_domain_list_id {
object.key("FirewallDomainListId").string(var_75.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_firewall_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteFirewallRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_76) = &input.firewall_rule_group_id {
object.key("FirewallRuleGroupId").string(var_76.as_str());
}
if let Some(var_77) = &input.firewall_domain_list_id {
object.key("FirewallDomainListId").string(var_77.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_firewall_rule_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteFirewallRuleGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_78) = &input.firewall_rule_group_id {
object.key("FirewallRuleGroupId").string(var_78.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_resolver_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteResolverEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_79) = &input.resolver_endpoint_id {
object.key("ResolverEndpointId").string(var_79.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_resolver_query_log_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteResolverQueryLogConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.resolver_query_log_config_id {
object
.key("ResolverQueryLogConfigId")
.string(var_80.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_resolver_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteResolverRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.resolver_rule_id {
object.key("ResolverRuleId").string(var_81.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_firewall_rule_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateFirewallRuleGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_82) = &input.firewall_rule_group_association_id {
object
.key("FirewallRuleGroupAssociationId")
.string(var_82.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_resolver_endpoint_ip_address_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateResolverEndpointIpAddressInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_83) = &input.resolver_endpoint_id {
object.key("ResolverEndpointId").string(var_83.as_str());
}
if let Some(var_84) = &input.ip_address {
#[allow(unused_mut)]
let mut object_85 = object.key("IpAddress").start_object();
crate::json_ser::serialize_structure_crate_model_ip_address_update(&mut object_85, var_84)?;
object_85.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_resolver_query_log_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateResolverQueryLogConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_86) = &input.resolver_query_log_config_id {
object
.key("ResolverQueryLogConfigId")
.string(var_86.as_str());
}
if let Some(var_87) = &input.resource_id {
object.key("ResourceId").string(var_87.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_resolver_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateResolverRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_88) = &input.vpc_id {
object.key("VPCId").string(var_88.as_str());
}
if let Some(var_89) = &input.resolver_rule_id {
object.key("ResolverRuleId").string(var_89.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_firewall_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetFirewallConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_90) = &input.resource_id {
object.key("ResourceId").string(var_90.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_firewall_domain_list_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetFirewallDomainListInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_91) = &input.firewall_domain_list_id {
object.key("FirewallDomainListId").string(var_91.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_firewall_rule_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetFirewallRuleGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_92) = &input.firewall_rule_group_id {
object.key("FirewallRuleGroupId").string(var_92.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_firewall_rule_group_association_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetFirewallRuleGroupAssociationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.firewall_rule_group_association_id {
object
.key("FirewallRuleGroupAssociationId")
.string(var_93.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_firewall_rule_group_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetFirewallRuleGroupPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_94) = &input.arn {
object.key("Arn").string(var_94.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_resolver_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetResolverConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_95) = &input.resource_id {
object.key("ResourceId").string(var_95.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_resolver_dnssec_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetResolverDnssecConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_96) = &input.resource_id {
object.key("ResourceId").string(var_96.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_resolver_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetResolverEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.resolver_endpoint_id {
object.key("ResolverEndpointId").string(var_97.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_resolver_query_log_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetResolverQueryLogConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_98) = &input.resolver_query_log_config_id {
object
.key("ResolverQueryLogConfigId")
.string(var_98.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_resolver_query_log_config_association_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetResolverQueryLogConfigAssociationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_99) = &input.resolver_query_log_config_association_id {
object
.key("ResolverQueryLogConfigAssociationId")
.string(var_99.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_resolver_query_log_config_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetResolverQueryLogConfigPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_100) = &input.arn {
object.key("Arn").string(var_100.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_resolver_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetResolverRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.resolver_rule_id {
object.key("ResolverRuleId").string(var_101.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_resolver_rule_association_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetResolverRuleAssociationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_102) = &input.resolver_rule_association_id {
object
.key("ResolverRuleAssociationId")
.string(var_102.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_resolver_rule_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetResolverRulePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_103) = &input.arn {
object.key("Arn").string(var_103.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_import_firewall_domains_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ImportFirewallDomainsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_104) = &input.firewall_domain_list_id {
object.key("FirewallDomainListId").string(var_104.as_str());
}
if let Some(var_105) = &input.operation {
object.key("Operation").string(var_105.as_str());
}
if let Some(var_106) = &input.domain_file_url {
object.key("DomainFileUrl").string(var_106.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_firewall_configs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFirewallConfigsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_107) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_107).into()),
);
}
if let Some(var_108) = &input.next_token {
object.key("NextToken").string(var_108.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_firewall_domain_lists_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFirewallDomainListsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_109) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_109).into()),
);
}
if let Some(var_110) = &input.next_token {
object.key("NextToken").string(var_110.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_firewall_domains_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFirewallDomainsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_111) = &input.firewall_domain_list_id {
object.key("FirewallDomainListId").string(var_111.as_str());
}
if let Some(var_112) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_112).into()),
);
}
if let Some(var_113) = &input.next_token {
object.key("NextToken").string(var_113.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_firewall_rule_group_associations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFirewallRuleGroupAssociationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_114) = &input.firewall_rule_group_id {
object.key("FirewallRuleGroupId").string(var_114.as_str());
}
if let Some(var_115) = &input.vpc_id {
object.key("VpcId").string(var_115.as_str());
}
if let Some(var_116) = &input.priority {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_116).into()),
);
}
if let Some(var_117) = &input.status {
object.key("Status").string(var_117.as_str());
}
if let Some(var_118) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_118).into()),
);
}
if let Some(var_119) = &input.next_token {
object.key("NextToken").string(var_119.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_firewall_rule_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFirewallRuleGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_120) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_120).into()),
);
}
if let Some(var_121) = &input.next_token {
object.key("NextToken").string(var_121.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_firewall_rules_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFirewallRulesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_122) = &input.firewall_rule_group_id {
object.key("FirewallRuleGroupId").string(var_122.as_str());
}
if let Some(var_123) = &input.priority {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_123).into()),
);
}
if let Some(var_124) = &input.action {
object.key("Action").string(var_124.as_str());
}
if let Some(var_125) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_125).into()),
);
}
if let Some(var_126) = &input.next_token {
object.key("NextToken").string(var_126.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_resolver_configs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListResolverConfigsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_127) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_127).into()),
);
}
if let Some(var_128) = &input.next_token {
object.key("NextToken").string(var_128.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_resolver_dnssec_configs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListResolverDnssecConfigsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_129) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_129).into()),
);
}
if let Some(var_130) = &input.next_token {
object.key("NextToken").string(var_130.as_str());
}
if let Some(var_131) = &input.filters {
let mut array_132 = object.key("Filters").start_array();
for item_133 in var_131 {
{
#[allow(unused_mut)]
let mut object_134 = array_132.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_134, item_133)?;
object_134.finish();
}
}
array_132.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_resolver_endpoint_ip_addresses_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListResolverEndpointIpAddressesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_135) = &input.resolver_endpoint_id {
object.key("ResolverEndpointId").string(var_135.as_str());
}
if let Some(var_136) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_136).into()),
);
}
if let Some(var_137) = &input.next_token {
object.key("NextToken").string(var_137.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_resolver_endpoints_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListResolverEndpointsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_138) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_138).into()),
);
}
if let Some(var_139) = &input.next_token {
object.key("NextToken").string(var_139.as_str());
}
if let Some(var_140) = &input.filters {
let mut array_141 = object.key("Filters").start_array();
for item_142 in var_140 {
{
#[allow(unused_mut)]
let mut object_143 = array_141.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_143, item_142)?;
object_143.finish();
}
}
array_141.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_resolver_query_log_config_associations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListResolverQueryLogConfigAssociationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_144) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_144).into()),
);
}
if let Some(var_145) = &input.next_token {
object.key("NextToken").string(var_145.as_str());
}
if let Some(var_146) = &input.filters {
let mut array_147 = object.key("Filters").start_array();
for item_148 in var_146 {
{
#[allow(unused_mut)]
let mut object_149 = array_147.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_149, item_148)?;
object_149.finish();
}
}
array_147.finish();
}
if let Some(var_150) = &input.sort_by {
object.key("SortBy").string(var_150.as_str());
}
if let Some(var_151) = &input.sort_order {
object.key("SortOrder").string(var_151.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_resolver_query_log_configs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListResolverQueryLogConfigsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_152) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_152).into()),
);
}
if let Some(var_153) = &input.next_token {
object.key("NextToken").string(var_153.as_str());
}
if let Some(var_154) = &input.filters {
let mut array_155 = object.key("Filters").start_array();
for item_156 in var_154 {
{
#[allow(unused_mut)]
let mut object_157 = array_155.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_157, item_156)?;
object_157.finish();
}
}
array_155.finish();
}
if let Some(var_158) = &input.sort_by {
object.key("SortBy").string(var_158.as_str());
}
if let Some(var_159) = &input.sort_order {
object.key("SortOrder").string(var_159.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_resolver_rule_associations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListResolverRuleAssociationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_160) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_160).into()),
);
}
if let Some(var_161) = &input.next_token {
object.key("NextToken").string(var_161.as_str());
}
if let Some(var_162) = &input.filters {
let mut array_163 = object.key("Filters").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_filter(&mut object_165, item_164)?;
object_165.finish();
}
}
array_163.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_resolver_rules_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListResolverRulesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_166) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_166).into()),
);
}
if let Some(var_167) = &input.next_token {
object.key("NextToken").string(var_167.as_str());
}
if let Some(var_168) = &input.filters {
let mut array_169 = object.key("Filters").start_array();
for item_170 in var_168 {
{
#[allow(unused_mut)]
let mut object_171 = array_169.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_171, item_170)?;
object_171.finish();
}
}
array_169.finish();
}
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_172) = &input.resource_arn {
object.key("ResourceArn").string(var_172.as_str());
}
if let Some(var_173) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_173).into()),
);
}
if let Some(var_174) = &input.next_token {
object.key("NextToken").string(var_174.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_firewall_rule_group_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutFirewallRuleGroupPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_175) = &input.arn {
object.key("Arn").string(var_175.as_str());
}
if let Some(var_176) = &input.firewall_rule_group_policy {
object
.key("FirewallRuleGroupPolicy")
.string(var_176.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_resolver_query_log_config_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutResolverQueryLogConfigPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_177) = &input.arn {
object.key("Arn").string(var_177.as_str());
}
if let Some(var_178) = &input.resolver_query_log_config_policy {
object
.key("ResolverQueryLogConfigPolicy")
.string(var_178.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_resolver_rule_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutResolverRulePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_179) = &input.arn {
object.key("Arn").string(var_179.as_str());
}
if let Some(var_180) = &input.resolver_rule_policy {
object.key("ResolverRulePolicy").string(var_180.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_181) = &input.resource_arn {
object.key("ResourceArn").string(var_181.as_str());
}
if let Some(var_182) = &input.tags {
let mut array_183 = object.key("Tags").start_array();
for item_184 in var_182 {
{
#[allow(unused_mut)]
let mut object_185 = array_183.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_185, item_184)?;
object_185.finish();
}
}
array_183.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_186) = &input.resource_arn {
object.key("ResourceArn").string(var_186.as_str());
}
if let Some(var_187) = &input.tag_keys {
let mut array_188 = object.key("TagKeys").start_array();
for item_189 in var_187 {
{
array_188.value().string(item_189.as_str());
}
}
array_188.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_firewall_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFirewallConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_190) = &input.resource_id {
object.key("ResourceId").string(var_190.as_str());
}
if let Some(var_191) = &input.firewall_fail_open {
object.key("FirewallFailOpen").string(var_191.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_firewall_domains_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFirewallDomainsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_192) = &input.firewall_domain_list_id {
object.key("FirewallDomainListId").string(var_192.as_str());
}
if let Some(var_193) = &input.operation {
object.key("Operation").string(var_193.as_str());
}
if let Some(var_194) = &input.domains {
let mut array_195 = object.key("Domains").start_array();
for item_196 in var_194 {
{
array_195.value().string(item_196.as_str());
}
}
array_195.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_firewall_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFirewallRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.firewall_rule_group_id {
object.key("FirewallRuleGroupId").string(var_197.as_str());
}
if let Some(var_198) = &input.firewall_domain_list_id {
object.key("FirewallDomainListId").string(var_198.as_str());
}
if let Some(var_199) = &input.priority {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_199).into()),
);
}
if let Some(var_200) = &input.action {
object.key("Action").string(var_200.as_str());
}
if let Some(var_201) = &input.block_response {
object.key("BlockResponse").string(var_201.as_str());
}
if let Some(var_202) = &input.block_override_domain {
object.key("BlockOverrideDomain").string(var_202.as_str());
}
if let Some(var_203) = &input.block_override_dns_type {
object.key("BlockOverrideDnsType").string(var_203.as_str());
}
if let Some(var_204) = &input.block_override_ttl {
object.key("BlockOverrideTtl").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_204).into()),
);
}
if let Some(var_205) = &input.name {
object.key("Name").string(var_205.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_firewall_rule_group_association_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFirewallRuleGroupAssociationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_206) = &input.firewall_rule_group_association_id {
object
.key("FirewallRuleGroupAssociationId")
.string(var_206.as_str());
}
if let Some(var_207) = &input.priority {
object.key("Priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_207).into()),
);
}
if let Some(var_208) = &input.mutation_protection {
object.key("MutationProtection").string(var_208.as_str());
}
if let Some(var_209) = &input.name {
object.key("Name").string(var_209.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_resolver_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateResolverConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_210) = &input.resource_id {
object.key("ResourceId").string(var_210.as_str());
}
if let Some(var_211) = &input.autodefined_reverse_flag {
object
.key("AutodefinedReverseFlag")
.string(var_211.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_resolver_dnssec_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateResolverDnssecConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_212) = &input.resource_id {
object.key("ResourceId").string(var_212.as_str());
}
if let Some(var_213) = &input.validation {
object.key("Validation").string(var_213.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_resolver_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateResolverEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_214) = &input.resolver_endpoint_id {
object.key("ResolverEndpointId").string(var_214.as_str());
}
if let Some(var_215) = &input.name {
object.key("Name").string(var_215.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_resolver_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateResolverRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_216) = &input.resolver_rule_id {
object.key("ResolverRuleId").string(var_216.as_str());
}
if let Some(var_217) = &input.config {
#[allow(unused_mut)]
let mut object_218 = object.key("Config").start_object();
crate::json_ser::serialize_structure_crate_model_resolver_rule_config(
&mut object_218,
var_217,
)?;
object_218.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_219) = &input.key {
object.key("Key").string(var_219.as_str());
}
if let Some(var_220) = &input.value {
object.key("Value").string(var_220.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ip_address_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IpAddressUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_221) = &input.ip_id {
object.key("IpId").string(var_221.as_str());
}
if let Some(var_222) = &input.subnet_id {
object.key("SubnetId").string(var_222.as_str());
}
if let Some(var_223) = &input.ip {
object.key("Ip").string(var_223.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ip_address_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IpAddressRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_224) = &input.subnet_id {
object.key("SubnetId").string(var_224.as_str());
}
if let Some(var_225) = &input.ip {
object.key("Ip").string(var_225.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_target_address(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TargetAddress,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_226) = &input.ip {
object.key("Ip").string(var_226.as_str());
}
if let Some(var_227) = &input.port {
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_227).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Filter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_228) = &input.name {
object.key("Name").string(var_228.as_str());
}
if let Some(var_229) = &input.values {
let mut array_230 = object.key("Values").start_array();
for item_231 in var_229 {
{
array_230.value().string(item_231.as_str());
}
}
array_230.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_resolver_rule_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResolverRuleConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_232) = &input.name {
object.key("Name").string(var_232.as_str());
}
if let Some(var_233) = &input.target_ips {
let mut array_234 = object.key("TargetIps").start_array();
for item_235 in var_233 {
{
#[allow(unused_mut)]
let mut object_236 = array_234.value().start_object();
crate::json_ser::serialize_structure_crate_model_target_address(
&mut object_236,
item_235,
)?;
object_236.finish();
}
}
array_234.finish();
}
if let Some(var_237) = &input.resolver_endpoint_id {
object.key("ResolverEndpointId").string(var_237.as_str());
}
Ok(())
}