pub fn serialize_structure_crate_input_associate_drt_log_bucket_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateDrtLogBucketInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.log_bucket {
object.key("LogBucket").string(var_1.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_drt_role_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateDrtRoleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2) = &input.role_arn {
object.key("RoleArn").string(var_2.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_health_check_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateHealthCheckInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3) = &input.protection_id {
object.key("ProtectionId").string(var_3.as_str());
}
if let Some(var_4) = &input.health_check_arn {
object.key("HealthCheckArn").string(var_4.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_proactive_engagement_details_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateProactiveEngagementDetailsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_5) = &input.emergency_contact_list {
let mut array_6 = object.key("EmergencyContactList").start_array();
for item_7 in var_5 {
{
#[allow(unused_mut)]
let mut object_8 = array_6.value().start_object();
crate::json_ser::serialize_structure_crate_model_emergency_contact(
&mut object_8,
item_7,
)?;
object_8.finish();
}
}
array_6.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_protection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateProtectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_9) = &input.name {
object.key("Name").string(var_9.as_str());
}
if let Some(var_10) = &input.resource_arn {
object.key("ResourceArn").string(var_10.as_str());
}
if let Some(var_11) = &input.tags {
let mut array_12 = object.key("Tags").start_array();
for item_13 in var_11 {
{
#[allow(unused_mut)]
let mut object_14 = array_12.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_14, item_13)?;
object_14.finish();
}
}
array_12.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_protection_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateProtectionGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_15) = &input.protection_group_id {
object.key("ProtectionGroupId").string(var_15.as_str());
}
if let Some(var_16) = &input.aggregation {
object.key("Aggregation").string(var_16.as_str());
}
if let Some(var_17) = &input.pattern {
object.key("Pattern").string(var_17.as_str());
}
if let Some(var_18) = &input.resource_type {
object.key("ResourceType").string(var_18.as_str());
}
if let Some(var_19) = &input.members {
let mut array_20 = object.key("Members").start_array();
for item_21 in var_19 {
{
array_20.value().string(item_21.as_str());
}
}
array_20.finish();
}
if let Some(var_22) = &input.tags {
let mut array_23 = object.key("Tags").start_array();
for item_24 in var_22 {
{
#[allow(unused_mut)]
let mut object_25 = array_23.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_25, item_24)?;
object_25.finish();
}
}
array_23.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_protection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteProtectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_26) = &input.protection_id {
object.key("ProtectionId").string(var_26.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_protection_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteProtectionGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_27) = &input.protection_group_id {
object.key("ProtectionGroupId").string(var_27.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_attack_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAttackInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_28) = &input.attack_id {
object.key("AttackId").string(var_28.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_protection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeProtectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.protection_id {
object.key("ProtectionId").string(var_29.as_str());
}
if let Some(var_30) = &input.resource_arn {
object.key("ResourceArn").string(var_30.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_protection_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeProtectionGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.protection_group_id {
object.key("ProtectionGroupId").string(var_31.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disable_application_layer_automatic_response_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisableApplicationLayerAutomaticResponseInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_32) = &input.resource_arn {
object.key("ResourceArn").string(var_32.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_drt_log_bucket_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateDrtLogBucketInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_33) = &input.log_bucket {
object.key("LogBucket").string(var_33.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_health_check_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateHealthCheckInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_34) = &input.protection_id {
object.key("ProtectionId").string(var_34.as_str());
}
if let Some(var_35) = &input.health_check_arn {
object.key("HealthCheckArn").string(var_35.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_enable_application_layer_automatic_response_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EnableApplicationLayerAutomaticResponseInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_36) = &input.resource_arn {
object.key("ResourceArn").string(var_36.as_str());
}
if let Some(var_37) = &input.action {
#[allow(unused_mut)]
let mut object_38 = object.key("Action").start_object();
crate::json_ser::serialize_structure_crate_model_response_action(&mut object_38, var_37)?;
object_38.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_attacks_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAttacksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_39) = &input.resource_arns {
let mut array_40 = object.key("ResourceArns").start_array();
for item_41 in var_39 {
{
array_40.value().string(item_41.as_str());
}
}
array_40.finish();
}
if let Some(var_42) = &input.start_time {
#[allow(unused_mut)]
let mut object_43 = object.key("StartTime").start_object();
crate::json_ser::serialize_structure_crate_model_time_range(&mut object_43, var_42)?;
object_43.finish();
}
if let Some(var_44) = &input.end_time {
#[allow(unused_mut)]
let mut object_45 = object.key("EndTime").start_object();
crate::json_ser::serialize_structure_crate_model_time_range(&mut object_45, var_44)?;
object_45.finish();
}
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_protection_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListProtectionGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
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()),
);
}
if let Some(var_50) = &input.inclusion_filters {
#[allow(unused_mut)]
let mut object_51 = object.key("InclusionFilters").start_object();
crate::json_ser::serialize_structure_crate_model_inclusion_protection_group_filters(
&mut object_51,
var_50,
)?;
object_51.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_protections_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListProtectionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_52) = &input.next_token {
object.key("NextToken").string(var_52.as_str());
}
if let Some(var_53) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_53).into()),
);
}
if let Some(var_54) = &input.inclusion_filters {
#[allow(unused_mut)]
let mut object_55 = object.key("InclusionFilters").start_object();
crate::json_ser::serialize_structure_crate_model_inclusion_protection_filters(
&mut object_55,
var_54,
)?;
object_55.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_resources_in_protection_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListResourcesInProtectionGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.protection_group_id {
object.key("ProtectionGroupId").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_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_59) = &input.resource_arn {
object.key("ResourceARN").string(var_59.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_60) = &input.resource_arn {
object.key("ResourceARN").string(var_60.as_str());
}
if let Some(var_61) = &input.tags {
let mut array_62 = object.key("Tags").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_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_65) = &input.resource_arn {
object.key("ResourceARN").string(var_65.as_str());
}
if let Some(var_66) = &input.tag_keys {
let mut array_67 = object.key("TagKeys").start_array();
for item_68 in var_66 {
{
array_67.value().string(item_68.as_str());
}
}
array_67.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_application_layer_automatic_response_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateApplicationLayerAutomaticResponseInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_69) = &input.resource_arn {
object.key("ResourceArn").string(var_69.as_str());
}
if let Some(var_70) = &input.action {
#[allow(unused_mut)]
let mut object_71 = object.key("Action").start_object();
crate::json_ser::serialize_structure_crate_model_response_action(&mut object_71, var_70)?;
object_71.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_emergency_contact_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateEmergencyContactSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_72) = &input.emergency_contact_list {
let mut array_73 = object.key("EmergencyContactList").start_array();
for item_74 in var_72 {
{
#[allow(unused_mut)]
let mut object_75 = array_73.value().start_object();
crate::json_ser::serialize_structure_crate_model_emergency_contact(
&mut object_75,
item_74,
)?;
object_75.finish();
}
}
array_73.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_protection_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateProtectionGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_76) = &input.protection_group_id {
object.key("ProtectionGroupId").string(var_76.as_str());
}
if let Some(var_77) = &input.aggregation {
object.key("Aggregation").string(var_77.as_str());
}
if let Some(var_78) = &input.pattern {
object.key("Pattern").string(var_78.as_str());
}
if let Some(var_79) = &input.resource_type {
object.key("ResourceType").string(var_79.as_str());
}
if let Some(var_80) = &input.members {
let mut array_81 = object.key("Members").start_array();
for item_82 in var_80 {
{
array_81.value().string(item_82.as_str());
}
}
array_81.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_subscription_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSubscriptionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_83) = &input.auto_renew {
object.key("AutoRenew").string(var_83.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_emergency_contact(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EmergencyContact,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_84) = &input.email_address {
object.key("EmailAddress").string(var_84.as_str());
}
if let Some(var_85) = &input.phone_number {
object.key("PhoneNumber").string(var_85.as_str());
}
if let Some(var_86) = &input.contact_notes {
object.key("ContactNotes").string(var_86.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.key {
object.key("Key").string(var_87.as_str());
}
if let Some(var_88) = &input.value {
object.key("Value").string(var_88.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_response_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResponseAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.block {
#[allow(unused_mut)]
let mut object_90 = object.key("Block").start_object();
crate::json_ser::serialize_structure_crate_model_block_action(&mut object_90, var_89)?;
object_90.finish();
}
if let Some(var_91) = &input.count {
#[allow(unused_mut)]
let mut object_92 = object.key("Count").start_object();
crate::json_ser::serialize_structure_crate_model_count_action(&mut object_92, var_91)?;
object_92.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_time_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.from_inclusive {
object
.key("FromInclusive")
.date_time(var_93, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_94) = &input.to_exclusive {
object
.key("ToExclusive")
.date_time(var_94, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_inclusion_protection_group_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InclusionProtectionGroupFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_95) = &input.protection_group_ids {
let mut array_96 = object.key("ProtectionGroupIds").start_array();
for item_97 in var_95 {
{
array_96.value().string(item_97.as_str());
}
}
array_96.finish();
}
if let Some(var_98) = &input.patterns {
let mut array_99 = object.key("Patterns").start_array();
for item_100 in var_98 {
{
array_99.value().string(item_100.as_str());
}
}
array_99.finish();
}
if let Some(var_101) = &input.resource_types {
let mut array_102 = object.key("ResourceTypes").start_array();
for item_103 in var_101 {
{
array_102.value().string(item_103.as_str());
}
}
array_102.finish();
}
if let Some(var_104) = &input.aggregations {
let mut array_105 = object.key("Aggregations").start_array();
for item_106 in var_104 {
{
array_105.value().string(item_106.as_str());
}
}
array_105.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_inclusion_protection_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InclusionProtectionFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_107) = &input.resource_arns {
let mut array_108 = object.key("ResourceArns").start_array();
for item_109 in var_107 {
{
array_108.value().string(item_109.as_str());
}
}
array_108.finish();
}
if let Some(var_110) = &input.protection_names {
let mut array_111 = object.key("ProtectionNames").start_array();
for item_112 in var_110 {
{
array_111.value().string(item_112.as_str());
}
}
array_111.finish();
}
if let Some(var_113) = &input.resource_types {
let mut array_114 = object.key("ResourceTypes").start_array();
for item_115 in var_113 {
{
array_114.value().string(item_115.as_str());
}
}
array_114.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_block_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BlockAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_structure_crate_model_count_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CountAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}