pub fn serialize_structure_crate_input_associate_admin_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateAdminAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.admin_account {
object.key("AdminAccount").string(var_1.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_third_party_firewall_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateThirdPartyFirewallInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2) = &input.third_party_firewall {
object.key("ThirdPartyFirewall").string(var_2.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_associate_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchAssociateResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3) = &input.resource_set_identifier {
object.key("ResourceSetIdentifier").string(var_3.as_str());
}
if let Some(var_4) = &input.items {
let mut array_5 = object.key("Items").start_array();
for item_6 in var_4 {
{
array_5.value().string(item_6.as_str());
}
}
array_5.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_disassociate_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDisassociateResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_7) = &input.resource_set_identifier {
object.key("ResourceSetIdentifier").string(var_7.as_str());
}
if let Some(var_8) = &input.items {
let mut array_9 = object.key("Items").start_array();
for item_10 in var_8 {
{
array_9.value().string(item_10.as_str());
}
}
array_9.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_apps_list_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAppsListInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_11) = &input.list_id {
object.key("ListId").string(var_11.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeletePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.policy_id {
object.key("PolicyId").string(var_12.as_str());
}
if input.delete_all_policy_resources {
object
.key("DeleteAllPolicyResources")
.boolean(input.delete_all_policy_resources);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_protocols_list_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteProtocolsListInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_13) = &input.list_id {
object.key("ListId").string(var_13.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_resource_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteResourceSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.identifier {
object.key("Identifier").string(var_14.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_third_party_firewall_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateThirdPartyFirewallInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_15) = &input.third_party_firewall {
object.key("ThirdPartyFirewall").string(var_15.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_apps_list_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAppsListInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.list_id {
object.key("ListId").string(var_16.as_str());
}
if input.default_list {
object.key("DefaultList").boolean(input.default_list);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_compliance_detail_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetComplianceDetailInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_17) = &input.policy_id {
object.key("PolicyId").string(var_17.as_str());
}
if let Some(var_18) = &input.member_account {
object.key("MemberAccount").string(var_18.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_19) = &input.policy_id {
object.key("PolicyId").string(var_19.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_protection_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetProtectionStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_20) = &input.policy_id {
object.key("PolicyId").string(var_20.as_str());
}
if let Some(var_21) = &input.member_account_id {
object.key("MemberAccountId").string(var_21.as_str());
}
if let Some(var_22) = &input.start_time {
object
.key("StartTime")
.date_time(var_22, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_23) = &input.end_time {
object
.key("EndTime")
.date_time(var_23, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_24) = &input.next_token {
object.key("NextToken").string(var_24.as_str());
}
if let Some(var_25) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_25).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_protocols_list_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetProtocolsListInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_26) = &input.list_id {
object.key("ListId").string(var_26.as_str());
}
if input.default_list {
object.key("DefaultList").boolean(input.default_list);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_resource_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetResourceSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_27) = &input.identifier {
object.key("Identifier").string(var_27.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_third_party_firewall_association_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetThirdPartyFirewallAssociationStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_28) = &input.third_party_firewall {
object.key("ThirdPartyFirewall").string(var_28.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_violation_details_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetViolationDetailsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.policy_id {
object.key("PolicyId").string(var_29.as_str());
}
if let Some(var_30) = &input.member_account {
object.key("MemberAccount").string(var_30.as_str());
}
if let Some(var_31) = &input.resource_id {
object.key("ResourceId").string(var_31.as_str());
}
if let Some(var_32) = &input.resource_type {
object.key("ResourceType").string(var_32.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_apps_lists_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAppsListsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.default_lists {
object.key("DefaultLists").boolean(input.default_lists);
}
if let Some(var_33) = &input.next_token {
object.key("NextToken").string(var_33.as_str());
}
if let Some(var_34) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_34).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_compliance_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListComplianceStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.policy_id {
object.key("PolicyId").string(var_35.as_str());
}
if let Some(var_36) = &input.next_token {
object.key("NextToken").string(var_36.as_str());
}
if let Some(var_37) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_37).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_discovered_resources_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDiscoveredResourcesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_38) = &input.member_account_ids {
let mut array_39 = object.key("MemberAccountIds").start_array();
for item_40 in var_38 {
{
array_39.value().string(item_40.as_str());
}
}
array_39.finish();
}
if let Some(var_41) = &input.resource_type {
object.key("ResourceType").string(var_41.as_str());
}
if let Some(var_42) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_42).into()),
);
}
if let Some(var_43) = &input.next_token {
object.key("NextToken").string(var_43.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_member_accounts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListMemberAccountsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_44) = &input.next_token {
object.key("NextToken").string(var_44.as_str());
}
if let Some(var_45) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_45).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_policies_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPoliciesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.next_token {
object.key("NextToken").string(var_46.as_str());
}
if let Some(var_47) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_47).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_protocols_lists_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListProtocolsListsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.default_lists {
object.key("DefaultLists").boolean(input.default_lists);
}
if let Some(var_48) = &input.next_token {
object.key("NextToken").string(var_48.as_str());
}
if let Some(var_49) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_49).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_resource_set_resources_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListResourceSetResourcesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.identifier {
object.key("Identifier").string(var_50.as_str());
}
if let Some(var_51) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_51).into()),
);
}
if let Some(var_52) = &input.next_token {
object.key("NextToken").string(var_52.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_resource_sets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListResourceSetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_53) = &input.next_token {
object.key("NextToken").string(var_53.as_str());
}
if let Some(var_54) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_54).into()),
);
}
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_55) = &input.resource_arn {
object.key("ResourceArn").string(var_55.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_third_party_firewall_firewall_policies_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListThirdPartyFirewallFirewallPoliciesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.third_party_firewall {
object.key("ThirdPartyFirewall").string(var_56.as_str());
}
if let Some(var_57) = &input.next_token {
object.key("NextToken").string(var_57.as_str());
}
if let Some(var_58) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_58).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_apps_list_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutAppsListInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_59) = &input.apps_list {
#[allow(unused_mut)]
let mut object_60 = object.key("AppsList").start_object();
crate::json_ser::serialize_structure_crate_model_apps_list_data(&mut object_60, var_59)?;
object_60.finish();
}
if let Some(var_61) = &input.tag_list {
let mut array_62 = object.key("TagList").start_array();
for item_63 in var_61 {
{
#[allow(unused_mut)]
let mut object_64 = array_62.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_64, item_63)?;
object_64.finish();
}
}
array_62.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_notification_channel_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutNotificationChannelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_65) = &input.sns_topic_arn {
object.key("SnsTopicArn").string(var_65.as_str());
}
if let Some(var_66) = &input.sns_role_name {
object.key("SnsRoleName").string(var_66.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_67) = &input.policy {
#[allow(unused_mut)]
let mut object_68 = object.key("Policy").start_object();
crate::json_ser::serialize_structure_crate_model_policy(&mut object_68, var_67)?;
object_68.finish();
}
if let Some(var_69) = &input.tag_list {
let mut array_70 = object.key("TagList").start_array();
for item_71 in var_69 {
{
#[allow(unused_mut)]
let mut object_72 = array_70.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_72, item_71)?;
object_72.finish();
}
}
array_70.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_protocols_list_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutProtocolsListInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_73) = &input.protocols_list {
#[allow(unused_mut)]
let mut object_74 = object.key("ProtocolsList").start_object();
crate::json_ser::serialize_structure_crate_model_protocols_list_data(
&mut object_74,
var_73,
)?;
object_74.finish();
}
if let Some(var_75) = &input.tag_list {
let mut array_76 = object.key("TagList").start_array();
for item_77 in var_75 {
{
#[allow(unused_mut)]
let mut object_78 = array_76.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_78, item_77)?;
object_78.finish();
}
}
array_76.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_resource_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutResourceSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_79) = &input.resource_set {
#[allow(unused_mut)]
let mut object_80 = object.key("ResourceSet").start_object();
crate::json_ser::serialize_structure_crate_model_resource_set(&mut object_80, var_79)?;
object_80.finish();
}
if let Some(var_81) = &input.tag_list {
let mut array_82 = object.key("TagList").start_array();
for item_83 in var_81 {
{
#[allow(unused_mut)]
let mut object_84 = array_82.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_84, item_83)?;
object_84.finish();
}
}
array_82.finish();
}
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_85) = &input.resource_arn {
object.key("ResourceArn").string(var_85.as_str());
}
if let Some(var_86) = &input.tag_list {
let mut array_87 = object.key("TagList").start_array();
for item_88 in var_86 {
{
#[allow(unused_mut)]
let mut object_89 = array_87.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_89, item_88)?;
object_89.finish();
}
}
array_87.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_90) = &input.resource_arn {
object.key("ResourceArn").string(var_90.as_str());
}
if let Some(var_91) = &input.tag_keys {
let mut array_92 = object.key("TagKeys").start_array();
for item_93 in var_91 {
{
array_92.value().string(item_93.as_str());
}
}
array_92.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_apps_list_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AppsListData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_94) = &input.list_id {
object.key("ListId").string(var_94.as_str());
}
if let Some(var_95) = &input.list_name {
object.key("ListName").string(var_95.as_str());
}
if let Some(var_96) = &input.list_update_token {
object.key("ListUpdateToken").string(var_96.as_str());
}
if let Some(var_97) = &input.create_time {
object
.key("CreateTime")
.date_time(var_97, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_98) = &input.last_update_time {
object
.key("LastUpdateTime")
.date_time(var_98, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_99) = &input.apps_list {
let mut array_100 = object.key("AppsList").start_array();
for item_101 in var_99 {
{
#[allow(unused_mut)]
let mut object_102 = array_100.value().start_object();
crate::json_ser::serialize_structure_crate_model_app(&mut object_102, item_101)?;
object_102.finish();
}
}
array_100.finish();
}
if let Some(var_103) = &input.previous_apps_list {
#[allow(unused_mut)]
let mut object_104 = object.key("PreviousAppsList").start_object();
for (key_105, value_106) in var_103 {
{
let mut array_107 = object_104.key(key_105.as_str()).start_array();
for item_108 in value_106 {
{
#[allow(unused_mut)]
let mut object_109 = array_107.value().start_object();
crate::json_ser::serialize_structure_crate_model_app(
&mut object_109,
item_108,
)?;
object_109.finish();
}
}
array_107.finish();
}
}
object_104.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_110) = &input.key {
object.key("Key").string(var_110.as_str());
}
if let Some(var_111) = &input.value {
object.key("Value").string(var_111.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Policy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_112) = &input.policy_id {
object.key("PolicyId").string(var_112.as_str());
}
if let Some(var_113) = &input.policy_name {
object.key("PolicyName").string(var_113.as_str());
}
if let Some(var_114) = &input.policy_update_token {
object.key("PolicyUpdateToken").string(var_114.as_str());
}
if let Some(var_115) = &input.security_service_policy_data {
#[allow(unused_mut)]
let mut object_116 = object.key("SecurityServicePolicyData").start_object();
crate::json_ser::serialize_structure_crate_model_security_service_policy_data(
&mut object_116,
var_115,
)?;
object_116.finish();
}
if let Some(var_117) = &input.resource_type {
object.key("ResourceType").string(var_117.as_str());
}
if let Some(var_118) = &input.resource_type_list {
let mut array_119 = object.key("ResourceTypeList").start_array();
for item_120 in var_118 {
{
array_119.value().string(item_120.as_str());
}
}
array_119.finish();
}
if let Some(var_121) = &input.resource_tags {
let mut array_122 = object.key("ResourceTags").start_array();
for item_123 in var_121 {
{
#[allow(unused_mut)]
let mut object_124 = array_122.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_tag(
&mut object_124,
item_123,
)?;
object_124.finish();
}
}
array_122.finish();
}
{
object
.key("ExcludeResourceTags")
.boolean(input.exclude_resource_tags);
}
{
object
.key("RemediationEnabled")
.boolean(input.remediation_enabled);
}
if input.delete_unused_fm_managed_resources {
object
.key("DeleteUnusedFMManagedResources")
.boolean(input.delete_unused_fm_managed_resources);
}
if let Some(var_125) = &input.include_map {
#[allow(unused_mut)]
let mut object_126 = object.key("IncludeMap").start_object();
for (key_127, value_128) in var_125 {
{
let mut array_129 = object_126.key(key_127.as_str()).start_array();
for item_130 in value_128 {
{
array_129.value().string(item_130.as_str());
}
}
array_129.finish();
}
}
object_126.finish();
}
if let Some(var_131) = &input.exclude_map {
#[allow(unused_mut)]
let mut object_132 = object.key("ExcludeMap").start_object();
for (key_133, value_134) in var_131 {
{
let mut array_135 = object_132.key(key_133.as_str()).start_array();
for item_136 in value_134 {
{
array_135.value().string(item_136.as_str());
}
}
array_135.finish();
}
}
object_132.finish();
}
if let Some(var_137) = &input.resource_set_ids {
let mut array_138 = object.key("ResourceSetIds").start_array();
for item_139 in var_137 {
{
array_138.value().string(item_139.as_str());
}
}
array_138.finish();
}
if let Some(var_140) = &input.policy_description {
object.key("PolicyDescription").string(var_140.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_protocols_list_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProtocolsListData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_141) = &input.list_id {
object.key("ListId").string(var_141.as_str());
}
if let Some(var_142) = &input.list_name {
object.key("ListName").string(var_142.as_str());
}
if let Some(var_143) = &input.list_update_token {
object.key("ListUpdateToken").string(var_143.as_str());
}
if let Some(var_144) = &input.create_time {
object
.key("CreateTime")
.date_time(var_144, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_145) = &input.last_update_time {
object
.key("LastUpdateTime")
.date_time(var_145, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_146) = &input.protocols_list {
let mut array_147 = object.key("ProtocolsList").start_array();
for item_148 in var_146 {
{
array_147.value().string(item_148.as_str());
}
}
array_147.finish();
}
if let Some(var_149) = &input.previous_protocols_list {
#[allow(unused_mut)]
let mut object_150 = object.key("PreviousProtocolsList").start_object();
for (key_151, value_152) in var_149 {
{
let mut array_153 = object_150.key(key_151.as_str()).start_array();
for item_154 in value_152 {
{
array_153.value().string(item_154.as_str());
}
}
array_153.finish();
}
}
object_150.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_set(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceSet,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_155) = &input.id {
object.key("Id").string(var_155.as_str());
}
if let Some(var_156) = &input.name {
object.key("Name").string(var_156.as_str());
}
if let Some(var_157) = &input.description {
object.key("Description").string(var_157.as_str());
}
if let Some(var_158) = &input.update_token {
object.key("UpdateToken").string(var_158.as_str());
}
if let Some(var_159) = &input.resource_type_list {
let mut array_160 = object.key("ResourceTypeList").start_array();
for item_161 in var_159 {
{
array_160.value().string(item_161.as_str());
}
}
array_160.finish();
}
if let Some(var_162) = &input.last_update_time {
object
.key("LastUpdateTime")
.date_time(var_162, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_app(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::App,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_163) = &input.app_name {
object.key("AppName").string(var_163.as_str());
}
if let Some(var_164) = &input.protocol {
object.key("Protocol").string(var_164.as_str());
}
if let Some(var_165) = &input.port {
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_165).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_security_service_policy_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SecurityServicePolicyData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_166) = &input.r#type {
object.key("Type").string(var_166.as_str());
}
if let Some(var_167) = &input.managed_service_data {
object.key("ManagedServiceData").string(var_167.as_str());
}
if let Some(var_168) = &input.policy_option {
#[allow(unused_mut)]
let mut object_169 = object.key("PolicyOption").start_object();
crate::json_ser::serialize_structure_crate_model_policy_option(&mut object_169, var_168)?;
object_169.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceTag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_170) = &input.key {
object.key("Key").string(var_170.as_str());
}
if let Some(var_171) = &input.value {
object.key("Value").string(var_171.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_policy_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PolicyOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_172) = &input.network_firewall_policy {
#[allow(unused_mut)]
let mut object_173 = object.key("NetworkFirewallPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_network_firewall_policy(
&mut object_173,
var_172,
)?;
object_173.finish();
}
if let Some(var_174) = &input.third_party_firewall_policy {
#[allow(unused_mut)]
let mut object_175 = object.key("ThirdPartyFirewallPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_third_party_firewall_policy(
&mut object_175,
var_174,
)?;
object_175.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_network_firewall_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NetworkFirewallPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_176) = &input.firewall_deployment_model {
object
.key("FirewallDeploymentModel")
.string(var_176.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_third_party_firewall_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ThirdPartyFirewallPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_177) = &input.firewall_deployment_model {
object
.key("FirewallDeploymentModel")
.string(var_177.as_str());
}
Ok(())
}