aws-sdk-securityhub 0.0.22-alpha

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub fn serialize_structure_crate_input_accept_administrator_invitation_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::AcceptAdministratorInvitationInput,
) {
    if let Some(var_1) = &input.administrator_id {
        object.key("AdministratorId").string(var_1);
    }
    if let Some(var_2) = &input.invitation_id {
        object.key("InvitationId").string(var_2);
    }
}

pub fn serialize_structure_crate_input_accept_invitation_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::AcceptInvitationInput,
) {
    if let Some(var_3) = &input.invitation_id {
        object.key("InvitationId").string(var_3);
    }
    if let Some(var_4) = &input.master_id {
        object.key("MasterId").string(var_4);
    }
}

pub fn serialize_structure_crate_input_batch_disable_standards_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchDisableStandardsInput,
) {
    if let Some(var_5) = &input.standards_subscription_arns {
        let mut array_6 = object.key("StandardsSubscriptionArns").start_array();
        for item_7 in var_5 {
            {
                array_6.value().string(item_7);
            }
        }
        array_6.finish();
    }
}

pub fn serialize_structure_crate_input_batch_enable_standards_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchEnableStandardsInput,
) {
    if let Some(var_8) = &input.standards_subscription_requests {
        let mut array_9 = object.key("StandardsSubscriptionRequests").start_array();
        for item_10 in var_8 {
            {
                let mut object_11 = array_9.value().start_object();
                crate::json_ser::serialize_structure_crate_model_standards_subscription_request(
                    &mut object_11,
                    item_10,
                );
                object_11.finish();
            }
        }
        array_9.finish();
    }
}

pub fn serialize_structure_crate_input_batch_import_findings_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchImportFindingsInput,
) {
    if let Some(var_12) = &input.findings {
        let mut array_13 = object.key("Findings").start_array();
        for item_14 in var_12 {
            {
                let mut object_15 = array_13.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_security_finding(
                    &mut object_15,
                    item_14,
                );
                object_15.finish();
            }
        }
        array_13.finish();
    }
}

pub fn serialize_structure_crate_input_batch_update_findings_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchUpdateFindingsInput,
) {
    if input.confidence != 0 {
        object.key("Confidence").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.confidence).into()),
        );
    }
    if input.criticality != 0 {
        object.key("Criticality").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.criticality).into()),
        );
    }
    if let Some(var_16) = &input.finding_identifiers {
        let mut array_17 = object.key("FindingIdentifiers").start_array();
        for item_18 in var_16 {
            {
                let mut object_19 = array_17.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_security_finding_identifier(
                    &mut object_19,
                    item_18,
                );
                object_19.finish();
            }
        }
        array_17.finish();
    }
    if let Some(var_20) = &input.note {
        let mut object_21 = object.key("Note").start_object();
        crate::json_ser::serialize_structure_crate_model_note_update(&mut object_21, var_20);
        object_21.finish();
    }
    if let Some(var_22) = &input.related_findings {
        let mut array_23 = object.key("RelatedFindings").start_array();
        for item_24 in var_22 {
            {
                let mut object_25 = array_23.value().start_object();
                crate::json_ser::serialize_structure_crate_model_related_finding(
                    &mut object_25,
                    item_24,
                );
                object_25.finish();
            }
        }
        array_23.finish();
    }
    if let Some(var_26) = &input.severity {
        let mut object_27 = object.key("Severity").start_object();
        crate::json_ser::serialize_structure_crate_model_severity_update(&mut object_27, var_26);
        object_27.finish();
    }
    if let Some(var_28) = &input.types {
        let mut array_29 = object.key("Types").start_array();
        for item_30 in var_28 {
            {
                array_29.value().string(item_30);
            }
        }
        array_29.finish();
    }
    if let Some(var_31) = &input.user_defined_fields {
        let mut object_32 = object.key("UserDefinedFields").start_object();
        for (key_33, value_34) in var_31 {
            {
                object_32.key(key_33).string(value_34);
            }
        }
        object_32.finish();
    }
    if let Some(var_35) = &input.verification_state {
        object.key("VerificationState").string(var_35.as_str());
    }
    if let Some(var_36) = &input.workflow {
        let mut object_37 = object.key("Workflow").start_object();
        crate::json_ser::serialize_structure_crate_model_workflow_update(&mut object_37, var_36);
        object_37.finish();
    }
}

pub fn serialize_structure_crate_input_create_action_target_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateActionTargetInput,
) {
    if let Some(var_38) = &input.description {
        object.key("Description").string(var_38);
    }
    if let Some(var_39) = &input.id {
        object.key("Id").string(var_39);
    }
    if let Some(var_40) = &input.name {
        object.key("Name").string(var_40);
    }
}

pub fn serialize_structure_crate_input_create_insight_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateInsightInput,
) {
    if let Some(var_41) = &input.filters {
        let mut object_42 = object.key("Filters").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_security_finding_filters(
            &mut object_42,
            var_41,
        );
        object_42.finish();
    }
    if let Some(var_43) = &input.group_by_attribute {
        object.key("GroupByAttribute").string(var_43);
    }
    if let Some(var_44) = &input.name {
        object.key("Name").string(var_44);
    }
}

pub fn serialize_structure_crate_input_create_members_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateMembersInput,
) {
    if let Some(var_45) = &input.account_details {
        let mut array_46 = object.key("AccountDetails").start_array();
        for item_47 in var_45 {
            {
                let mut object_48 = array_46.value().start_object();
                crate::json_ser::serialize_structure_crate_model_account_details(
                    &mut object_48,
                    item_47,
                );
                object_48.finish();
            }
        }
        array_46.finish();
    }
}

pub fn serialize_structure_crate_input_decline_invitations_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeclineInvitationsInput,
) {
    if let Some(var_49) = &input.account_ids {
        let mut array_50 = object.key("AccountIds").start_array();
        for item_51 in var_49 {
            {
                array_50.value().string(item_51);
            }
        }
        array_50.finish();
    }
}

pub fn serialize_structure_crate_input_delete_invitations_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteInvitationsInput,
) {
    if let Some(var_52) = &input.account_ids {
        let mut array_53 = object.key("AccountIds").start_array();
        for item_54 in var_52 {
            {
                array_53.value().string(item_54);
            }
        }
        array_53.finish();
    }
}

pub fn serialize_structure_crate_input_delete_members_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteMembersInput,
) {
    if let Some(var_55) = &input.account_ids {
        let mut array_56 = object.key("AccountIds").start_array();
        for item_57 in var_55 {
            {
                array_56.value().string(item_57);
            }
        }
        array_56.finish();
    }
}

pub fn serialize_structure_crate_input_describe_action_targets_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeActionTargetsInput,
) {
    if let Some(var_58) = &input.action_target_arns {
        let mut array_59 = object.key("ActionTargetArns").start_array();
        for item_60 in var_58 {
            {
                array_59.value().string(item_60);
            }
        }
        array_59.finish();
    }
    if input.max_results != 0 {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_results).into()),
        );
    }
    if let Some(var_61) = &input.next_token {
        object.key("NextToken").string(var_61);
    }
}

pub fn serialize_structure_crate_input_disable_organization_admin_account_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DisableOrganizationAdminAccountInput,
) {
    if let Some(var_62) = &input.admin_account_id {
        object.key("AdminAccountId").string(var_62);
    }
}

pub fn serialize_structure_crate_input_disassociate_members_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DisassociateMembersInput,
) {
    if let Some(var_63) = &input.account_ids {
        let mut array_64 = object.key("AccountIds").start_array();
        for item_65 in var_63 {
            {
                array_64.value().string(item_65);
            }
        }
        array_64.finish();
    }
}

pub fn serialize_structure_crate_input_enable_import_findings_for_product_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::EnableImportFindingsForProductInput,
) {
    if let Some(var_66) = &input.product_arn {
        object.key("ProductArn").string(var_66);
    }
}

pub fn serialize_structure_crate_input_enable_organization_admin_account_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::EnableOrganizationAdminAccountInput,
) {
    if let Some(var_67) = &input.admin_account_id {
        object.key("AdminAccountId").string(var_67);
    }
}

pub fn serialize_structure_crate_input_enable_security_hub_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::EnableSecurityHubInput,
) {
    if input.enable_default_standards {
        object
            .key("EnableDefaultStandards")
            .boolean(input.enable_default_standards);
    }
    if let Some(var_68) = &input.tags {
        let mut object_69 = object.key("Tags").start_object();
        for (key_70, value_71) in var_68 {
            {
                object_69.key(key_70).string(value_71);
            }
        }
        object_69.finish();
    }
}

pub fn serialize_structure_crate_input_get_enabled_standards_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetEnabledStandardsInput,
) {
    if input.max_results != 0 {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_results).into()),
        );
    }
    if let Some(var_72) = &input.next_token {
        object.key("NextToken").string(var_72);
    }
    if let Some(var_73) = &input.standards_subscription_arns {
        let mut array_74 = object.key("StandardsSubscriptionArns").start_array();
        for item_75 in var_73 {
            {
                array_74.value().string(item_75);
            }
        }
        array_74.finish();
    }
}

pub fn serialize_structure_crate_input_get_findings_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetFindingsInput,
) {
    if let Some(var_76) = &input.filters {
        let mut object_77 = object.key("Filters").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_security_finding_filters(
            &mut object_77,
            var_76,
        );
        object_77.finish();
    }
    if input.max_results != 0 {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_results).into()),
        );
    }
    if let Some(var_78) = &input.next_token {
        object.key("NextToken").string(var_78);
    }
    if let Some(var_79) = &input.sort_criteria {
        let mut array_80 = object.key("SortCriteria").start_array();
        for item_81 in var_79 {
            {
                let mut object_82 = array_80.value().start_object();
                crate::json_ser::serialize_structure_crate_model_sort_criterion(
                    &mut object_82,
                    item_81,
                );
                object_82.finish();
            }
        }
        array_80.finish();
    }
}

pub fn serialize_structure_crate_input_get_insights_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetInsightsInput,
) {
    if let Some(var_83) = &input.insight_arns {
        let mut array_84 = object.key("InsightArns").start_array();
        for item_85 in var_83 {
            {
                array_84.value().string(item_85);
            }
        }
        array_84.finish();
    }
    if input.max_results != 0 {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_results).into()),
        );
    }
    if let Some(var_86) = &input.next_token {
        object.key("NextToken").string(var_86);
    }
}

pub fn serialize_structure_crate_input_get_members_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetMembersInput,
) {
    if let Some(var_87) = &input.account_ids {
        let mut array_88 = object.key("AccountIds").start_array();
        for item_89 in var_87 {
            {
                array_88.value().string(item_89);
            }
        }
        array_88.finish();
    }
}

pub fn serialize_structure_crate_input_invite_members_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::InviteMembersInput,
) {
    if let Some(var_90) = &input.account_ids {
        let mut array_91 = object.key("AccountIds").start_array();
        for item_92 in var_90 {
            {
                array_91.value().string(item_92);
            }
        }
        array_91.finish();
    }
}

pub fn serialize_structure_crate_input_tag_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::TagResourceInput,
) {
    if let Some(var_93) = &input.tags {
        let mut object_94 = object.key("Tags").start_object();
        for (key_95, value_96) in var_93 {
            {
                object_94.key(key_95).string(value_96);
            }
        }
        object_94.finish();
    }
}

pub fn serialize_structure_crate_input_update_action_target_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateActionTargetInput,
) {
    if let Some(var_97) = &input.description {
        object.key("Description").string(var_97);
    }
    if let Some(var_98) = &input.name {
        object.key("Name").string(var_98);
    }
}

pub fn serialize_structure_crate_input_update_findings_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateFindingsInput,
) {
    if let Some(var_99) = &input.filters {
        let mut object_100 = object.key("Filters").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_security_finding_filters(
            &mut object_100,
            var_99,
        );
        object_100.finish();
    }
    if let Some(var_101) = &input.note {
        let mut object_102 = object.key("Note").start_object();
        crate::json_ser::serialize_structure_crate_model_note_update(&mut object_102, var_101);
        object_102.finish();
    }
    if let Some(var_103) = &input.record_state {
        object.key("RecordState").string(var_103.as_str());
    }
}

pub fn serialize_structure_crate_input_update_insight_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateInsightInput,
) {
    if let Some(var_104) = &input.filters {
        let mut object_105 = object.key("Filters").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_security_finding_filters(
            &mut object_105,
            var_104,
        );
        object_105.finish();
    }
    if let Some(var_106) = &input.group_by_attribute {
        object.key("GroupByAttribute").string(var_106);
    }
    if let Some(var_107) = &input.name {
        object.key("Name").string(var_107);
    }
}

pub fn serialize_structure_crate_input_update_organization_configuration_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateOrganizationConfigurationInput,
) {
    {
        object.key("AutoEnable").boolean(input.auto_enable);
    }
}

pub fn serialize_structure_crate_input_update_security_hub_configuration_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateSecurityHubConfigurationInput,
) {
    if input.auto_enable_controls {
        object
            .key("AutoEnableControls")
            .boolean(input.auto_enable_controls);
    }
}

pub fn serialize_structure_crate_input_update_standards_control_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateStandardsControlInput,
) {
    if let Some(var_108) = &input.control_status {
        object.key("ControlStatus").string(var_108.as_str());
    }
    if let Some(var_109) = &input.disabled_reason {
        object.key("DisabledReason").string(var_109);
    }
}

pub fn serialize_structure_crate_model_standards_subscription_request(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::StandardsSubscriptionRequest,
) {
    if let Some(var_110) = &input.standards_arn {
        object.key("StandardsArn").string(var_110);
    }
    if let Some(var_111) = &input.standards_input {
        let mut object_112 = object.key("StandardsInput").start_object();
        for (key_113, value_114) in var_111 {
            {
                object_112.key(key_113).string(value_114);
            }
        }
        object_112.finish();
    }
}

pub fn serialize_structure_crate_model_aws_security_finding(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsSecurityFinding,
) {
    if let Some(var_115) = &input.schema_version {
        object.key("SchemaVersion").string(var_115);
    }
    if let Some(var_116) = &input.id {
        object.key("Id").string(var_116);
    }
    if let Some(var_117) = &input.product_arn {
        object.key("ProductArn").string(var_117);
    }
    if let Some(var_118) = &input.product_name {
        object.key("ProductName").string(var_118);
    }
    if let Some(var_119) = &input.company_name {
        object.key("CompanyName").string(var_119);
    }
    if let Some(var_120) = &input.region {
        object.key("Region").string(var_120);
    }
    if let Some(var_121) = &input.generator_id {
        object.key("GeneratorId").string(var_121);
    }
    if let Some(var_122) = &input.aws_account_id {
        object.key("AwsAccountId").string(var_122);
    }
    if let Some(var_123) = &input.types {
        let mut array_124 = object.key("Types").start_array();
        for item_125 in var_123 {
            {
                array_124.value().string(item_125);
            }
        }
        array_124.finish();
    }
    if let Some(var_126) = &input.first_observed_at {
        object.key("FirstObservedAt").string(var_126);
    }
    if let Some(var_127) = &input.last_observed_at {
        object.key("LastObservedAt").string(var_127);
    }
    if let Some(var_128) = &input.created_at {
        object.key("CreatedAt").string(var_128);
    }
    if let Some(var_129) = &input.updated_at {
        object.key("UpdatedAt").string(var_129);
    }
    if let Some(var_130) = &input.severity {
        let mut object_131 = object.key("Severity").start_object();
        crate::json_ser::serialize_structure_crate_model_severity(&mut object_131, var_130);
        object_131.finish();
    }
    if input.confidence != 0 {
        object.key("Confidence").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.confidence).into()),
        );
    }
    if input.criticality != 0 {
        object.key("Criticality").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.criticality).into()),
        );
    }
    if let Some(var_132) = &input.title {
        object.key("Title").string(var_132);
    }
    if let Some(var_133) = &input.description {
        object.key("Description").string(var_133);
    }
    if let Some(var_134) = &input.remediation {
        let mut object_135 = object.key("Remediation").start_object();
        crate::json_ser::serialize_structure_crate_model_remediation(&mut object_135, var_134);
        object_135.finish();
    }
    if let Some(var_136) = &input.source_url {
        object.key("SourceUrl").string(var_136);
    }
    if let Some(var_137) = &input.product_fields {
        let mut object_138 = object.key("ProductFields").start_object();
        for (key_139, value_140) in var_137 {
            {
                object_138.key(key_139).string(value_140);
            }
        }
        object_138.finish();
    }
    if let Some(var_141) = &input.user_defined_fields {
        let mut object_142 = object.key("UserDefinedFields").start_object();
        for (key_143, value_144) in var_141 {
            {
                object_142.key(key_143).string(value_144);
            }
        }
        object_142.finish();
    }
    if let Some(var_145) = &input.malware {
        let mut array_146 = object.key("Malware").start_array();
        for item_147 in var_145 {
            {
                let mut object_148 = array_146.value().start_object();
                crate::json_ser::serialize_structure_crate_model_malware(&mut object_148, item_147);
                object_148.finish();
            }
        }
        array_146.finish();
    }
    if let Some(var_149) = &input.network {
        let mut object_150 = object.key("Network").start_object();
        crate::json_ser::serialize_structure_crate_model_network(&mut object_150, var_149);
        object_150.finish();
    }
    if let Some(var_151) = &input.network_path {
        let mut array_152 = object.key("NetworkPath").start_array();
        for item_153 in var_151 {
            {
                let mut object_154 = array_152.value().start_object();
                crate::json_ser::serialize_structure_crate_model_network_path_component(
                    &mut object_154,
                    item_153,
                );
                object_154.finish();
            }
        }
        array_152.finish();
    }
    if let Some(var_155) = &input.process {
        let mut object_156 = object.key("Process").start_object();
        crate::json_ser::serialize_structure_crate_model_process_details(&mut object_156, var_155);
        object_156.finish();
    }
    if let Some(var_157) = &input.threat_intel_indicators {
        let mut array_158 = object.key("ThreatIntelIndicators").start_array();
        for item_159 in var_157 {
            {
                let mut object_160 = array_158.value().start_object();
                crate::json_ser::serialize_structure_crate_model_threat_intel_indicator(
                    &mut object_160,
                    item_159,
                );
                object_160.finish();
            }
        }
        array_158.finish();
    }
    if let Some(var_161) = &input.resources {
        let mut array_162 = object.key("Resources").start_array();
        for item_163 in var_161 {
            {
                let mut object_164 = array_162.value().start_object();
                crate::json_ser::serialize_structure_crate_model_resource(
                    &mut object_164,
                    item_163,
                );
                object_164.finish();
            }
        }
        array_162.finish();
    }
    if let Some(var_165) = &input.compliance {
        let mut object_166 = object.key("Compliance").start_object();
        crate::json_ser::serialize_structure_crate_model_compliance(&mut object_166, var_165);
        object_166.finish();
    }
    if let Some(var_167) = &input.verification_state {
        object.key("VerificationState").string(var_167.as_str());
    }
    if let Some(var_168) = &input.workflow_state {
        object.key("WorkflowState").string(var_168.as_str());
    }
    if let Some(var_169) = &input.workflow {
        let mut object_170 = object.key("Workflow").start_object();
        crate::json_ser::serialize_structure_crate_model_workflow(&mut object_170, var_169);
        object_170.finish();
    }
    if let Some(var_171) = &input.record_state {
        object.key("RecordState").string(var_171.as_str());
    }
    if let Some(var_172) = &input.related_findings {
        let mut array_173 = object.key("RelatedFindings").start_array();
        for item_174 in var_172 {
            {
                let mut object_175 = array_173.value().start_object();
                crate::json_ser::serialize_structure_crate_model_related_finding(
                    &mut object_175,
                    item_174,
                );
                object_175.finish();
            }
        }
        array_173.finish();
    }
    if let Some(var_176) = &input.note {
        let mut object_177 = object.key("Note").start_object();
        crate::json_ser::serialize_structure_crate_model_note(&mut object_177, var_176);
        object_177.finish();
    }
    if let Some(var_178) = &input.vulnerabilities {
        let mut array_179 = object.key("Vulnerabilities").start_array();
        for item_180 in var_178 {
            {
                let mut object_181 = array_179.value().start_object();
                crate::json_ser::serialize_structure_crate_model_vulnerability(
                    &mut object_181,
                    item_180,
                );
                object_181.finish();
            }
        }
        array_179.finish();
    }
    if let Some(var_182) = &input.patch_summary {
        let mut object_183 = object.key("PatchSummary").start_object();
        crate::json_ser::serialize_structure_crate_model_patch_summary(&mut object_183, var_182);
        object_183.finish();
    }
    if let Some(var_184) = &input.action {
        let mut object_185 = object.key("Action").start_object();
        crate::json_ser::serialize_structure_crate_model_action(&mut object_185, var_184);
        object_185.finish();
    }
    if let Some(var_186) = &input.finding_provider_fields {
        let mut object_187 = object.key("FindingProviderFields").start_object();
        crate::json_ser::serialize_structure_crate_model_finding_provider_fields(
            &mut object_187,
            var_186,
        );
        object_187.finish();
    }
}

pub fn serialize_structure_crate_model_aws_security_finding_identifier(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsSecurityFindingIdentifier,
) {
    if let Some(var_188) = &input.id {
        object.key("Id").string(var_188);
    }
    if let Some(var_189) = &input.product_arn {
        object.key("ProductArn").string(var_189);
    }
}

pub fn serialize_structure_crate_model_note_update(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NoteUpdate,
) {
    if let Some(var_190) = &input.text {
        object.key("Text").string(var_190);
    }
    if let Some(var_191) = &input.updated_by {
        object.key("UpdatedBy").string(var_191);
    }
}

pub fn serialize_structure_crate_model_related_finding(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::RelatedFinding,
) {
    if let Some(var_192) = &input.product_arn {
        object.key("ProductArn").string(var_192);
    }
    if let Some(var_193) = &input.id {
        object.key("Id").string(var_193);
    }
}

pub fn serialize_structure_crate_model_severity_update(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SeverityUpdate,
) {
    if input.normalized != 0 {
        object.key("Normalized").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.normalized).into()),
        );
    }
    if input.product != 0.0 {
        object.key("Product").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.product).into()),
        );
    }
    if let Some(var_194) = &input.label {
        object.key("Label").string(var_194.as_str());
    }
}

pub fn serialize_structure_crate_model_workflow_update(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::WorkflowUpdate,
) {
    if let Some(var_195) = &input.status {
        object.key("Status").string(var_195.as_str());
    }
}

pub fn serialize_structure_crate_model_aws_security_finding_filters(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsSecurityFindingFilters,
) {
    if let Some(var_196) = &input.product_arn {
        let mut array_197 = object.key("ProductArn").start_array();
        for item_198 in var_196 {
            {
                let mut object_199 = array_197.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_199,
                    item_198,
                );
                object_199.finish();
            }
        }
        array_197.finish();
    }
    if let Some(var_200) = &input.aws_account_id {
        let mut array_201 = object.key("AwsAccountId").start_array();
        for item_202 in var_200 {
            {
                let mut object_203 = array_201.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_203,
                    item_202,
                );
                object_203.finish();
            }
        }
        array_201.finish();
    }
    if let Some(var_204) = &input.id {
        let mut array_205 = object.key("Id").start_array();
        for item_206 in var_204 {
            {
                let mut object_207 = array_205.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_207,
                    item_206,
                );
                object_207.finish();
            }
        }
        array_205.finish();
    }
    if let Some(var_208) = &input.generator_id {
        let mut array_209 = object.key("GeneratorId").start_array();
        for item_210 in var_208 {
            {
                let mut object_211 = array_209.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_211,
                    item_210,
                );
                object_211.finish();
            }
        }
        array_209.finish();
    }
    if let Some(var_212) = &input.region {
        let mut array_213 = object.key("Region").start_array();
        for item_214 in var_212 {
            {
                let mut object_215 = array_213.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_215,
                    item_214,
                );
                object_215.finish();
            }
        }
        array_213.finish();
    }
    if let Some(var_216) = &input.r#type {
        let mut array_217 = object.key("Type").start_array();
        for item_218 in var_216 {
            {
                let mut object_219 = array_217.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_219,
                    item_218,
                );
                object_219.finish();
            }
        }
        array_217.finish();
    }
    if let Some(var_220) = &input.first_observed_at {
        let mut array_221 = object.key("FirstObservedAt").start_array();
        for item_222 in var_220 {
            {
                let mut object_223 = array_221.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_223,
                    item_222,
                );
                object_223.finish();
            }
        }
        array_221.finish();
    }
    if let Some(var_224) = &input.last_observed_at {
        let mut array_225 = object.key("LastObservedAt").start_array();
        for item_226 in var_224 {
            {
                let mut object_227 = array_225.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_227,
                    item_226,
                );
                object_227.finish();
            }
        }
        array_225.finish();
    }
    if let Some(var_228) = &input.created_at {
        let mut array_229 = object.key("CreatedAt").start_array();
        for item_230 in var_228 {
            {
                let mut object_231 = array_229.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_231,
                    item_230,
                );
                object_231.finish();
            }
        }
        array_229.finish();
    }
    if let Some(var_232) = &input.updated_at {
        let mut array_233 = object.key("UpdatedAt").start_array();
        for item_234 in var_232 {
            {
                let mut object_235 = array_233.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_235,
                    item_234,
                );
                object_235.finish();
            }
        }
        array_233.finish();
    }
    if let Some(var_236) = &input.severity_product {
        let mut array_237 = object.key("SeverityProduct").start_array();
        for item_238 in var_236 {
            {
                let mut object_239 = array_237.value().start_object();
                crate::json_ser::serialize_structure_crate_model_number_filter(
                    &mut object_239,
                    item_238,
                );
                object_239.finish();
            }
        }
        array_237.finish();
    }
    if let Some(var_240) = &input.severity_normalized {
        let mut array_241 = object.key("SeverityNormalized").start_array();
        for item_242 in var_240 {
            {
                let mut object_243 = array_241.value().start_object();
                crate::json_ser::serialize_structure_crate_model_number_filter(
                    &mut object_243,
                    item_242,
                );
                object_243.finish();
            }
        }
        array_241.finish();
    }
    if let Some(var_244) = &input.severity_label {
        let mut array_245 = object.key("SeverityLabel").start_array();
        for item_246 in var_244 {
            {
                let mut object_247 = array_245.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_247,
                    item_246,
                );
                object_247.finish();
            }
        }
        array_245.finish();
    }
    if let Some(var_248) = &input.confidence {
        let mut array_249 = object.key("Confidence").start_array();
        for item_250 in var_248 {
            {
                let mut object_251 = array_249.value().start_object();
                crate::json_ser::serialize_structure_crate_model_number_filter(
                    &mut object_251,
                    item_250,
                );
                object_251.finish();
            }
        }
        array_249.finish();
    }
    if let Some(var_252) = &input.criticality {
        let mut array_253 = object.key("Criticality").start_array();
        for item_254 in var_252 {
            {
                let mut object_255 = array_253.value().start_object();
                crate::json_ser::serialize_structure_crate_model_number_filter(
                    &mut object_255,
                    item_254,
                );
                object_255.finish();
            }
        }
        array_253.finish();
    }
    if let Some(var_256) = &input.title {
        let mut array_257 = object.key("Title").start_array();
        for item_258 in var_256 {
            {
                let mut object_259 = array_257.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_259,
                    item_258,
                );
                object_259.finish();
            }
        }
        array_257.finish();
    }
    if let Some(var_260) = &input.description {
        let mut array_261 = object.key("Description").start_array();
        for item_262 in var_260 {
            {
                let mut object_263 = array_261.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_263,
                    item_262,
                );
                object_263.finish();
            }
        }
        array_261.finish();
    }
    if let Some(var_264) = &input.recommendation_text {
        let mut array_265 = object.key("RecommendationText").start_array();
        for item_266 in var_264 {
            {
                let mut object_267 = array_265.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_267,
                    item_266,
                );
                object_267.finish();
            }
        }
        array_265.finish();
    }
    if let Some(var_268) = &input.source_url {
        let mut array_269 = object.key("SourceUrl").start_array();
        for item_270 in var_268 {
            {
                let mut object_271 = array_269.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_271,
                    item_270,
                );
                object_271.finish();
            }
        }
        array_269.finish();
    }
    if let Some(var_272) = &input.product_fields {
        let mut array_273 = object.key("ProductFields").start_array();
        for item_274 in var_272 {
            {
                let mut object_275 = array_273.value().start_object();
                crate::json_ser::serialize_structure_crate_model_map_filter(
                    &mut object_275,
                    item_274,
                );
                object_275.finish();
            }
        }
        array_273.finish();
    }
    if let Some(var_276) = &input.product_name {
        let mut array_277 = object.key("ProductName").start_array();
        for item_278 in var_276 {
            {
                let mut object_279 = array_277.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_279,
                    item_278,
                );
                object_279.finish();
            }
        }
        array_277.finish();
    }
    if let Some(var_280) = &input.company_name {
        let mut array_281 = object.key("CompanyName").start_array();
        for item_282 in var_280 {
            {
                let mut object_283 = array_281.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_283,
                    item_282,
                );
                object_283.finish();
            }
        }
        array_281.finish();
    }
    if let Some(var_284) = &input.user_defined_fields {
        let mut array_285 = object.key("UserDefinedFields").start_array();
        for item_286 in var_284 {
            {
                let mut object_287 = array_285.value().start_object();
                crate::json_ser::serialize_structure_crate_model_map_filter(
                    &mut object_287,
                    item_286,
                );
                object_287.finish();
            }
        }
        array_285.finish();
    }
    if let Some(var_288) = &input.malware_name {
        let mut array_289 = object.key("MalwareName").start_array();
        for item_290 in var_288 {
            {
                let mut object_291 = array_289.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_291,
                    item_290,
                );
                object_291.finish();
            }
        }
        array_289.finish();
    }
    if let Some(var_292) = &input.malware_type {
        let mut array_293 = object.key("MalwareType").start_array();
        for item_294 in var_292 {
            {
                let mut object_295 = array_293.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_295,
                    item_294,
                );
                object_295.finish();
            }
        }
        array_293.finish();
    }
    if let Some(var_296) = &input.malware_path {
        let mut array_297 = object.key("MalwarePath").start_array();
        for item_298 in var_296 {
            {
                let mut object_299 = array_297.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_299,
                    item_298,
                );
                object_299.finish();
            }
        }
        array_297.finish();
    }
    if let Some(var_300) = &input.malware_state {
        let mut array_301 = object.key("MalwareState").start_array();
        for item_302 in var_300 {
            {
                let mut object_303 = array_301.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_303,
                    item_302,
                );
                object_303.finish();
            }
        }
        array_301.finish();
    }
    if let Some(var_304) = &input.network_direction {
        let mut array_305 = object.key("NetworkDirection").start_array();
        for item_306 in var_304 {
            {
                let mut object_307 = array_305.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_307,
                    item_306,
                );
                object_307.finish();
            }
        }
        array_305.finish();
    }
    if let Some(var_308) = &input.network_protocol {
        let mut array_309 = object.key("NetworkProtocol").start_array();
        for item_310 in var_308 {
            {
                let mut object_311 = array_309.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_311,
                    item_310,
                );
                object_311.finish();
            }
        }
        array_309.finish();
    }
    if let Some(var_312) = &input.network_source_ip_v4 {
        let mut array_313 = object.key("NetworkSourceIpV4").start_array();
        for item_314 in var_312 {
            {
                let mut object_315 = array_313.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ip_filter(
                    &mut object_315,
                    item_314,
                );
                object_315.finish();
            }
        }
        array_313.finish();
    }
    if let Some(var_316) = &input.network_source_ip_v6 {
        let mut array_317 = object.key("NetworkSourceIpV6").start_array();
        for item_318 in var_316 {
            {
                let mut object_319 = array_317.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ip_filter(
                    &mut object_319,
                    item_318,
                );
                object_319.finish();
            }
        }
        array_317.finish();
    }
    if let Some(var_320) = &input.network_source_port {
        let mut array_321 = object.key("NetworkSourcePort").start_array();
        for item_322 in var_320 {
            {
                let mut object_323 = array_321.value().start_object();
                crate::json_ser::serialize_structure_crate_model_number_filter(
                    &mut object_323,
                    item_322,
                );
                object_323.finish();
            }
        }
        array_321.finish();
    }
    if let Some(var_324) = &input.network_source_domain {
        let mut array_325 = object.key("NetworkSourceDomain").start_array();
        for item_326 in var_324 {
            {
                let mut object_327 = array_325.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_327,
                    item_326,
                );
                object_327.finish();
            }
        }
        array_325.finish();
    }
    if let Some(var_328) = &input.network_source_mac {
        let mut array_329 = object.key("NetworkSourceMac").start_array();
        for item_330 in var_328 {
            {
                let mut object_331 = array_329.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_331,
                    item_330,
                );
                object_331.finish();
            }
        }
        array_329.finish();
    }
    if let Some(var_332) = &input.network_destination_ip_v4 {
        let mut array_333 = object.key("NetworkDestinationIpV4").start_array();
        for item_334 in var_332 {
            {
                let mut object_335 = array_333.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ip_filter(
                    &mut object_335,
                    item_334,
                );
                object_335.finish();
            }
        }
        array_333.finish();
    }
    if let Some(var_336) = &input.network_destination_ip_v6 {
        let mut array_337 = object.key("NetworkDestinationIpV6").start_array();
        for item_338 in var_336 {
            {
                let mut object_339 = array_337.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ip_filter(
                    &mut object_339,
                    item_338,
                );
                object_339.finish();
            }
        }
        array_337.finish();
    }
    if let Some(var_340) = &input.network_destination_port {
        let mut array_341 = object.key("NetworkDestinationPort").start_array();
        for item_342 in var_340 {
            {
                let mut object_343 = array_341.value().start_object();
                crate::json_ser::serialize_structure_crate_model_number_filter(
                    &mut object_343,
                    item_342,
                );
                object_343.finish();
            }
        }
        array_341.finish();
    }
    if let Some(var_344) = &input.network_destination_domain {
        let mut array_345 = object.key("NetworkDestinationDomain").start_array();
        for item_346 in var_344 {
            {
                let mut object_347 = array_345.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_347,
                    item_346,
                );
                object_347.finish();
            }
        }
        array_345.finish();
    }
    if let Some(var_348) = &input.process_name {
        let mut array_349 = object.key("ProcessName").start_array();
        for item_350 in var_348 {
            {
                let mut object_351 = array_349.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_351,
                    item_350,
                );
                object_351.finish();
            }
        }
        array_349.finish();
    }
    if let Some(var_352) = &input.process_path {
        let mut array_353 = object.key("ProcessPath").start_array();
        for item_354 in var_352 {
            {
                let mut object_355 = array_353.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_355,
                    item_354,
                );
                object_355.finish();
            }
        }
        array_353.finish();
    }
    if let Some(var_356) = &input.process_pid {
        let mut array_357 = object.key("ProcessPid").start_array();
        for item_358 in var_356 {
            {
                let mut object_359 = array_357.value().start_object();
                crate::json_ser::serialize_structure_crate_model_number_filter(
                    &mut object_359,
                    item_358,
                );
                object_359.finish();
            }
        }
        array_357.finish();
    }
    if let Some(var_360) = &input.process_parent_pid {
        let mut array_361 = object.key("ProcessParentPid").start_array();
        for item_362 in var_360 {
            {
                let mut object_363 = array_361.value().start_object();
                crate::json_ser::serialize_structure_crate_model_number_filter(
                    &mut object_363,
                    item_362,
                );
                object_363.finish();
            }
        }
        array_361.finish();
    }
    if let Some(var_364) = &input.process_launched_at {
        let mut array_365 = object.key("ProcessLaunchedAt").start_array();
        for item_366 in var_364 {
            {
                let mut object_367 = array_365.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_367,
                    item_366,
                );
                object_367.finish();
            }
        }
        array_365.finish();
    }
    if let Some(var_368) = &input.process_terminated_at {
        let mut array_369 = object.key("ProcessTerminatedAt").start_array();
        for item_370 in var_368 {
            {
                let mut object_371 = array_369.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_371,
                    item_370,
                );
                object_371.finish();
            }
        }
        array_369.finish();
    }
    if let Some(var_372) = &input.threat_intel_indicator_type {
        let mut array_373 = object.key("ThreatIntelIndicatorType").start_array();
        for item_374 in var_372 {
            {
                let mut object_375 = array_373.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_375,
                    item_374,
                );
                object_375.finish();
            }
        }
        array_373.finish();
    }
    if let Some(var_376) = &input.threat_intel_indicator_value {
        let mut array_377 = object.key("ThreatIntelIndicatorValue").start_array();
        for item_378 in var_376 {
            {
                let mut object_379 = array_377.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_379,
                    item_378,
                );
                object_379.finish();
            }
        }
        array_377.finish();
    }
    if let Some(var_380) = &input.threat_intel_indicator_category {
        let mut array_381 = object.key("ThreatIntelIndicatorCategory").start_array();
        for item_382 in var_380 {
            {
                let mut object_383 = array_381.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_383,
                    item_382,
                );
                object_383.finish();
            }
        }
        array_381.finish();
    }
    if let Some(var_384) = &input.threat_intel_indicator_last_observed_at {
        let mut array_385 = object
            .key("ThreatIntelIndicatorLastObservedAt")
            .start_array();
        for item_386 in var_384 {
            {
                let mut object_387 = array_385.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_387,
                    item_386,
                );
                object_387.finish();
            }
        }
        array_385.finish();
    }
    if let Some(var_388) = &input.threat_intel_indicator_source {
        let mut array_389 = object.key("ThreatIntelIndicatorSource").start_array();
        for item_390 in var_388 {
            {
                let mut object_391 = array_389.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_391,
                    item_390,
                );
                object_391.finish();
            }
        }
        array_389.finish();
    }
    if let Some(var_392) = &input.threat_intel_indicator_source_url {
        let mut array_393 = object.key("ThreatIntelIndicatorSourceUrl").start_array();
        for item_394 in var_392 {
            {
                let mut object_395 = array_393.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_395,
                    item_394,
                );
                object_395.finish();
            }
        }
        array_393.finish();
    }
    if let Some(var_396) = &input.resource_type {
        let mut array_397 = object.key("ResourceType").start_array();
        for item_398 in var_396 {
            {
                let mut object_399 = array_397.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_399,
                    item_398,
                );
                object_399.finish();
            }
        }
        array_397.finish();
    }
    if let Some(var_400) = &input.resource_id {
        let mut array_401 = object.key("ResourceId").start_array();
        for item_402 in var_400 {
            {
                let mut object_403 = array_401.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_403,
                    item_402,
                );
                object_403.finish();
            }
        }
        array_401.finish();
    }
    if let Some(var_404) = &input.resource_partition {
        let mut array_405 = object.key("ResourcePartition").start_array();
        for item_406 in var_404 {
            {
                let mut object_407 = array_405.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_407,
                    item_406,
                );
                object_407.finish();
            }
        }
        array_405.finish();
    }
    if let Some(var_408) = &input.resource_region {
        let mut array_409 = object.key("ResourceRegion").start_array();
        for item_410 in var_408 {
            {
                let mut object_411 = array_409.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_411,
                    item_410,
                );
                object_411.finish();
            }
        }
        array_409.finish();
    }
    if let Some(var_412) = &input.resource_tags {
        let mut array_413 = object.key("ResourceTags").start_array();
        for item_414 in var_412 {
            {
                let mut object_415 = array_413.value().start_object();
                crate::json_ser::serialize_structure_crate_model_map_filter(
                    &mut object_415,
                    item_414,
                );
                object_415.finish();
            }
        }
        array_413.finish();
    }
    if let Some(var_416) = &input.resource_aws_ec2_instance_type {
        let mut array_417 = object.key("ResourceAwsEc2InstanceType").start_array();
        for item_418 in var_416 {
            {
                let mut object_419 = array_417.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_419,
                    item_418,
                );
                object_419.finish();
            }
        }
        array_417.finish();
    }
    if let Some(var_420) = &input.resource_aws_ec2_instance_image_id {
        let mut array_421 = object.key("ResourceAwsEc2InstanceImageId").start_array();
        for item_422 in var_420 {
            {
                let mut object_423 = array_421.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_423,
                    item_422,
                );
                object_423.finish();
            }
        }
        array_421.finish();
    }
    if let Some(var_424) = &input.resource_aws_ec2_instance_ip_v4_addresses {
        let mut array_425 = object
            .key("ResourceAwsEc2InstanceIpV4Addresses")
            .start_array();
        for item_426 in var_424 {
            {
                let mut object_427 = array_425.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ip_filter(
                    &mut object_427,
                    item_426,
                );
                object_427.finish();
            }
        }
        array_425.finish();
    }
    if let Some(var_428) = &input.resource_aws_ec2_instance_ip_v6_addresses {
        let mut array_429 = object
            .key("ResourceAwsEc2InstanceIpV6Addresses")
            .start_array();
        for item_430 in var_428 {
            {
                let mut object_431 = array_429.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ip_filter(
                    &mut object_431,
                    item_430,
                );
                object_431.finish();
            }
        }
        array_429.finish();
    }
    if let Some(var_432) = &input.resource_aws_ec2_instance_key_name {
        let mut array_433 = object.key("ResourceAwsEc2InstanceKeyName").start_array();
        for item_434 in var_432 {
            {
                let mut object_435 = array_433.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_435,
                    item_434,
                );
                object_435.finish();
            }
        }
        array_433.finish();
    }
    if let Some(var_436) = &input.resource_aws_ec2_instance_iam_instance_profile_arn {
        let mut array_437 = object
            .key("ResourceAwsEc2InstanceIamInstanceProfileArn")
            .start_array();
        for item_438 in var_436 {
            {
                let mut object_439 = array_437.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_439,
                    item_438,
                );
                object_439.finish();
            }
        }
        array_437.finish();
    }
    if let Some(var_440) = &input.resource_aws_ec2_instance_vpc_id {
        let mut array_441 = object.key("ResourceAwsEc2InstanceVpcId").start_array();
        for item_442 in var_440 {
            {
                let mut object_443 = array_441.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_443,
                    item_442,
                );
                object_443.finish();
            }
        }
        array_441.finish();
    }
    if let Some(var_444) = &input.resource_aws_ec2_instance_subnet_id {
        let mut array_445 = object.key("ResourceAwsEc2InstanceSubnetId").start_array();
        for item_446 in var_444 {
            {
                let mut object_447 = array_445.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_447,
                    item_446,
                );
                object_447.finish();
            }
        }
        array_445.finish();
    }
    if let Some(var_448) = &input.resource_aws_ec2_instance_launched_at {
        let mut array_449 = object.key("ResourceAwsEc2InstanceLaunchedAt").start_array();
        for item_450 in var_448 {
            {
                let mut object_451 = array_449.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_451,
                    item_450,
                );
                object_451.finish();
            }
        }
        array_449.finish();
    }
    if let Some(var_452) = &input.resource_aws_s3_bucket_owner_id {
        let mut array_453 = object.key("ResourceAwsS3BucketOwnerId").start_array();
        for item_454 in var_452 {
            {
                let mut object_455 = array_453.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_455,
                    item_454,
                );
                object_455.finish();
            }
        }
        array_453.finish();
    }
    if let Some(var_456) = &input.resource_aws_s3_bucket_owner_name {
        let mut array_457 = object.key("ResourceAwsS3BucketOwnerName").start_array();
        for item_458 in var_456 {
            {
                let mut object_459 = array_457.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_459,
                    item_458,
                );
                object_459.finish();
            }
        }
        array_457.finish();
    }
    if let Some(var_460) = &input.resource_aws_iam_access_key_user_name {
        let mut array_461 = object.key("ResourceAwsIamAccessKeyUserName").start_array();
        for item_462 in var_460 {
            {
                let mut object_463 = array_461.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_463,
                    item_462,
                );
                object_463.finish();
            }
        }
        array_461.finish();
    }
    if let Some(var_464) = &input.resource_aws_iam_access_key_principal_name {
        let mut array_465 = object
            .key("ResourceAwsIamAccessKeyPrincipalName")
            .start_array();
        for item_466 in var_464 {
            {
                let mut object_467 = array_465.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_467,
                    item_466,
                );
                object_467.finish();
            }
        }
        array_465.finish();
    }
    if let Some(var_468) = &input.resource_aws_iam_access_key_status {
        let mut array_469 = object.key("ResourceAwsIamAccessKeyStatus").start_array();
        for item_470 in var_468 {
            {
                let mut object_471 = array_469.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_471,
                    item_470,
                );
                object_471.finish();
            }
        }
        array_469.finish();
    }
    if let Some(var_472) = &input.resource_aws_iam_access_key_created_at {
        let mut array_473 = object.key("ResourceAwsIamAccessKeyCreatedAt").start_array();
        for item_474 in var_472 {
            {
                let mut object_475 = array_473.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_475,
                    item_474,
                );
                object_475.finish();
            }
        }
        array_473.finish();
    }
    if let Some(var_476) = &input.resource_aws_iam_user_user_name {
        let mut array_477 = object.key("ResourceAwsIamUserUserName").start_array();
        for item_478 in var_476 {
            {
                let mut object_479 = array_477.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_479,
                    item_478,
                );
                object_479.finish();
            }
        }
        array_477.finish();
    }
    if let Some(var_480) = &input.resource_container_name {
        let mut array_481 = object.key("ResourceContainerName").start_array();
        for item_482 in var_480 {
            {
                let mut object_483 = array_481.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_483,
                    item_482,
                );
                object_483.finish();
            }
        }
        array_481.finish();
    }
    if let Some(var_484) = &input.resource_container_image_id {
        let mut array_485 = object.key("ResourceContainerImageId").start_array();
        for item_486 in var_484 {
            {
                let mut object_487 = array_485.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_487,
                    item_486,
                );
                object_487.finish();
            }
        }
        array_485.finish();
    }
    if let Some(var_488) = &input.resource_container_image_name {
        let mut array_489 = object.key("ResourceContainerImageName").start_array();
        for item_490 in var_488 {
            {
                let mut object_491 = array_489.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_491,
                    item_490,
                );
                object_491.finish();
            }
        }
        array_489.finish();
    }
    if let Some(var_492) = &input.resource_container_launched_at {
        let mut array_493 = object.key("ResourceContainerLaunchedAt").start_array();
        for item_494 in var_492 {
            {
                let mut object_495 = array_493.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_495,
                    item_494,
                );
                object_495.finish();
            }
        }
        array_493.finish();
    }
    if let Some(var_496) = &input.resource_details_other {
        let mut array_497 = object.key("ResourceDetailsOther").start_array();
        for item_498 in var_496 {
            {
                let mut object_499 = array_497.value().start_object();
                crate::json_ser::serialize_structure_crate_model_map_filter(
                    &mut object_499,
                    item_498,
                );
                object_499.finish();
            }
        }
        array_497.finish();
    }
    if let Some(var_500) = &input.compliance_status {
        let mut array_501 = object.key("ComplianceStatus").start_array();
        for item_502 in var_500 {
            {
                let mut object_503 = array_501.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_503,
                    item_502,
                );
                object_503.finish();
            }
        }
        array_501.finish();
    }
    if let Some(var_504) = &input.verification_state {
        let mut array_505 = object.key("VerificationState").start_array();
        for item_506 in var_504 {
            {
                let mut object_507 = array_505.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_507,
                    item_506,
                );
                object_507.finish();
            }
        }
        array_505.finish();
    }
    if let Some(var_508) = &input.workflow_state {
        let mut array_509 = object.key("WorkflowState").start_array();
        for item_510 in var_508 {
            {
                let mut object_511 = array_509.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_511,
                    item_510,
                );
                object_511.finish();
            }
        }
        array_509.finish();
    }
    if let Some(var_512) = &input.workflow_status {
        let mut array_513 = object.key("WorkflowStatus").start_array();
        for item_514 in var_512 {
            {
                let mut object_515 = array_513.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_515,
                    item_514,
                );
                object_515.finish();
            }
        }
        array_513.finish();
    }
    if let Some(var_516) = &input.record_state {
        let mut array_517 = object.key("RecordState").start_array();
        for item_518 in var_516 {
            {
                let mut object_519 = array_517.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_519,
                    item_518,
                );
                object_519.finish();
            }
        }
        array_517.finish();
    }
    if let Some(var_520) = &input.related_findings_product_arn {
        let mut array_521 = object.key("RelatedFindingsProductArn").start_array();
        for item_522 in var_520 {
            {
                let mut object_523 = array_521.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_523,
                    item_522,
                );
                object_523.finish();
            }
        }
        array_521.finish();
    }
    if let Some(var_524) = &input.related_findings_id {
        let mut array_525 = object.key("RelatedFindingsId").start_array();
        for item_526 in var_524 {
            {
                let mut object_527 = array_525.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_527,
                    item_526,
                );
                object_527.finish();
            }
        }
        array_525.finish();
    }
    if let Some(var_528) = &input.note_text {
        let mut array_529 = object.key("NoteText").start_array();
        for item_530 in var_528 {
            {
                let mut object_531 = array_529.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_531,
                    item_530,
                );
                object_531.finish();
            }
        }
        array_529.finish();
    }
    if let Some(var_532) = &input.note_updated_at {
        let mut array_533 = object.key("NoteUpdatedAt").start_array();
        for item_534 in var_532 {
            {
                let mut object_535 = array_533.value().start_object();
                crate::json_ser::serialize_structure_crate_model_date_filter(
                    &mut object_535,
                    item_534,
                );
                object_535.finish();
            }
        }
        array_533.finish();
    }
    if let Some(var_536) = &input.note_updated_by {
        let mut array_537 = object.key("NoteUpdatedBy").start_array();
        for item_538 in var_536 {
            {
                let mut object_539 = array_537.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_539,
                    item_538,
                );
                object_539.finish();
            }
        }
        array_537.finish();
    }
    if let Some(var_540) = &input.keyword {
        let mut array_541 = object.key("Keyword").start_array();
        for item_542 in var_540 {
            {
                let mut object_543 = array_541.value().start_object();
                crate::json_ser::serialize_structure_crate_model_keyword_filter(
                    &mut object_543,
                    item_542,
                );
                object_543.finish();
            }
        }
        array_541.finish();
    }
    if let Some(var_544) = &input.finding_provider_fields_confidence {
        let mut array_545 = object.key("FindingProviderFieldsConfidence").start_array();
        for item_546 in var_544 {
            {
                let mut object_547 = array_545.value().start_object();
                crate::json_ser::serialize_structure_crate_model_number_filter(
                    &mut object_547,
                    item_546,
                );
                object_547.finish();
            }
        }
        array_545.finish();
    }
    if let Some(var_548) = &input.finding_provider_fields_criticality {
        let mut array_549 = object.key("FindingProviderFieldsCriticality").start_array();
        for item_550 in var_548 {
            {
                let mut object_551 = array_549.value().start_object();
                crate::json_ser::serialize_structure_crate_model_number_filter(
                    &mut object_551,
                    item_550,
                );
                object_551.finish();
            }
        }
        array_549.finish();
    }
    if let Some(var_552) = &input.finding_provider_fields_related_findings_id {
        let mut array_553 = object
            .key("FindingProviderFieldsRelatedFindingsId")
            .start_array();
        for item_554 in var_552 {
            {
                let mut object_555 = array_553.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_555,
                    item_554,
                );
                object_555.finish();
            }
        }
        array_553.finish();
    }
    if let Some(var_556) = &input.finding_provider_fields_related_findings_product_arn {
        let mut array_557 = object
            .key("FindingProviderFieldsRelatedFindingsProductArn")
            .start_array();
        for item_558 in var_556 {
            {
                let mut object_559 = array_557.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_559,
                    item_558,
                );
                object_559.finish();
            }
        }
        array_557.finish();
    }
    if let Some(var_560) = &input.finding_provider_fields_severity_label {
        let mut array_561 = object
            .key("FindingProviderFieldsSeverityLabel")
            .start_array();
        for item_562 in var_560 {
            {
                let mut object_563 = array_561.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_563,
                    item_562,
                );
                object_563.finish();
            }
        }
        array_561.finish();
    }
    if let Some(var_564) = &input.finding_provider_fields_severity_original {
        let mut array_565 = object
            .key("FindingProviderFieldsSeverityOriginal")
            .start_array();
        for item_566 in var_564 {
            {
                let mut object_567 = array_565.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_567,
                    item_566,
                );
                object_567.finish();
            }
        }
        array_565.finish();
    }
    if let Some(var_568) = &input.finding_provider_fields_types {
        let mut array_569 = object.key("FindingProviderFieldsTypes").start_array();
        for item_570 in var_568 {
            {
                let mut object_571 = array_569.value().start_object();
                crate::json_ser::serialize_structure_crate_model_string_filter(
                    &mut object_571,
                    item_570,
                );
                object_571.finish();
            }
        }
        array_569.finish();
    }
}

pub fn serialize_structure_crate_model_account_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AccountDetails,
) {
    if let Some(var_572) = &input.account_id {
        object.key("AccountId").string(var_572);
    }
    if let Some(var_573) = &input.email {
        object.key("Email").string(var_573);
    }
}

pub fn serialize_structure_crate_model_sort_criterion(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SortCriterion,
) {
    if let Some(var_574) = &input.field {
        object.key("Field").string(var_574);
    }
    if let Some(var_575) = &input.sort_order {
        object.key("SortOrder").string(var_575.as_str());
    }
}

pub fn serialize_structure_crate_model_severity(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Severity,
) {
    if input.product != 0.0 {
        object.key("Product").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.product).into()),
        );
    }
    if let Some(var_576) = &input.label {
        object.key("Label").string(var_576.as_str());
    }
    if input.normalized != 0 {
        object.key("Normalized").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.normalized).into()),
        );
    }
    if let Some(var_577) = &input.original {
        object.key("Original").string(var_577);
    }
}

pub fn serialize_structure_crate_model_remediation(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Remediation,
) {
    if let Some(var_578) = &input.recommendation {
        let mut object_579 = object.key("Recommendation").start_object();
        crate::json_ser::serialize_structure_crate_model_recommendation(&mut object_579, var_578);
        object_579.finish();
    }
}

pub fn serialize_structure_crate_model_malware(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Malware,
) {
    if let Some(var_580) = &input.name {
        object.key("Name").string(var_580);
    }
    if let Some(var_581) = &input.r#type {
        object.key("Type").string(var_581.as_str());
    }
    if let Some(var_582) = &input.path {
        object.key("Path").string(var_582);
    }
    if let Some(var_583) = &input.state {
        object.key("State").string(var_583.as_str());
    }
}

pub fn serialize_structure_crate_model_network(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Network,
) {
    if let Some(var_584) = &input.direction {
        object.key("Direction").string(var_584.as_str());
    }
    if let Some(var_585) = &input.protocol {
        object.key("Protocol").string(var_585);
    }
    if let Some(var_586) = &input.open_port_range {
        let mut object_587 = object.key("OpenPortRange").start_object();
        crate::json_ser::serialize_structure_crate_model_port_range(&mut object_587, var_586);
        object_587.finish();
    }
    if let Some(var_588) = &input.source_ip_v4 {
        object.key("SourceIpV4").string(var_588);
    }
    if let Some(var_589) = &input.source_ip_v6 {
        object.key("SourceIpV6").string(var_589);
    }
    if input.source_port != 0 {
        object.key("SourcePort").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.source_port).into()),
        );
    }
    if let Some(var_590) = &input.source_domain {
        object.key("SourceDomain").string(var_590);
    }
    if let Some(var_591) = &input.source_mac {
        object.key("SourceMac").string(var_591);
    }
    if let Some(var_592) = &input.destination_ip_v4 {
        object.key("DestinationIpV4").string(var_592);
    }
    if let Some(var_593) = &input.destination_ip_v6 {
        object.key("DestinationIpV6").string(var_593);
    }
    if input.destination_port != 0 {
        object.key("DestinationPort").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.destination_port).into()),
        );
    }
    if let Some(var_594) = &input.destination_domain {
        object.key("DestinationDomain").string(var_594);
    }
}

pub fn serialize_structure_crate_model_network_path_component(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NetworkPathComponent,
) {
    if let Some(var_595) = &input.component_id {
        object.key("ComponentId").string(var_595);
    }
    if let Some(var_596) = &input.component_type {
        object.key("ComponentType").string(var_596);
    }
    if let Some(var_597) = &input.egress {
        let mut object_598 = object.key("Egress").start_object();
        crate::json_ser::serialize_structure_crate_model_network_header(&mut object_598, var_597);
        object_598.finish();
    }
    if let Some(var_599) = &input.ingress {
        let mut object_600 = object.key("Ingress").start_object();
        crate::json_ser::serialize_structure_crate_model_network_header(&mut object_600, var_599);
        object_600.finish();
    }
}

pub fn serialize_structure_crate_model_process_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ProcessDetails,
) {
    if let Some(var_601) = &input.name {
        object.key("Name").string(var_601);
    }
    if let Some(var_602) = &input.path {
        object.key("Path").string(var_602);
    }
    if input.pid != 0 {
        object.key("Pid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.pid).into()),
        );
    }
    if input.parent_pid != 0 {
        object.key("ParentPid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.parent_pid).into()),
        );
    }
    if let Some(var_603) = &input.launched_at {
        object.key("LaunchedAt").string(var_603);
    }
    if let Some(var_604) = &input.terminated_at {
        object.key("TerminatedAt").string(var_604);
    }
}

pub fn serialize_structure_crate_model_threat_intel_indicator(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ThreatIntelIndicator,
) {
    if let Some(var_605) = &input.r#type {
        object.key("Type").string(var_605.as_str());
    }
    if let Some(var_606) = &input.value {
        object.key("Value").string(var_606);
    }
    if let Some(var_607) = &input.category {
        object.key("Category").string(var_607.as_str());
    }
    if let Some(var_608) = &input.last_observed_at {
        object.key("LastObservedAt").string(var_608);
    }
    if let Some(var_609) = &input.source {
        object.key("Source").string(var_609);
    }
    if let Some(var_610) = &input.source_url {
        object.key("SourceUrl").string(var_610);
    }
}

pub fn serialize_structure_crate_model_resource(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Resource,
) {
    if let Some(var_611) = &input.r#type {
        object.key("Type").string(var_611);
    }
    if let Some(var_612) = &input.id {
        object.key("Id").string(var_612);
    }
    if let Some(var_613) = &input.partition {
        object.key("Partition").string(var_613.as_str());
    }
    if let Some(var_614) = &input.region {
        object.key("Region").string(var_614);
    }
    if let Some(var_615) = &input.resource_role {
        object.key("ResourceRole").string(var_615);
    }
    if let Some(var_616) = &input.tags {
        let mut object_617 = object.key("Tags").start_object();
        for (key_618, value_619) in var_616 {
            {
                object_617.key(key_618).string(value_619);
            }
        }
        object_617.finish();
    }
    if let Some(var_620) = &input.data_classification {
        let mut object_621 = object.key("DataClassification").start_object();
        crate::json_ser::serialize_structure_crate_model_data_classification_details(
            &mut object_621,
            var_620,
        );
        object_621.finish();
    }
    if let Some(var_622) = &input.details {
        let mut object_623 = object.key("Details").start_object();
        crate::json_ser::serialize_structure_crate_model_resource_details(&mut object_623, var_622);
        object_623.finish();
    }
}

pub fn serialize_structure_crate_model_compliance(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Compliance,
) {
    if let Some(var_624) = &input.status {
        object.key("Status").string(var_624.as_str());
    }
    if let Some(var_625) = &input.related_requirements {
        let mut array_626 = object.key("RelatedRequirements").start_array();
        for item_627 in var_625 {
            {
                array_626.value().string(item_627);
            }
        }
        array_626.finish();
    }
    if let Some(var_628) = &input.status_reasons {
        let mut array_629 = object.key("StatusReasons").start_array();
        for item_630 in var_628 {
            {
                let mut object_631 = array_629.value().start_object();
                crate::json_ser::serialize_structure_crate_model_status_reason(
                    &mut object_631,
                    item_630,
                );
                object_631.finish();
            }
        }
        array_629.finish();
    }
}

pub fn serialize_structure_crate_model_workflow(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Workflow,
) {
    if let Some(var_632) = &input.status {
        object.key("Status").string(var_632.as_str());
    }
}

pub fn serialize_structure_crate_model_note(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Note,
) {
    if let Some(var_633) = &input.text {
        object.key("Text").string(var_633);
    }
    if let Some(var_634) = &input.updated_by {
        object.key("UpdatedBy").string(var_634);
    }
    if let Some(var_635) = &input.updated_at {
        object.key("UpdatedAt").string(var_635);
    }
}

pub fn serialize_structure_crate_model_vulnerability(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Vulnerability,
) {
    if let Some(var_636) = &input.id {
        object.key("Id").string(var_636);
    }
    if let Some(var_637) = &input.vulnerable_packages {
        let mut array_638 = object.key("VulnerablePackages").start_array();
        for item_639 in var_637 {
            {
                let mut object_640 = array_638.value().start_object();
                crate::json_ser::serialize_structure_crate_model_software_package(
                    &mut object_640,
                    item_639,
                );
                object_640.finish();
            }
        }
        array_638.finish();
    }
    if let Some(var_641) = &input.cvss {
        let mut array_642 = object.key("Cvss").start_array();
        for item_643 in var_641 {
            {
                let mut object_644 = array_642.value().start_object();
                crate::json_ser::serialize_structure_crate_model_cvss(&mut object_644, item_643);
                object_644.finish();
            }
        }
        array_642.finish();
    }
    if let Some(var_645) = &input.related_vulnerabilities {
        let mut array_646 = object.key("RelatedVulnerabilities").start_array();
        for item_647 in var_645 {
            {
                array_646.value().string(item_647);
            }
        }
        array_646.finish();
    }
    if let Some(var_648) = &input.vendor {
        let mut object_649 = object.key("Vendor").start_object();
        crate::json_ser::serialize_structure_crate_model_vulnerability_vendor(
            &mut object_649,
            var_648,
        );
        object_649.finish();
    }
    if let Some(var_650) = &input.reference_urls {
        let mut array_651 = object.key("ReferenceUrls").start_array();
        for item_652 in var_650 {
            {
                array_651.value().string(item_652);
            }
        }
        array_651.finish();
    }
}

pub fn serialize_structure_crate_model_patch_summary(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::PatchSummary,
) {
    if let Some(var_653) = &input.id {
        object.key("Id").string(var_653);
    }
    if input.installed_count != 0 {
        object.key("InstalledCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.installed_count).into()),
        );
    }
    if input.missing_count != 0 {
        object.key("MissingCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.missing_count).into()),
        );
    }
    if input.failed_count != 0 {
        object.key("FailedCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.failed_count).into()),
        );
    }
    if input.installed_other_count != 0 {
        object.key("InstalledOtherCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.installed_other_count).into()),
        );
    }
    if input.installed_rejected_count != 0 {
        object.key("InstalledRejectedCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.installed_rejected_count).into()),
        );
    }
    if input.installed_pending_reboot != 0 {
        object.key("InstalledPendingReboot").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.installed_pending_reboot).into()),
        );
    }
    if let Some(var_654) = &input.operation_start_time {
        object.key("OperationStartTime").string(var_654);
    }
    if let Some(var_655) = &input.operation_end_time {
        object.key("OperationEndTime").string(var_655);
    }
    if let Some(var_656) = &input.reboot_option {
        object.key("RebootOption").string(var_656);
    }
    if let Some(var_657) = &input.operation {
        object.key("Operation").string(var_657);
    }
}

pub fn serialize_structure_crate_model_action(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Action,
) {
    if let Some(var_658) = &input.action_type {
        object.key("ActionType").string(var_658);
    }
    if let Some(var_659) = &input.network_connection_action {
        let mut object_660 = object.key("NetworkConnectionAction").start_object();
        crate::json_ser::serialize_structure_crate_model_network_connection_action(
            &mut object_660,
            var_659,
        );
        object_660.finish();
    }
    if let Some(var_661) = &input.aws_api_call_action {
        let mut object_662 = object.key("AwsApiCallAction").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_api_call_action(
            &mut object_662,
            var_661,
        );
        object_662.finish();
    }
    if let Some(var_663) = &input.dns_request_action {
        let mut object_664 = object.key("DnsRequestAction").start_object();
        crate::json_ser::serialize_structure_crate_model_dns_request_action(
            &mut object_664,
            var_663,
        );
        object_664.finish();
    }
    if let Some(var_665) = &input.port_probe_action {
        let mut object_666 = object.key("PortProbeAction").start_object();
        crate::json_ser::serialize_structure_crate_model_port_probe_action(
            &mut object_666,
            var_665,
        );
        object_666.finish();
    }
}

pub fn serialize_structure_crate_model_finding_provider_fields(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FindingProviderFields,
) {
    if input.confidence != 0 {
        object.key("Confidence").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.confidence).into()),
        );
    }
    if input.criticality != 0 {
        object.key("Criticality").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.criticality).into()),
        );
    }
    if let Some(var_667) = &input.related_findings {
        let mut array_668 = object.key("RelatedFindings").start_array();
        for item_669 in var_667 {
            {
                let mut object_670 = array_668.value().start_object();
                crate::json_ser::serialize_structure_crate_model_related_finding(
                    &mut object_670,
                    item_669,
                );
                object_670.finish();
            }
        }
        array_668.finish();
    }
    if let Some(var_671) = &input.severity {
        let mut object_672 = object.key("Severity").start_object();
        crate::json_ser::serialize_structure_crate_model_finding_provider_severity(
            &mut object_672,
            var_671,
        );
        object_672.finish();
    }
    if let Some(var_673) = &input.types {
        let mut array_674 = object.key("Types").start_array();
        for item_675 in var_673 {
            {
                array_674.value().string(item_675);
            }
        }
        array_674.finish();
    }
}

pub fn serialize_structure_crate_model_string_filter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::StringFilter,
) {
    if let Some(var_676) = &input.value {
        object.key("Value").string(var_676);
    }
    if let Some(var_677) = &input.comparison {
        object.key("Comparison").string(var_677.as_str());
    }
}

pub fn serialize_structure_crate_model_date_filter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DateFilter,
) {
    if let Some(var_678) = &input.start {
        object.key("Start").string(var_678);
    }
    if let Some(var_679) = &input.end {
        object.key("End").string(var_679);
    }
    if let Some(var_680) = &input.date_range {
        let mut object_681 = object.key("DateRange").start_object();
        crate::json_ser::serialize_structure_crate_model_date_range(&mut object_681, var_680);
        object_681.finish();
    }
}

pub fn serialize_structure_crate_model_number_filter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NumberFilter,
) {
    if input.gte != 0.0 {
        object.key("Gte").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.gte).into()),
        );
    }
    if input.lte != 0.0 {
        object.key("Lte").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.lte).into()),
        );
    }
    if input.eq != 0.0 {
        object.key("Eq").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.eq).into()),
        );
    }
}

pub fn serialize_structure_crate_model_map_filter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MapFilter,
) {
    if let Some(var_682) = &input.key {
        object.key("Key").string(var_682);
    }
    if let Some(var_683) = &input.value {
        object.key("Value").string(var_683);
    }
    if let Some(var_684) = &input.comparison {
        object.key("Comparison").string(var_684.as_str());
    }
}

pub fn serialize_structure_crate_model_ip_filter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::IpFilter,
) {
    if let Some(var_685) = &input.cidr {
        object.key("Cidr").string(var_685);
    }
}

pub fn serialize_structure_crate_model_keyword_filter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::KeywordFilter,
) {
    if let Some(var_686) = &input.value {
        object.key("Value").string(var_686);
    }
}

pub fn serialize_structure_crate_model_recommendation(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Recommendation,
) {
    if let Some(var_687) = &input.text {
        object.key("Text").string(var_687);
    }
    if let Some(var_688) = &input.url {
        object.key("Url").string(var_688);
    }
}

pub fn serialize_structure_crate_model_port_range(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::PortRange,
) {
    if input.begin != 0 {
        object.key("Begin").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.begin).into()),
        );
    }
    if input.end != 0 {
        object.key("End").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.end).into()),
        );
    }
}

pub fn serialize_structure_crate_model_network_header(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NetworkHeader,
) {
    if let Some(var_689) = &input.protocol {
        object.key("Protocol").string(var_689);
    }
    if let Some(var_690) = &input.destination {
        let mut object_691 = object.key("Destination").start_object();
        crate::json_ser::serialize_structure_crate_model_network_path_component_details(
            &mut object_691,
            var_690,
        );
        object_691.finish();
    }
    if let Some(var_692) = &input.source {
        let mut object_693 = object.key("Source").start_object();
        crate::json_ser::serialize_structure_crate_model_network_path_component_details(
            &mut object_693,
            var_692,
        );
        object_693.finish();
    }
}

pub fn serialize_structure_crate_model_data_classification_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DataClassificationDetails,
) {
    if let Some(var_694) = &input.detailed_results_location {
        object.key("DetailedResultsLocation").string(var_694);
    }
    if let Some(var_695) = &input.result {
        let mut object_696 = object.key("Result").start_object();
        crate::json_ser::serialize_structure_crate_model_classification_result(
            &mut object_696,
            var_695,
        );
        object_696.finish();
    }
}

pub fn serialize_structure_crate_model_resource_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ResourceDetails,
) {
    if let Some(var_697) = &input.aws_auto_scaling_auto_scaling_group {
        let mut object_698 = object.key("AwsAutoScalingAutoScalingGroup").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_auto_scaling_auto_scaling_group_details(&mut object_698, var_697);
        object_698.finish();
    }
    if let Some(var_699) = &input.aws_code_build_project {
        let mut object_700 = object.key("AwsCodeBuildProject").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_code_build_project_details(
            &mut object_700,
            var_699,
        );
        object_700.finish();
    }
    if let Some(var_701) = &input.aws_cloud_front_distribution {
        let mut object_702 = object.key("AwsCloudFrontDistribution").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_details(
            &mut object_702,
            var_701,
        );
        object_702.finish();
    }
    if let Some(var_703) = &input.aws_ec2_instance {
        let mut object_704 = object.key("AwsEc2Instance").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ec2_instance_details(
            &mut object_704,
            var_703,
        );
        object_704.finish();
    }
    if let Some(var_705) = &input.aws_ec2_network_interface {
        let mut object_706 = object.key("AwsEc2NetworkInterface").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ec2_network_interface_details(
            &mut object_706,
            var_705,
        );
        object_706.finish();
    }
    if let Some(var_707) = &input.aws_ec2_security_group {
        let mut object_708 = object.key("AwsEc2SecurityGroup").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ec2_security_group_details(
            &mut object_708,
            var_707,
        );
        object_708.finish();
    }
    if let Some(var_709) = &input.aws_ec2_volume {
        let mut object_710 = object.key("AwsEc2Volume").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ec2_volume_details(
            &mut object_710,
            var_709,
        );
        object_710.finish();
    }
    if let Some(var_711) = &input.aws_ec2_vpc {
        let mut object_712 = object.key("AwsEc2Vpc").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ec2_vpc_details(
            &mut object_712,
            var_711,
        );
        object_712.finish();
    }
    if let Some(var_713) = &input.aws_ec2_eip {
        let mut object_714 = object.key("AwsEc2Eip").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ec2_eip_details(
            &mut object_714,
            var_713,
        );
        object_714.finish();
    }
    if let Some(var_715) = &input.aws_ec2_subnet {
        let mut object_716 = object.key("AwsEc2Subnet").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ec2_subnet_details(
            &mut object_716,
            var_715,
        );
        object_716.finish();
    }
    if let Some(var_717) = &input.aws_ec2_network_acl {
        let mut object_718 = object.key("AwsEc2NetworkAcl").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ec2_network_acl_details(
            &mut object_718,
            var_717,
        );
        object_718.finish();
    }
    if let Some(var_719) = &input.aws_elbv2_load_balancer {
        let mut object_720 = object.key("AwsElbv2LoadBalancer").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elbv2_load_balancer_details(
            &mut object_720,
            var_719,
        );
        object_720.finish();
    }
    if let Some(var_721) = &input.aws_elastic_beanstalk_environment {
        let mut object_722 = object.key("AwsElasticBeanstalkEnvironment").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elastic_beanstalk_environment_details(
            &mut object_722,
            var_721,
        );
        object_722.finish();
    }
    if let Some(var_723) = &input.aws_elasticsearch_domain {
        let mut object_724 = object.key("AwsElasticsearchDomain").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_details(
            &mut object_724,
            var_723,
        );
        object_724.finish();
    }
    if let Some(var_725) = &input.aws_s3_bucket {
        let mut object_726 = object.key("AwsS3Bucket").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_details(
            &mut object_726,
            var_725,
        );
        object_726.finish();
    }
    if let Some(var_727) = &input.aws_s3_account_public_access_block {
        let mut object_728 = object.key("AwsS3AccountPublicAccessBlock").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_account_public_access_block_details(
            &mut object_728,
            var_727,
        );
        object_728.finish();
    }
    if let Some(var_729) = &input.aws_s3_object {
        let mut object_730 = object.key("AwsS3Object").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_object_details(
            &mut object_730,
            var_729,
        );
        object_730.finish();
    }
    if let Some(var_731) = &input.aws_secrets_manager_secret {
        let mut object_732 = object.key("AwsSecretsManagerSecret").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_secrets_manager_secret_details(
            &mut object_732,
            var_731,
        );
        object_732.finish();
    }
    if let Some(var_733) = &input.aws_iam_access_key {
        let mut object_734 = object.key("AwsIamAccessKey").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_iam_access_key_details(
            &mut object_734,
            var_733,
        );
        object_734.finish();
    }
    if let Some(var_735) = &input.aws_iam_user {
        let mut object_736 = object.key("AwsIamUser").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_iam_user_details(
            &mut object_736,
            var_735,
        );
        object_736.finish();
    }
    if let Some(var_737) = &input.aws_iam_policy {
        let mut object_738 = object.key("AwsIamPolicy").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_iam_policy_details(
            &mut object_738,
            var_737,
        );
        object_738.finish();
    }
    if let Some(var_739) = &input.aws_api_gateway_v2_stage {
        let mut object_740 = object.key("AwsApiGatewayV2Stage").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_api_gateway_v2_stage_details(
            &mut object_740,
            var_739,
        );
        object_740.finish();
    }
    if let Some(var_741) = &input.aws_api_gateway_v2_api {
        let mut object_742 = object.key("AwsApiGatewayV2Api").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_api_gateway_v2_api_details(
            &mut object_742,
            var_741,
        );
        object_742.finish();
    }
    if let Some(var_743) = &input.aws_dynamo_db_table {
        let mut object_744 = object.key("AwsDynamoDbTable").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_details(
            &mut object_744,
            var_743,
        );
        object_744.finish();
    }
    if let Some(var_745) = &input.aws_api_gateway_stage {
        let mut object_746 = object.key("AwsApiGatewayStage").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_api_gateway_stage_details(
            &mut object_746,
            var_745,
        );
        object_746.finish();
    }
    if let Some(var_747) = &input.aws_api_gateway_rest_api {
        let mut object_748 = object.key("AwsApiGatewayRestApi").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_api_gateway_rest_api_details(
            &mut object_748,
            var_747,
        );
        object_748.finish();
    }
    if let Some(var_749) = &input.aws_cloud_trail_trail {
        let mut object_750 = object.key("AwsCloudTrailTrail").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_cloud_trail_trail_details(
            &mut object_750,
            var_749,
        );
        object_750.finish();
    }
    if let Some(var_751) = &input.aws_ssm_patch_compliance {
        let mut object_752 = object.key("AwsSsmPatchCompliance").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ssm_patch_compliance_details(
            &mut object_752,
            var_751,
        );
        object_752.finish();
    }
    if let Some(var_753) = &input.aws_certificate_manager_certificate {
        let mut object_754 = object
            .key("AwsCertificateManagerCertificate")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_aws_certificate_manager_certificate_details(&mut object_754, var_753);
        object_754.finish();
    }
    if let Some(var_755) = &input.aws_redshift_cluster {
        let mut object_756 = object.key("AwsRedshiftCluster").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_details(
            &mut object_756,
            var_755,
        );
        object_756.finish();
    }
    if let Some(var_757) = &input.aws_elb_load_balancer {
        let mut object_758 = object.key("AwsElbLoadBalancer").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_details(
            &mut object_758,
            var_757,
        );
        object_758.finish();
    }
    if let Some(var_759) = &input.aws_iam_group {
        let mut object_760 = object.key("AwsIamGroup").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_iam_group_details(
            &mut object_760,
            var_759,
        );
        object_760.finish();
    }
    if let Some(var_761) = &input.aws_iam_role {
        let mut object_762 = object.key("AwsIamRole").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_iam_role_details(
            &mut object_762,
            var_761,
        );
        object_762.finish();
    }
    if let Some(var_763) = &input.aws_kms_key {
        let mut object_764 = object.key("AwsKmsKey").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_kms_key_details(
            &mut object_764,
            var_763,
        );
        object_764.finish();
    }
    if let Some(var_765) = &input.aws_lambda_function {
        let mut object_766 = object.key("AwsLambdaFunction").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_lambda_function_details(
            &mut object_766,
            var_765,
        );
        object_766.finish();
    }
    if let Some(var_767) = &input.aws_lambda_layer_version {
        let mut object_768 = object.key("AwsLambdaLayerVersion").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_lambda_layer_version_details(
            &mut object_768,
            var_767,
        );
        object_768.finish();
    }
    if let Some(var_769) = &input.aws_rds_db_instance {
        let mut object_770 = object.key("AwsRdsDbInstance").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_rds_db_instance_details(
            &mut object_770,
            var_769,
        );
        object_770.finish();
    }
    if let Some(var_771) = &input.aws_sns_topic {
        let mut object_772 = object.key("AwsSnsTopic").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_sns_topic_details(
            &mut object_772,
            var_771,
        );
        object_772.finish();
    }
    if let Some(var_773) = &input.aws_sqs_queue {
        let mut object_774 = object.key("AwsSqsQueue").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_sqs_queue_details(
            &mut object_774,
            var_773,
        );
        object_774.finish();
    }
    if let Some(var_775) = &input.aws_waf_web_acl {
        let mut object_776 = object.key("AwsWafWebAcl").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_waf_web_acl_details(
            &mut object_776,
            var_775,
        );
        object_776.finish();
    }
    if let Some(var_777) = &input.aws_rds_db_snapshot {
        let mut object_778 = object.key("AwsRdsDbSnapshot").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_rds_db_snapshot_details(
            &mut object_778,
            var_777,
        );
        object_778.finish();
    }
    if let Some(var_779) = &input.aws_rds_db_cluster_snapshot {
        let mut object_780 = object.key("AwsRdsDbClusterSnapshot").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_rds_db_cluster_snapshot_details(
            &mut object_780,
            var_779,
        );
        object_780.finish();
    }
    if let Some(var_781) = &input.aws_rds_db_cluster {
        let mut object_782 = object.key("AwsRdsDbCluster").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_rds_db_cluster_details(
            &mut object_782,
            var_781,
        );
        object_782.finish();
    }
    if let Some(var_783) = &input.aws_ecs_cluster {
        let mut object_784 = object.key("AwsEcsCluster").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_cluster_details(
            &mut object_784,
            var_783,
        );
        object_784.finish();
    }
    if let Some(var_785) = &input.aws_ecs_task_definition {
        let mut object_786 = object.key("AwsEcsTaskDefinition").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_details(
            &mut object_786,
            var_785,
        );
        object_786.finish();
    }
    if let Some(var_787) = &input.container {
        let mut object_788 = object.key("Container").start_object();
        crate::json_ser::serialize_structure_crate_model_container_details(
            &mut object_788,
            var_787,
        );
        object_788.finish();
    }
    if let Some(var_789) = &input.other {
        let mut object_790 = object.key("Other").start_object();
        for (key_791, value_792) in var_789 {
            {
                object_790.key(key_791).string(value_792);
            }
        }
        object_790.finish();
    }
    if let Some(var_793) = &input.aws_rds_event_subscription {
        let mut object_794 = object.key("AwsRdsEventSubscription").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_rds_event_subscription_details(
            &mut object_794,
            var_793,
        );
        object_794.finish();
    }
    if let Some(var_795) = &input.aws_ecs_service {
        let mut object_796 = object.key("AwsEcsService").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_service_details(
            &mut object_796,
            var_795,
        );
        object_796.finish();
    }
    if let Some(var_797) = &input.aws_auto_scaling_launch_configuration {
        let mut object_798 = object
            .key("AwsAutoScalingLaunchConfiguration")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_aws_auto_scaling_launch_configuration_details(&mut object_798, var_797);
        object_798.finish();
    }
    if let Some(var_799) = &input.aws_ec2_vpn_connection {
        let mut object_800 = object.key("AwsEc2VpnConnection").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ec2_vpn_connection_details(
            &mut object_800,
            var_799,
        );
        object_800.finish();
    }
    if let Some(var_801) = &input.aws_ecr_container_image {
        let mut object_802 = object.key("AwsEcrContainerImage").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecr_container_image_details(
            &mut object_802,
            var_801,
        );
        object_802.finish();
    }
    if let Some(var_803) = &input.aws_open_search_service_domain {
        let mut object_804 = object.key("AwsOpenSearchServiceDomain").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_details(
            &mut object_804,
            var_803,
        );
        object_804.finish();
    }
    if let Some(var_805) = &input.aws_ec2_vpc_endpoint_service {
        let mut object_806 = object.key("AwsEc2VpcEndpointService").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ec2_vpc_endpoint_service_details(
            &mut object_806,
            var_805,
        );
        object_806.finish();
    }
    if let Some(var_807) = &input.aws_xray_encryption_config {
        let mut object_808 = object.key("AwsXrayEncryptionConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_xray_encryption_config_details(
            &mut object_808,
            var_807,
        );
        object_808.finish();
    }
    if let Some(var_809) = &input.aws_waf_rate_based_rule {
        let mut object_810 = object.key("AwsWafRateBasedRule").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_waf_rate_based_rule_details(
            &mut object_810,
            var_809,
        );
        object_810.finish();
    }
    if let Some(var_811) = &input.aws_waf_regional_rate_based_rule {
        let mut object_812 = object.key("AwsWafRegionalRateBasedRule").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_waf_regional_rate_based_rule_details(
            &mut object_812,
            var_811,
        );
        object_812.finish();
    }
    if let Some(var_813) = &input.aws_ecr_repository {
        let mut object_814 = object.key("AwsEcrRepository").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecr_repository_details(
            &mut object_814,
            var_813,
        );
        object_814.finish();
    }
    if let Some(var_815) = &input.aws_eks_cluster {
        let mut object_816 = object.key("AwsEksCluster").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_eks_cluster_details(
            &mut object_816,
            var_815,
        );
        object_816.finish();
    }
}

pub fn serialize_structure_crate_model_status_reason(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::StatusReason,
) {
    if let Some(var_817) = &input.reason_code {
        object.key("ReasonCode").string(var_817);
    }
    if let Some(var_818) = &input.description {
        object.key("Description").string(var_818);
    }
}

pub fn serialize_structure_crate_model_software_package(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SoftwarePackage,
) {
    if let Some(var_819) = &input.name {
        object.key("Name").string(var_819);
    }
    if let Some(var_820) = &input.version {
        object.key("Version").string(var_820);
    }
    if let Some(var_821) = &input.epoch {
        object.key("Epoch").string(var_821);
    }
    if let Some(var_822) = &input.release {
        object.key("Release").string(var_822);
    }
    if let Some(var_823) = &input.architecture {
        object.key("Architecture").string(var_823);
    }
    if let Some(var_824) = &input.package_manager {
        object.key("PackageManager").string(var_824);
    }
    if let Some(var_825) = &input.file_path {
        object.key("FilePath").string(var_825);
    }
}

pub fn serialize_structure_crate_model_cvss(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Cvss,
) {
    if let Some(var_826) = &input.version {
        object.key("Version").string(var_826);
    }
    if input.base_score != 0.0 {
        object.key("BaseScore").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.base_score).into()),
        );
    }
    if let Some(var_827) = &input.base_vector {
        object.key("BaseVector").string(var_827);
    }
    if let Some(var_828) = &input.source {
        object.key("Source").string(var_828);
    }
    if let Some(var_829) = &input.adjustments {
        let mut array_830 = object.key("Adjustments").start_array();
        for item_831 in var_829 {
            {
                let mut object_832 = array_830.value().start_object();
                crate::json_ser::serialize_structure_crate_model_adjustment(
                    &mut object_832,
                    item_831,
                );
                object_832.finish();
            }
        }
        array_830.finish();
    }
}

pub fn serialize_structure_crate_model_vulnerability_vendor(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VulnerabilityVendor,
) {
    if let Some(var_833) = &input.name {
        object.key("Name").string(var_833);
    }
    if let Some(var_834) = &input.url {
        object.key("Url").string(var_834);
    }
    if let Some(var_835) = &input.vendor_severity {
        object.key("VendorSeverity").string(var_835);
    }
    if let Some(var_836) = &input.vendor_created_at {
        object.key("VendorCreatedAt").string(var_836);
    }
    if let Some(var_837) = &input.vendor_updated_at {
        object.key("VendorUpdatedAt").string(var_837);
    }
}

pub fn serialize_structure_crate_model_network_connection_action(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NetworkConnectionAction,
) {
    if let Some(var_838) = &input.connection_direction {
        object.key("ConnectionDirection").string(var_838);
    }
    if let Some(var_839) = &input.remote_ip_details {
        let mut object_840 = object.key("RemoteIpDetails").start_object();
        crate::json_ser::serialize_structure_crate_model_action_remote_ip_details(
            &mut object_840,
            var_839,
        );
        object_840.finish();
    }
    if let Some(var_841) = &input.remote_port_details {
        let mut object_842 = object.key("RemotePortDetails").start_object();
        crate::json_ser::serialize_structure_crate_model_action_remote_port_details(
            &mut object_842,
            var_841,
        );
        object_842.finish();
    }
    if let Some(var_843) = &input.local_port_details {
        let mut object_844 = object.key("LocalPortDetails").start_object();
        crate::json_ser::serialize_structure_crate_model_action_local_port_details(
            &mut object_844,
            var_843,
        );
        object_844.finish();
    }
    if let Some(var_845) = &input.protocol {
        object.key("Protocol").string(var_845);
    }
    if input.blocked {
        object.key("Blocked").boolean(input.blocked);
    }
}

pub fn serialize_structure_crate_model_aws_api_call_action(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsApiCallAction,
) {
    if let Some(var_846) = &input.api {
        object.key("Api").string(var_846);
    }
    if let Some(var_847) = &input.service_name {
        object.key("ServiceName").string(var_847);
    }
    if let Some(var_848) = &input.caller_type {
        object.key("CallerType").string(var_848);
    }
    if let Some(var_849) = &input.remote_ip_details {
        let mut object_850 = object.key("RemoteIpDetails").start_object();
        crate::json_ser::serialize_structure_crate_model_action_remote_ip_details(
            &mut object_850,
            var_849,
        );
        object_850.finish();
    }
    if let Some(var_851) = &input.domain_details {
        let mut object_852 = object.key("DomainDetails").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_api_call_action_domain_details(
            &mut object_852,
            var_851,
        );
        object_852.finish();
    }
    if let Some(var_853) = &input.affected_resources {
        let mut object_854 = object.key("AffectedResources").start_object();
        for (key_855, value_856) in var_853 {
            {
                object_854.key(key_855).string(value_856);
            }
        }
        object_854.finish();
    }
    if let Some(var_857) = &input.first_seen {
        object.key("FirstSeen").string(var_857);
    }
    if let Some(var_858) = &input.last_seen {
        object.key("LastSeen").string(var_858);
    }
}

pub fn serialize_structure_crate_model_dns_request_action(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DnsRequestAction,
) {
    if let Some(var_859) = &input.domain {
        object.key("Domain").string(var_859);
    }
    if let Some(var_860) = &input.protocol {
        object.key("Protocol").string(var_860);
    }
    if input.blocked {
        object.key("Blocked").boolean(input.blocked);
    }
}

pub fn serialize_structure_crate_model_port_probe_action(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::PortProbeAction,
) {
    if let Some(var_861) = &input.port_probe_details {
        let mut array_862 = object.key("PortProbeDetails").start_array();
        for item_863 in var_861 {
            {
                let mut object_864 = array_862.value().start_object();
                crate::json_ser::serialize_structure_crate_model_port_probe_detail(
                    &mut object_864,
                    item_863,
                );
                object_864.finish();
            }
        }
        array_862.finish();
    }
    if input.blocked {
        object.key("Blocked").boolean(input.blocked);
    }
}

pub fn serialize_structure_crate_model_finding_provider_severity(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FindingProviderSeverity,
) {
    if let Some(var_865) = &input.label {
        object.key("Label").string(var_865.as_str());
    }
    if let Some(var_866) = &input.original {
        object.key("Original").string(var_866);
    }
}

pub fn serialize_structure_crate_model_date_range(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DateRange,
) {
    if input.value != 0 {
        object.key("Value").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.value).into()),
        );
    }
    if let Some(var_867) = &input.unit {
        object.key("Unit").string(var_867.as_str());
    }
}

pub fn serialize_structure_crate_model_network_path_component_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NetworkPathComponentDetails,
) {
    if let Some(var_868) = &input.address {
        let mut array_869 = object.key("Address").start_array();
        for item_870 in var_868 {
            {
                array_869.value().string(item_870);
            }
        }
        array_869.finish();
    }
    if let Some(var_871) = &input.port_ranges {
        let mut array_872 = object.key("PortRanges").start_array();
        for item_873 in var_871 {
            {
                let mut object_874 = array_872.value().start_object();
                crate::json_ser::serialize_structure_crate_model_port_range(
                    &mut object_874,
                    item_873,
                );
                object_874.finish();
            }
        }
        array_872.finish();
    }
}

pub fn serialize_structure_crate_model_classification_result(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ClassificationResult,
) {
    if let Some(var_875) = &input.mime_type {
        object.key("MimeType").string(var_875);
    }
    if input.size_classified != 0 {
        object.key("SizeClassified").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.size_classified).into()),
        );
    }
    if input.additional_occurrences {
        object
            .key("AdditionalOccurrences")
            .boolean(input.additional_occurrences);
    }
    if let Some(var_876) = &input.status {
        let mut object_877 = object.key("Status").start_object();
        crate::json_ser::serialize_structure_crate_model_classification_status(
            &mut object_877,
            var_876,
        );
        object_877.finish();
    }
    if let Some(var_878) = &input.sensitive_data {
        let mut array_879 = object.key("SensitiveData").start_array();
        for item_880 in var_878 {
            {
                let mut object_881 = array_879.value().start_object();
                crate::json_ser::serialize_structure_crate_model_sensitive_data_result(
                    &mut object_881,
                    item_880,
                );
                object_881.finish();
            }
        }
        array_879.finish();
    }
    if let Some(var_882) = &input.custom_data_identifiers {
        let mut object_883 = object.key("CustomDataIdentifiers").start_object();
        crate::json_ser::serialize_structure_crate_model_custom_data_identifiers_result(
            &mut object_883,
            var_882,
        );
        object_883.finish();
    }
}

pub fn serialize_structure_crate_model_aws_auto_scaling_auto_scaling_group_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsAutoScalingAutoScalingGroupDetails,
) {
    if let Some(var_884) = &input.launch_configuration_name {
        object.key("LaunchConfigurationName").string(var_884);
    }
    if let Some(var_885) = &input.load_balancer_names {
        let mut array_886 = object.key("LoadBalancerNames").start_array();
        for item_887 in var_885 {
            {
                array_886.value().string(item_887);
            }
        }
        array_886.finish();
    }
    if let Some(var_888) = &input.health_check_type {
        object.key("HealthCheckType").string(var_888);
    }
    if input.health_check_grace_period != 0 {
        object.key("HealthCheckGracePeriod").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.health_check_grace_period).into()),
        );
    }
    if let Some(var_889) = &input.created_time {
        object.key("CreatedTime").string(var_889);
    }
}

pub fn serialize_structure_crate_model_aws_code_build_project_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCodeBuildProjectDetails,
) {
    if let Some(var_890) = &input.encryption_key {
        object.key("EncryptionKey").string(var_890);
    }
    if let Some(var_891) = &input.artifacts {
        let mut array_892 = object.key("Artifacts").start_array();
        for item_893 in var_891 {
            {
                let mut object_894 = array_892.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_code_build_project_artifacts_details(&mut object_894, item_893);
                object_894.finish();
            }
        }
        array_892.finish();
    }
    if let Some(var_895) = &input.environment {
        let mut object_896 = object.key("Environment").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_code_build_project_environment(
            &mut object_896,
            var_895,
        );
        object_896.finish();
    }
    if let Some(var_897) = &input.name {
        object.key("Name").string(var_897);
    }
    if let Some(var_898) = &input.source {
        let mut object_899 = object.key("Source").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_code_build_project_source(
            &mut object_899,
            var_898,
        );
        object_899.finish();
    }
    if let Some(var_900) = &input.service_role {
        object.key("ServiceRole").string(var_900);
    }
    if let Some(var_901) = &input.logs_config {
        let mut object_902 = object.key("LogsConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_code_build_project_logs_config_details(
            &mut object_902,
            var_901,
        );
        object_902.finish();
    }
    if let Some(var_903) = &input.vpc_config {
        let mut object_904 = object.key("VpcConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_code_build_project_vpc_config(
            &mut object_904,
            var_903,
        );
        object_904.finish();
    }
}

pub fn serialize_structure_crate_model_aws_cloud_front_distribution_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCloudFrontDistributionDetails,
) {
    if let Some(var_905) = &input.cache_behaviors {
        let mut object_906 = object.key("CacheBehaviors").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_cache_behaviors(&mut object_906, var_905);
        object_906.finish();
    }
    if let Some(var_907) = &input.default_cache_behavior {
        let mut object_908 = object.key("DefaultCacheBehavior").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_default_cache_behavior(&mut object_908, var_907);
        object_908.finish();
    }
    if let Some(var_909) = &input.default_root_object {
        object.key("DefaultRootObject").string(var_909);
    }
    if let Some(var_910) = &input.domain_name {
        object.key("DomainName").string(var_910);
    }
    if let Some(var_911) = &input.e_tag {
        object.key("ETag").string(var_911);
    }
    if let Some(var_912) = &input.last_modified_time {
        object.key("LastModifiedTime").string(var_912);
    }
    if let Some(var_913) = &input.logging {
        let mut object_914 = object.key("Logging").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_logging(
            &mut object_914,
            var_913,
        );
        object_914.finish();
    }
    if let Some(var_915) = &input.origins {
        let mut object_916 = object.key("Origins").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_origins(
            &mut object_916,
            var_915,
        );
        object_916.finish();
    }
    if let Some(var_917) = &input.origin_groups {
        let mut object_918 = object.key("OriginGroups").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_origin_groups(
            &mut object_918,
            var_917,
        );
        object_918.finish();
    }
    if let Some(var_919) = &input.viewer_certificate {
        let mut object_920 = object.key("ViewerCertificate").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_viewer_certificate(&mut object_920, var_919);
        object_920.finish();
    }
    if let Some(var_921) = &input.status {
        object.key("Status").string(var_921);
    }
    if let Some(var_922) = &input.web_acl_id {
        object.key("WebAclId").string(var_922);
    }
}

pub fn serialize_structure_crate_model_aws_ec2_instance_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2InstanceDetails,
) {
    if let Some(var_923) = &input.r#type {
        object.key("Type").string(var_923);
    }
    if let Some(var_924) = &input.image_id {
        object.key("ImageId").string(var_924);
    }
    if let Some(var_925) = &input.ip_v4_addresses {
        let mut array_926 = object.key("IpV4Addresses").start_array();
        for item_927 in var_925 {
            {
                array_926.value().string(item_927);
            }
        }
        array_926.finish();
    }
    if let Some(var_928) = &input.ip_v6_addresses {
        let mut array_929 = object.key("IpV6Addresses").start_array();
        for item_930 in var_928 {
            {
                array_929.value().string(item_930);
            }
        }
        array_929.finish();
    }
    if let Some(var_931) = &input.key_name {
        object.key("KeyName").string(var_931);
    }
    if let Some(var_932) = &input.iam_instance_profile_arn {
        object.key("IamInstanceProfileArn").string(var_932);
    }
    if let Some(var_933) = &input.vpc_id {
        object.key("VpcId").string(var_933);
    }
    if let Some(var_934) = &input.subnet_id {
        object.key("SubnetId").string(var_934);
    }
    if let Some(var_935) = &input.launched_at {
        object.key("LaunchedAt").string(var_935);
    }
    if let Some(var_936) = &input.network_interfaces {
        let mut array_937 = object.key("NetworkInterfaces").start_array();
        for item_938 in var_936 {
            {
                let mut object_939 = array_937.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ec2_instance_network_interfaces_details(&mut object_939, item_938);
                object_939.finish();
            }
        }
        array_937.finish();
    }
}

pub fn serialize_structure_crate_model_aws_ec2_network_interface_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2NetworkInterfaceDetails,
) {
    if let Some(var_940) = &input.attachment {
        let mut object_941 = object.key("Attachment").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ec2_network_interface_attachment(
            &mut object_941,
            var_940,
        );
        object_941.finish();
    }
    if let Some(var_942) = &input.network_interface_id {
        object.key("NetworkInterfaceId").string(var_942);
    }
    if let Some(var_943) = &input.security_groups {
        let mut array_944 = object.key("SecurityGroups").start_array();
        for item_945 in var_943 {
            {
                let mut object_946 = array_944.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ec2_network_interface_security_group(&mut object_946, item_945);
                object_946.finish();
            }
        }
        array_944.finish();
    }
    if input.source_dest_check {
        object
            .key("SourceDestCheck")
            .boolean(input.source_dest_check);
    }
    if let Some(var_947) = &input.ip_v6_addresses {
        let mut array_948 = object.key("IpV6Addresses").start_array();
        for item_949 in var_947 {
            {
                let mut object_950 = array_948.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ec2_network_interface_ip_v6_address_detail(&mut object_950, item_949);
                object_950.finish();
            }
        }
        array_948.finish();
    }
    if let Some(var_951) = &input.private_ip_addresses {
        let mut array_952 = object.key("PrivateIpAddresses").start_array();
        for item_953 in var_951 {
            {
                let mut object_954 = array_952.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ec2_network_interface_private_ip_address_detail(&mut object_954, item_953);
                object_954.finish();
            }
        }
        array_952.finish();
    }
    if let Some(var_955) = &input.public_dns_name {
        object.key("PublicDnsName").string(var_955);
    }
    if let Some(var_956) = &input.public_ip {
        object.key("PublicIp").string(var_956);
    }
}

pub fn serialize_structure_crate_model_aws_ec2_security_group_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2SecurityGroupDetails,
) {
    if let Some(var_957) = &input.group_name {
        object.key("GroupName").string(var_957);
    }
    if let Some(var_958) = &input.group_id {
        object.key("GroupId").string(var_958);
    }
    if let Some(var_959) = &input.owner_id {
        object.key("OwnerId").string(var_959);
    }
    if let Some(var_960) = &input.vpc_id {
        object.key("VpcId").string(var_960);
    }
    if let Some(var_961) = &input.ip_permissions {
        let mut array_962 = object.key("IpPermissions").start_array();
        for item_963 in var_961 {
            {
                let mut object_964 = array_962.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ec2_security_group_ip_permission(&mut object_964, item_963);
                object_964.finish();
            }
        }
        array_962.finish();
    }
    if let Some(var_965) = &input.ip_permissions_egress {
        let mut array_966 = object.key("IpPermissionsEgress").start_array();
        for item_967 in var_965 {
            {
                let mut object_968 = array_966.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ec2_security_group_ip_permission(&mut object_968, item_967);
                object_968.finish();
            }
        }
        array_966.finish();
    }
}

pub fn serialize_structure_crate_model_aws_ec2_volume_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2VolumeDetails,
) {
    if let Some(var_969) = &input.create_time {
        object.key("CreateTime").string(var_969);
    }
    if input.encrypted {
        object.key("Encrypted").boolean(input.encrypted);
    }
    if input.size != 0 {
        object.key("Size").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.size).into()),
        );
    }
    if let Some(var_970) = &input.snapshot_id {
        object.key("SnapshotId").string(var_970);
    }
    if let Some(var_971) = &input.status {
        object.key("Status").string(var_971);
    }
    if let Some(var_972) = &input.kms_key_id {
        object.key("KmsKeyId").string(var_972);
    }
    if let Some(var_973) = &input.attachments {
        let mut array_974 = object.key("Attachments").start_array();
        for item_975 in var_973 {
            {
                let mut object_976 = array_974.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ec2_volume_attachment(
                    &mut object_976,
                    item_975,
                );
                object_976.finish();
            }
        }
        array_974.finish();
    }
}

pub fn serialize_structure_crate_model_aws_ec2_vpc_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2VpcDetails,
) {
    if let Some(var_977) = &input.cidr_block_association_set {
        let mut array_978 = object.key("CidrBlockAssociationSet").start_array();
        for item_979 in var_977 {
            {
                let mut object_980 = array_978.value().start_object();
                crate::json_ser::serialize_structure_crate_model_cidr_block_association(
                    &mut object_980,
                    item_979,
                );
                object_980.finish();
            }
        }
        array_978.finish();
    }
    if let Some(var_981) = &input.ipv6_cidr_block_association_set {
        let mut array_982 = object.key("Ipv6CidrBlockAssociationSet").start_array();
        for item_983 in var_981 {
            {
                let mut object_984 = array_982.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ipv6_cidr_block_association(
                    &mut object_984,
                    item_983,
                );
                object_984.finish();
            }
        }
        array_982.finish();
    }
    if let Some(var_985) = &input.dhcp_options_id {
        object.key("DhcpOptionsId").string(var_985);
    }
    if let Some(var_986) = &input.state {
        object.key("State").string(var_986);
    }
}

pub fn serialize_structure_crate_model_aws_ec2_eip_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2EipDetails,
) {
    if let Some(var_987) = &input.instance_id {
        object.key("InstanceId").string(var_987);
    }
    if let Some(var_988) = &input.public_ip {
        object.key("PublicIp").string(var_988);
    }
    if let Some(var_989) = &input.allocation_id {
        object.key("AllocationId").string(var_989);
    }
    if let Some(var_990) = &input.association_id {
        object.key("AssociationId").string(var_990);
    }
    if let Some(var_991) = &input.domain {
        object.key("Domain").string(var_991);
    }
    if let Some(var_992) = &input.public_ipv4_pool {
        object.key("PublicIpv4Pool").string(var_992);
    }
    if let Some(var_993) = &input.network_border_group {
        object.key("NetworkBorderGroup").string(var_993);
    }
    if let Some(var_994) = &input.network_interface_id {
        object.key("NetworkInterfaceId").string(var_994);
    }
    if let Some(var_995) = &input.network_interface_owner_id {
        object.key("NetworkInterfaceOwnerId").string(var_995);
    }
    if let Some(var_996) = &input.private_ip_address {
        object.key("PrivateIpAddress").string(var_996);
    }
}

pub fn serialize_structure_crate_model_aws_ec2_subnet_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2SubnetDetails,
) {
    if input.assign_ipv6_address_on_creation {
        object
            .key("AssignIpv6AddressOnCreation")
            .boolean(input.assign_ipv6_address_on_creation);
    }
    if let Some(var_997) = &input.availability_zone {
        object.key("AvailabilityZone").string(var_997);
    }
    if let Some(var_998) = &input.availability_zone_id {
        object.key("AvailabilityZoneId").string(var_998);
    }
    if input.available_ip_address_count != 0 {
        object.key("AvailableIpAddressCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.available_ip_address_count).into()),
        );
    }
    if let Some(var_999) = &input.cidr_block {
        object.key("CidrBlock").string(var_999);
    }
    if input.default_for_az {
        object.key("DefaultForAz").boolean(input.default_for_az);
    }
    if input.map_public_ip_on_launch {
        object
            .key("MapPublicIpOnLaunch")
            .boolean(input.map_public_ip_on_launch);
    }
    if let Some(var_1000) = &input.owner_id {
        object.key("OwnerId").string(var_1000);
    }
    if let Some(var_1001) = &input.state {
        object.key("State").string(var_1001);
    }
    if let Some(var_1002) = &input.subnet_arn {
        object.key("SubnetArn").string(var_1002);
    }
    if let Some(var_1003) = &input.subnet_id {
        object.key("SubnetId").string(var_1003);
    }
    if let Some(var_1004) = &input.vpc_id {
        object.key("VpcId").string(var_1004);
    }
    if let Some(var_1005) = &input.ipv6_cidr_block_association_set {
        let mut array_1006 = object.key("Ipv6CidrBlockAssociationSet").start_array();
        for item_1007 in var_1005 {
            {
                let mut object_1008 = array_1006.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ipv6_cidr_block_association(
                    &mut object_1008,
                    item_1007,
                );
                object_1008.finish();
            }
        }
        array_1006.finish();
    }
}

pub fn serialize_structure_crate_model_aws_ec2_network_acl_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2NetworkAclDetails,
) {
    if input.is_default {
        object.key("IsDefault").boolean(input.is_default);
    }
    if let Some(var_1009) = &input.network_acl_id {
        object.key("NetworkAclId").string(var_1009);
    }
    if let Some(var_1010) = &input.owner_id {
        object.key("OwnerId").string(var_1010);
    }
    if let Some(var_1011) = &input.vpc_id {
        object.key("VpcId").string(var_1011);
    }
    if let Some(var_1012) = &input.associations {
        let mut array_1013 = object.key("Associations").start_array();
        for item_1014 in var_1012 {
            {
                let mut object_1015 = array_1013.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ec2_network_acl_association(
                    &mut object_1015,
                    item_1014,
                );
                object_1015.finish();
            }
        }
        array_1013.finish();
    }
    if let Some(var_1016) = &input.entries {
        let mut array_1017 = object.key("Entries").start_array();
        for item_1018 in var_1016 {
            {
                let mut object_1019 = array_1017.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ec2_network_acl_entry(
                    &mut object_1019,
                    item_1018,
                );
                object_1019.finish();
            }
        }
        array_1017.finish();
    }
}

pub fn serialize_structure_crate_model_aws_elbv2_load_balancer_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElbv2LoadBalancerDetails,
) {
    if let Some(var_1020) = &input.availability_zones {
        let mut array_1021 = object.key("AvailabilityZones").start_array();
        for item_1022 in var_1020 {
            {
                let mut object_1023 = array_1021.value().start_object();
                crate::json_ser::serialize_structure_crate_model_availability_zone(
                    &mut object_1023,
                    item_1022,
                );
                object_1023.finish();
            }
        }
        array_1021.finish();
    }
    if let Some(var_1024) = &input.canonical_hosted_zone_id {
        object.key("CanonicalHostedZoneId").string(var_1024);
    }
    if let Some(var_1025) = &input.created_time {
        object.key("CreatedTime").string(var_1025);
    }
    if let Some(var_1026) = &input.dns_name {
        object.key("DNSName").string(var_1026);
    }
    if let Some(var_1027) = &input.ip_address_type {
        object.key("IpAddressType").string(var_1027);
    }
    if let Some(var_1028) = &input.scheme {
        object.key("Scheme").string(var_1028);
    }
    if let Some(var_1029) = &input.security_groups {
        let mut array_1030 = object.key("SecurityGroups").start_array();
        for item_1031 in var_1029 {
            {
                array_1030.value().string(item_1031);
            }
        }
        array_1030.finish();
    }
    if let Some(var_1032) = &input.state {
        let mut object_1033 = object.key("State").start_object();
        crate::json_ser::serialize_structure_crate_model_load_balancer_state(
            &mut object_1033,
            var_1032,
        );
        object_1033.finish();
    }
    if let Some(var_1034) = &input.r#type {
        object.key("Type").string(var_1034);
    }
    if let Some(var_1035) = &input.vpc_id {
        object.key("VpcId").string(var_1035);
    }
    if let Some(var_1036) = &input.load_balancer_attributes {
        let mut array_1037 = object.key("LoadBalancerAttributes").start_array();
        for item_1038 in var_1036 {
            {
                let mut object_1039 = array_1037.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_elbv2_load_balancer_attribute(
                    &mut object_1039,
                    item_1038,
                );
                object_1039.finish();
            }
        }
        array_1037.finish();
    }
}

pub fn serialize_structure_crate_model_aws_elastic_beanstalk_environment_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElasticBeanstalkEnvironmentDetails,
) {
    if let Some(var_1040) = &input.application_name {
        object.key("ApplicationName").string(var_1040);
    }
    if let Some(var_1041) = &input.cname {
        object.key("Cname").string(var_1041);
    }
    if let Some(var_1042) = &input.date_created {
        object.key("DateCreated").string(var_1042);
    }
    if let Some(var_1043) = &input.date_updated {
        object.key("DateUpdated").string(var_1043);
    }
    if let Some(var_1044) = &input.description {
        object.key("Description").string(var_1044);
    }
    if let Some(var_1045) = &input.endpoint_url {
        object.key("EndpointUrl").string(var_1045);
    }
    if let Some(var_1046) = &input.environment_arn {
        object.key("EnvironmentArn").string(var_1046);
    }
    if let Some(var_1047) = &input.environment_id {
        object.key("EnvironmentId").string(var_1047);
    }
    if let Some(var_1048) = &input.environment_links {
        let mut array_1049 = object.key("EnvironmentLinks").start_array();
        for item_1050 in var_1048 {
            {
                let mut object_1051 = array_1049.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_elastic_beanstalk_environment_environment_link(&mut object_1051, item_1050);
                object_1051.finish();
            }
        }
        array_1049.finish();
    }
    if let Some(var_1052) = &input.environment_name {
        object.key("EnvironmentName").string(var_1052);
    }
    if let Some(var_1053) = &input.option_settings {
        let mut array_1054 = object.key("OptionSettings").start_array();
        for item_1055 in var_1053 {
            {
                let mut object_1056 = array_1054.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_elastic_beanstalk_environment_option_setting(&mut object_1056, item_1055);
                object_1056.finish();
            }
        }
        array_1054.finish();
    }
    if let Some(var_1057) = &input.platform_arn {
        object.key("PlatformArn").string(var_1057);
    }
    if let Some(var_1058) = &input.solution_stack_name {
        object.key("SolutionStackName").string(var_1058);
    }
    if let Some(var_1059) = &input.status {
        object.key("Status").string(var_1059);
    }
    if let Some(var_1060) = &input.tier {
        let mut object_1061 = object.key("Tier").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elastic_beanstalk_environment_tier(
            &mut object_1061,
            var_1060,
        );
        object_1061.finish();
    }
    if let Some(var_1062) = &input.version_label {
        object.key("VersionLabel").string(var_1062);
    }
}

pub fn serialize_structure_crate_model_aws_elasticsearch_domain_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElasticsearchDomainDetails,
) {
    if let Some(var_1063) = &input.access_policies {
        object.key("AccessPolicies").string(var_1063);
    }
    if let Some(var_1064) = &input.domain_endpoint_options {
        let mut object_1065 = object.key("DomainEndpointOptions").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_domain_endpoint_options(&mut object_1065, var_1064);
        object_1065.finish();
    }
    if let Some(var_1066) = &input.domain_id {
        object.key("DomainId").string(var_1066);
    }
    if let Some(var_1067) = &input.domain_name {
        object.key("DomainName").string(var_1067);
    }
    if let Some(var_1068) = &input.endpoint {
        object.key("Endpoint").string(var_1068);
    }
    if let Some(var_1069) = &input.endpoints {
        let mut object_1070 = object.key("Endpoints").start_object();
        for (key_1071, value_1072) in var_1069 {
            {
                object_1070.key(key_1071).string(value_1072);
            }
        }
        object_1070.finish();
    }
    if let Some(var_1073) = &input.elasticsearch_version {
        object.key("ElasticsearchVersion").string(var_1073);
    }
    if let Some(var_1074) = &input.elasticsearch_cluster_config {
        let mut object_1075 = object.key("ElasticsearchClusterConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_elasticsearch_cluster_config_details(&mut object_1075, var_1074);
        object_1075.finish();
    }
    if let Some(var_1076) = &input.encryption_at_rest_options {
        let mut object_1077 = object.key("EncryptionAtRestOptions").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_encryption_at_rest_options(&mut object_1077, var_1076);
        object_1077.finish();
    }
    if let Some(var_1078) = &input.log_publishing_options {
        let mut object_1079 = object.key("LogPublishingOptions").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_log_publishing_options(&mut object_1079, var_1078);
        object_1079.finish();
    }
    if let Some(var_1080) = &input.node_to_node_encryption_options {
        let mut object_1081 = object.key("NodeToNodeEncryptionOptions").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_node_to_node_encryption_options(&mut object_1081, var_1080);
        object_1081.finish();
    }
    if let Some(var_1082) = &input.service_software_options {
        let mut object_1083 = object.key("ServiceSoftwareOptions").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_service_software_options(&mut object_1083, var_1082);
        object_1083.finish();
    }
    if let Some(var_1084) = &input.vpc_options {
        let mut object_1085 = object.key("VPCOptions").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_vpc_options(
            &mut object_1085,
            var_1084,
        );
        object_1085.finish();
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketDetails,
) {
    if let Some(var_1086) = &input.owner_id {
        object.key("OwnerId").string(var_1086);
    }
    if let Some(var_1087) = &input.owner_name {
        object.key("OwnerName").string(var_1087);
    }
    if let Some(var_1088) = &input.owner_account_id {
        object.key("OwnerAccountId").string(var_1088);
    }
    if let Some(var_1089) = &input.created_at {
        object.key("CreatedAt").string(var_1089);
    }
    if let Some(var_1090) = &input.server_side_encryption_configuration {
        let mut object_1091 = object
            .key("ServerSideEncryptionConfiguration")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_server_side_encryption_configuration(&mut object_1091, var_1090);
        object_1091.finish();
    }
    if let Some(var_1092) = &input.bucket_lifecycle_configuration {
        let mut object_1093 = object.key("BucketLifecycleConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_details(&mut object_1093, var_1092);
        object_1093.finish();
    }
    if let Some(var_1094) = &input.public_access_block_configuration {
        let mut object_1095 = object.key("PublicAccessBlockConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_account_public_access_block_details(
            &mut object_1095,
            var_1094,
        );
        object_1095.finish();
    }
    if let Some(var_1096) = &input.access_control_list {
        object.key("AccessControlList").string(var_1096);
    }
    if let Some(var_1097) = &input.bucket_logging_configuration {
        let mut object_1098 = object.key("BucketLoggingConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_logging_configuration(
            &mut object_1098,
            var_1097,
        );
        object_1098.finish();
    }
    if let Some(var_1099) = &input.bucket_website_configuration {
        let mut object_1100 = object.key("BucketWebsiteConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_website_configuration(
            &mut object_1100,
            var_1099,
        );
        object_1100.finish();
    }
    if let Some(var_1101) = &input.bucket_notification_configuration {
        let mut object_1102 = object.key("BucketNotificationConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_notification_configuration(
            &mut object_1102,
            var_1101,
        );
        object_1102.finish();
    }
}

pub fn serialize_structure_crate_model_aws_s3_account_public_access_block_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3AccountPublicAccessBlockDetails,
) {
    if input.block_public_acls {
        object
            .key("BlockPublicAcls")
            .boolean(input.block_public_acls);
    }
    if input.block_public_policy {
        object
            .key("BlockPublicPolicy")
            .boolean(input.block_public_policy);
    }
    if input.ignore_public_acls {
        object
            .key("IgnorePublicAcls")
            .boolean(input.ignore_public_acls);
    }
    if input.restrict_public_buckets {
        object
            .key("RestrictPublicBuckets")
            .boolean(input.restrict_public_buckets);
    }
}

pub fn serialize_structure_crate_model_aws_s3_object_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3ObjectDetails,
) {
    if let Some(var_1103) = &input.last_modified {
        object.key("LastModified").string(var_1103);
    }
    if let Some(var_1104) = &input.e_tag {
        object.key("ETag").string(var_1104);
    }
    if let Some(var_1105) = &input.version_id {
        object.key("VersionId").string(var_1105);
    }
    if let Some(var_1106) = &input.content_type {
        object.key("ContentType").string(var_1106);
    }
    if let Some(var_1107) = &input.server_side_encryption {
        object.key("ServerSideEncryption").string(var_1107);
    }
    if let Some(var_1108) = &input.ssekms_key_id {
        object.key("SSEKMSKeyId").string(var_1108);
    }
}

pub fn serialize_structure_crate_model_aws_secrets_manager_secret_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsSecretsManagerSecretDetails,
) {
    if let Some(var_1109) = &input.rotation_rules {
        let mut object_1110 = object.key("RotationRules").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_secrets_manager_secret_rotation_rules(
            &mut object_1110,
            var_1109,
        );
        object_1110.finish();
    }
    if input.rotation_occurred_within_frequency {
        object
            .key("RotationOccurredWithinFrequency")
            .boolean(input.rotation_occurred_within_frequency);
    }
    if let Some(var_1111) = &input.kms_key_id {
        object.key("KmsKeyId").string(var_1111);
    }
    if input.rotation_enabled {
        object
            .key("RotationEnabled")
            .boolean(input.rotation_enabled);
    }
    if let Some(var_1112) = &input.rotation_lambda_arn {
        object.key("RotationLambdaArn").string(var_1112);
    }
    if input.deleted {
        object.key("Deleted").boolean(input.deleted);
    }
    if let Some(var_1113) = &input.name {
        object.key("Name").string(var_1113);
    }
    if let Some(var_1114) = &input.description {
        object.key("Description").string(var_1114);
    }
}

pub fn serialize_structure_crate_model_aws_iam_access_key_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsIamAccessKeyDetails,
) {
    if let Some(var_1115) = &input.user_name {
        object.key("UserName").string(var_1115);
    }
    if let Some(var_1116) = &input.status {
        object.key("Status").string(var_1116.as_str());
    }
    if let Some(var_1117) = &input.created_at {
        object.key("CreatedAt").string(var_1117);
    }
    if let Some(var_1118) = &input.principal_id {
        object.key("PrincipalId").string(var_1118);
    }
    if let Some(var_1119) = &input.principal_type {
        object.key("PrincipalType").string(var_1119);
    }
    if let Some(var_1120) = &input.principal_name {
        object.key("PrincipalName").string(var_1120);
    }
    if let Some(var_1121) = &input.account_id {
        object.key("AccountId").string(var_1121);
    }
    if let Some(var_1122) = &input.access_key_id {
        object.key("AccessKeyId").string(var_1122);
    }
    if let Some(var_1123) = &input.session_context {
        let mut object_1124 = object.key("SessionContext").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_iam_access_key_session_context(
            &mut object_1124,
            var_1123,
        );
        object_1124.finish();
    }
}

pub fn serialize_structure_crate_model_aws_iam_user_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsIamUserDetails,
) {
    if let Some(var_1125) = &input.attached_managed_policies {
        let mut array_1126 = object.key("AttachedManagedPolicies").start_array();
        for item_1127 in var_1125 {
            {
                let mut object_1128 = array_1126.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_iam_attached_managed_policy(
                    &mut object_1128,
                    item_1127,
                );
                object_1128.finish();
            }
        }
        array_1126.finish();
    }
    if let Some(var_1129) = &input.create_date {
        object.key("CreateDate").string(var_1129);
    }
    if let Some(var_1130) = &input.group_list {
        let mut array_1131 = object.key("GroupList").start_array();
        for item_1132 in var_1130 {
            {
                array_1131.value().string(item_1132);
            }
        }
        array_1131.finish();
    }
    if let Some(var_1133) = &input.path {
        object.key("Path").string(var_1133);
    }
    if let Some(var_1134) = &input.permissions_boundary {
        let mut object_1135 = object.key("PermissionsBoundary").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_iam_permissions_boundary(
            &mut object_1135,
            var_1134,
        );
        object_1135.finish();
    }
    if let Some(var_1136) = &input.user_id {
        object.key("UserId").string(var_1136);
    }
    if let Some(var_1137) = &input.user_name {
        object.key("UserName").string(var_1137);
    }
    if let Some(var_1138) = &input.user_policy_list {
        let mut array_1139 = object.key("UserPolicyList").start_array();
        for item_1140 in var_1138 {
            {
                let mut object_1141 = array_1139.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_iam_user_policy(
                    &mut object_1141,
                    item_1140,
                );
                object_1141.finish();
            }
        }
        array_1139.finish();
    }
}

pub fn serialize_structure_crate_model_aws_iam_policy_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsIamPolicyDetails,
) {
    if input.attachment_count != 0 {
        object.key("AttachmentCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.attachment_count).into()),
        );
    }
    if let Some(var_1142) = &input.create_date {
        object.key("CreateDate").string(var_1142);
    }
    if let Some(var_1143) = &input.default_version_id {
        object.key("DefaultVersionId").string(var_1143);
    }
    if let Some(var_1144) = &input.description {
        object.key("Description").string(var_1144);
    }
    if input.is_attachable {
        object.key("IsAttachable").boolean(input.is_attachable);
    }
    if let Some(var_1145) = &input.path {
        object.key("Path").string(var_1145);
    }
    if input.permissions_boundary_usage_count != 0 {
        object.key("PermissionsBoundaryUsageCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.permissions_boundary_usage_count).into()),
        );
    }
    if let Some(var_1146) = &input.policy_id {
        object.key("PolicyId").string(var_1146);
    }
    if let Some(var_1147) = &input.policy_name {
        object.key("PolicyName").string(var_1147);
    }
    if let Some(var_1148) = &input.policy_version_list {
        let mut array_1149 = object.key("PolicyVersionList").start_array();
        for item_1150 in var_1148 {
            {
                let mut object_1151 = array_1149.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_iam_policy_version(
                    &mut object_1151,
                    item_1150,
                );
                object_1151.finish();
            }
        }
        array_1149.finish();
    }
    if let Some(var_1152) = &input.update_date {
        object.key("UpdateDate").string(var_1152);
    }
}

pub fn serialize_structure_crate_model_aws_api_gateway_v2_stage_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsApiGatewayV2StageDetails,
) {
    if let Some(var_1153) = &input.client_certificate_id {
        object.key("ClientCertificateId").string(var_1153);
    }
    if let Some(var_1154) = &input.created_date {
        object.key("CreatedDate").string(var_1154);
    }
    if let Some(var_1155) = &input.description {
        object.key("Description").string(var_1155);
    }
    if let Some(var_1156) = &input.default_route_settings {
        let mut object_1157 = object.key("DefaultRouteSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_api_gateway_v2_route_settings(
            &mut object_1157,
            var_1156,
        );
        object_1157.finish();
    }
    if let Some(var_1158) = &input.deployment_id {
        object.key("DeploymentId").string(var_1158);
    }
    if let Some(var_1159) = &input.last_updated_date {
        object.key("LastUpdatedDate").string(var_1159);
    }
    if let Some(var_1160) = &input.route_settings {
        let mut object_1161 = object.key("RouteSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_api_gateway_v2_route_settings(
            &mut object_1161,
            var_1160,
        );
        object_1161.finish();
    }
    if let Some(var_1162) = &input.stage_name {
        object.key("StageName").string(var_1162);
    }
    if let Some(var_1163) = &input.stage_variables {
        let mut object_1164 = object.key("StageVariables").start_object();
        for (key_1165, value_1166) in var_1163 {
            {
                object_1164.key(key_1165).string(value_1166);
            }
        }
        object_1164.finish();
    }
    if let Some(var_1167) = &input.access_log_settings {
        let mut object_1168 = object.key("AccessLogSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_api_gateway_access_log_settings(
            &mut object_1168,
            var_1167,
        );
        object_1168.finish();
    }
    if input.auto_deploy {
        object.key("AutoDeploy").boolean(input.auto_deploy);
    }
    if let Some(var_1169) = &input.last_deployment_status_message {
        object.key("LastDeploymentStatusMessage").string(var_1169);
    }
    if input.api_gateway_managed {
        object
            .key("ApiGatewayManaged")
            .boolean(input.api_gateway_managed);
    }
}

pub fn serialize_structure_crate_model_aws_api_gateway_v2_api_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsApiGatewayV2ApiDetails,
) {
    if let Some(var_1170) = &input.api_endpoint {
        object.key("ApiEndpoint").string(var_1170);
    }
    if let Some(var_1171) = &input.api_id {
        object.key("ApiId").string(var_1171);
    }
    if let Some(var_1172) = &input.api_key_selection_expression {
        object.key("ApiKeySelectionExpression").string(var_1172);
    }
    if let Some(var_1173) = &input.created_date {
        object.key("CreatedDate").string(var_1173);
    }
    if let Some(var_1174) = &input.description {
        object.key("Description").string(var_1174);
    }
    if let Some(var_1175) = &input.version {
        object.key("Version").string(var_1175);
    }
    if let Some(var_1176) = &input.name {
        object.key("Name").string(var_1176);
    }
    if let Some(var_1177) = &input.protocol_type {
        object.key("ProtocolType").string(var_1177);
    }
    if let Some(var_1178) = &input.route_selection_expression {
        object.key("RouteSelectionExpression").string(var_1178);
    }
    if let Some(var_1179) = &input.cors_configuration {
        let mut object_1180 = object.key("CorsConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_cors_configuration(
            &mut object_1180,
            var_1179,
        );
        object_1180.finish();
    }
}

pub fn serialize_structure_crate_model_aws_dynamo_db_table_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsDynamoDbTableDetails,
) {
    if let Some(var_1181) = &input.attribute_definitions {
        let mut array_1182 = object.key("AttributeDefinitions").start_array();
        for item_1183 in var_1181 {
            {
                let mut object_1184 = array_1182.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_attribute_definition(&mut object_1184, item_1183);
                object_1184.finish();
            }
        }
        array_1182.finish();
    }
    if let Some(var_1185) = &input.billing_mode_summary {
        let mut object_1186 = object.key("BillingModeSummary").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_billing_mode_summary(
            &mut object_1186,
            var_1185,
        );
        object_1186.finish();
    }
    if let Some(var_1187) = &input.creation_date_time {
        object.key("CreationDateTime").string(var_1187);
    }
    if let Some(var_1188) = &input.global_secondary_indexes {
        let mut array_1189 = object.key("GlobalSecondaryIndexes").start_array();
        for item_1190 in var_1188 {
            {
                let mut object_1191 = array_1189.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_global_secondary_index(&mut object_1191, item_1190);
                object_1191.finish();
            }
        }
        array_1189.finish();
    }
    if let Some(var_1192) = &input.global_table_version {
        object.key("GlobalTableVersion").string(var_1192);
    }
    if input.item_count != 0 {
        object.key("ItemCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.item_count).into()),
        );
    }
    if let Some(var_1193) = &input.key_schema {
        let mut array_1194 = object.key("KeySchema").start_array();
        for item_1195 in var_1193 {
            {
                let mut object_1196 = array_1194.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_key_schema(
                    &mut object_1196,
                    item_1195,
                );
                object_1196.finish();
            }
        }
        array_1194.finish();
    }
    if let Some(var_1197) = &input.latest_stream_arn {
        object.key("LatestStreamArn").string(var_1197);
    }
    if let Some(var_1198) = &input.latest_stream_label {
        object.key("LatestStreamLabel").string(var_1198);
    }
    if let Some(var_1199) = &input.local_secondary_indexes {
        let mut array_1200 = object.key("LocalSecondaryIndexes").start_array();
        for item_1201 in var_1199 {
            {
                let mut object_1202 = array_1200.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_local_secondary_index(&mut object_1202, item_1201);
                object_1202.finish();
            }
        }
        array_1200.finish();
    }
    if let Some(var_1203) = &input.provisioned_throughput {
        let mut object_1204 = object.key("ProvisionedThroughput").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_provisioned_throughput(
            &mut object_1204,
            var_1203,
        );
        object_1204.finish();
    }
    if let Some(var_1205) = &input.replicas {
        let mut array_1206 = object.key("Replicas").start_array();
        for item_1207 in var_1205 {
            {
                let mut object_1208 = array_1206.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_replica(
                    &mut object_1208,
                    item_1207,
                );
                object_1208.finish();
            }
        }
        array_1206.finish();
    }
    if let Some(var_1209) = &input.restore_summary {
        let mut object_1210 = object.key("RestoreSummary").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_restore_summary(
            &mut object_1210,
            var_1209,
        );
        object_1210.finish();
    }
    if let Some(var_1211) = &input.sse_description {
        let mut object_1212 = object.key("SseDescription").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_sse_description(
            &mut object_1212,
            var_1211,
        );
        object_1212.finish();
    }
    if let Some(var_1213) = &input.stream_specification {
        let mut object_1214 = object.key("StreamSpecification").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_stream_specification(
            &mut object_1214,
            var_1213,
        );
        object_1214.finish();
    }
    if let Some(var_1215) = &input.table_id {
        object.key("TableId").string(var_1215);
    }
    if let Some(var_1216) = &input.table_name {
        object.key("TableName").string(var_1216);
    }
    if input.table_size_bytes != 0 {
        object.key("TableSizeBytes").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.table_size_bytes).into()),
        );
    }
    if let Some(var_1217) = &input.table_status {
        object.key("TableStatus").string(var_1217);
    }
}

pub fn serialize_structure_crate_model_aws_api_gateway_stage_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsApiGatewayStageDetails,
) {
    if let Some(var_1218) = &input.deployment_id {
        object.key("DeploymentId").string(var_1218);
    }
    if let Some(var_1219) = &input.client_certificate_id {
        object.key("ClientCertificateId").string(var_1219);
    }
    if let Some(var_1220) = &input.stage_name {
        object.key("StageName").string(var_1220);
    }
    if let Some(var_1221) = &input.description {
        object.key("Description").string(var_1221);
    }
    if input.cache_cluster_enabled {
        object
            .key("CacheClusterEnabled")
            .boolean(input.cache_cluster_enabled);
    }
    if let Some(var_1222) = &input.cache_cluster_size {
        object.key("CacheClusterSize").string(var_1222);
    }
    if let Some(var_1223) = &input.cache_cluster_status {
        object.key("CacheClusterStatus").string(var_1223);
    }
    if let Some(var_1224) = &input.method_settings {
        let mut array_1225 = object.key("MethodSettings").start_array();
        for item_1226 in var_1224 {
            {
                let mut object_1227 = array_1225.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_api_gateway_method_settings(
                    &mut object_1227,
                    item_1226,
                );
                object_1227.finish();
            }
        }
        array_1225.finish();
    }
    if let Some(var_1228) = &input.variables {
        let mut object_1229 = object.key("Variables").start_object();
        for (key_1230, value_1231) in var_1228 {
            {
                object_1229.key(key_1230).string(value_1231);
            }
        }
        object_1229.finish();
    }
    if let Some(var_1232) = &input.documentation_version {
        object.key("DocumentationVersion").string(var_1232);
    }
    if let Some(var_1233) = &input.access_log_settings {
        let mut object_1234 = object.key("AccessLogSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_api_gateway_access_log_settings(
            &mut object_1234,
            var_1233,
        );
        object_1234.finish();
    }
    if let Some(var_1235) = &input.canary_settings {
        let mut object_1236 = object.key("CanarySettings").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_api_gateway_canary_settings(
            &mut object_1236,
            var_1235,
        );
        object_1236.finish();
    }
    if input.tracing_enabled {
        object.key("TracingEnabled").boolean(input.tracing_enabled);
    }
    if let Some(var_1237) = &input.created_date {
        object.key("CreatedDate").string(var_1237);
    }
    if let Some(var_1238) = &input.last_updated_date {
        object.key("LastUpdatedDate").string(var_1238);
    }
    if let Some(var_1239) = &input.web_acl_arn {
        object.key("WebAclArn").string(var_1239);
    }
}

pub fn serialize_structure_crate_model_aws_api_gateway_rest_api_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsApiGatewayRestApiDetails,
) {
    if let Some(var_1240) = &input.id {
        object.key("Id").string(var_1240);
    }
    if let Some(var_1241) = &input.name {
        object.key("Name").string(var_1241);
    }
    if let Some(var_1242) = &input.description {
        object.key("Description").string(var_1242);
    }
    if let Some(var_1243) = &input.created_date {
        object.key("CreatedDate").string(var_1243);
    }
    if let Some(var_1244) = &input.version {
        object.key("Version").string(var_1244);
    }
    if let Some(var_1245) = &input.binary_media_types {
        let mut array_1246 = object.key("BinaryMediaTypes").start_array();
        for item_1247 in var_1245 {
            {
                array_1246.value().string(item_1247);
            }
        }
        array_1246.finish();
    }
    if input.minimum_compression_size != 0 {
        object.key("MinimumCompressionSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.minimum_compression_size).into()),
        );
    }
    if let Some(var_1248) = &input.api_key_source {
        object.key("ApiKeySource").string(var_1248);
    }
    if let Some(var_1249) = &input.endpoint_configuration {
        let mut object_1250 = object.key("EndpointConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_api_gateway_endpoint_configuration(
            &mut object_1250,
            var_1249,
        );
        object_1250.finish();
    }
}

pub fn serialize_structure_crate_model_aws_cloud_trail_trail_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCloudTrailTrailDetails,
) {
    if let Some(var_1251) = &input.cloud_watch_logs_log_group_arn {
        object.key("CloudWatchLogsLogGroupArn").string(var_1251);
    }
    if let Some(var_1252) = &input.cloud_watch_logs_role_arn {
        object.key("CloudWatchLogsRoleArn").string(var_1252);
    }
    if input.has_custom_event_selectors {
        object
            .key("HasCustomEventSelectors")
            .boolean(input.has_custom_event_selectors);
    }
    if let Some(var_1253) = &input.home_region {
        object.key("HomeRegion").string(var_1253);
    }
    if input.include_global_service_events {
        object
            .key("IncludeGlobalServiceEvents")
            .boolean(input.include_global_service_events);
    }
    if input.is_multi_region_trail {
        object
            .key("IsMultiRegionTrail")
            .boolean(input.is_multi_region_trail);
    }
    if input.is_organization_trail {
        object
            .key("IsOrganizationTrail")
            .boolean(input.is_organization_trail);
    }
    if let Some(var_1254) = &input.kms_key_id {
        object.key("KmsKeyId").string(var_1254);
    }
    if input.log_file_validation_enabled {
        object
            .key("LogFileValidationEnabled")
            .boolean(input.log_file_validation_enabled);
    }
    if let Some(var_1255) = &input.name {
        object.key("Name").string(var_1255);
    }
    if let Some(var_1256) = &input.s3_bucket_name {
        object.key("S3BucketName").string(var_1256);
    }
    if let Some(var_1257) = &input.s3_key_prefix {
        object.key("S3KeyPrefix").string(var_1257);
    }
    if let Some(var_1258) = &input.sns_topic_arn {
        object.key("SnsTopicArn").string(var_1258);
    }
    if let Some(var_1259) = &input.sns_topic_name {
        object.key("SnsTopicName").string(var_1259);
    }
    if let Some(var_1260) = &input.trail_arn {
        object.key("TrailArn").string(var_1260);
    }
}

pub fn serialize_structure_crate_model_aws_ssm_patch_compliance_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsSsmPatchComplianceDetails,
) {
    if let Some(var_1261) = &input.patch {
        let mut object_1262 = object.key("Patch").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ssm_patch(&mut object_1262, var_1261);
        object_1262.finish();
    }
}

pub fn serialize_structure_crate_model_aws_certificate_manager_certificate_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCertificateManagerCertificateDetails,
) {
    if let Some(var_1263) = &input.certificate_authority_arn {
        object.key("CertificateAuthorityArn").string(var_1263);
    }
    if let Some(var_1264) = &input.created_at {
        object.key("CreatedAt").string(var_1264);
    }
    if let Some(var_1265) = &input.domain_name {
        object.key("DomainName").string(var_1265);
    }
    if let Some(var_1266) = &input.domain_validation_options {
        let mut array_1267 = object.key("DomainValidationOptions").start_array();
        for item_1268 in var_1266 {
            {
                let mut object_1269 = array_1267.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_certificate_manager_certificate_domain_validation_option(&mut object_1269, item_1268);
                object_1269.finish();
            }
        }
        array_1267.finish();
    }
    if let Some(var_1270) = &input.extended_key_usages {
        let mut array_1271 = object.key("ExtendedKeyUsages").start_array();
        for item_1272 in var_1270 {
            {
                let mut object_1273 = array_1271.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_certificate_manager_certificate_extended_key_usage(&mut object_1273, item_1272);
                object_1273.finish();
            }
        }
        array_1271.finish();
    }
    if let Some(var_1274) = &input.failure_reason {
        object.key("FailureReason").string(var_1274);
    }
    if let Some(var_1275) = &input.imported_at {
        object.key("ImportedAt").string(var_1275);
    }
    if let Some(var_1276) = &input.in_use_by {
        let mut array_1277 = object.key("InUseBy").start_array();
        for item_1278 in var_1276 {
            {
                array_1277.value().string(item_1278);
            }
        }
        array_1277.finish();
    }
    if let Some(var_1279) = &input.issued_at {
        object.key("IssuedAt").string(var_1279);
    }
    if let Some(var_1280) = &input.issuer {
        object.key("Issuer").string(var_1280);
    }
    if let Some(var_1281) = &input.key_algorithm {
        object.key("KeyAlgorithm").string(var_1281);
    }
    if let Some(var_1282) = &input.key_usages {
        let mut array_1283 = object.key("KeyUsages").start_array();
        for item_1284 in var_1282 {
            {
                let mut object_1285 = array_1283.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_certificate_manager_certificate_key_usage(&mut object_1285, item_1284);
                object_1285.finish();
            }
        }
        array_1283.finish();
    }
    if let Some(var_1286) = &input.not_after {
        object.key("NotAfter").string(var_1286);
    }
    if let Some(var_1287) = &input.not_before {
        object.key("NotBefore").string(var_1287);
    }
    if let Some(var_1288) = &input.options {
        let mut object_1289 = object.key("Options").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_certificate_manager_certificate_options(&mut object_1289, var_1288);
        object_1289.finish();
    }
    if let Some(var_1290) = &input.renewal_eligibility {
        object.key("RenewalEligibility").string(var_1290);
    }
    if let Some(var_1291) = &input.renewal_summary {
        let mut object_1292 = object.key("RenewalSummary").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_certificate_manager_certificate_renewal_summary(&mut object_1292, var_1291);
        object_1292.finish();
    }
    if let Some(var_1293) = &input.serial {
        object.key("Serial").string(var_1293);
    }
    if let Some(var_1294) = &input.signature_algorithm {
        object.key("SignatureAlgorithm").string(var_1294);
    }
    if let Some(var_1295) = &input.status {
        object.key("Status").string(var_1295);
    }
    if let Some(var_1296) = &input.subject {
        object.key("Subject").string(var_1296);
    }
    if let Some(var_1297) = &input.subject_alternative_names {
        let mut array_1298 = object.key("SubjectAlternativeNames").start_array();
        for item_1299 in var_1297 {
            {
                array_1298.value().string(item_1299);
            }
        }
        array_1298.finish();
    }
    if let Some(var_1300) = &input.r#type {
        object.key("Type").string(var_1300);
    }
}

pub fn serialize_structure_crate_model_aws_redshift_cluster_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRedshiftClusterDetails,
) {
    if input.allow_version_upgrade {
        object
            .key("AllowVersionUpgrade")
            .boolean(input.allow_version_upgrade);
    }
    if input.automated_snapshot_retention_period != 0 {
        object.key("AutomatedSnapshotRetentionPeriod").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.automated_snapshot_retention_period).into()),
        );
    }
    if let Some(var_1301) = &input.availability_zone {
        object.key("AvailabilityZone").string(var_1301);
    }
    if let Some(var_1302) = &input.cluster_availability_status {
        object.key("ClusterAvailabilityStatus").string(var_1302);
    }
    if let Some(var_1303) = &input.cluster_create_time {
        object.key("ClusterCreateTime").string(var_1303);
    }
    if let Some(var_1304) = &input.cluster_identifier {
        object.key("ClusterIdentifier").string(var_1304);
    }
    if let Some(var_1305) = &input.cluster_nodes {
        let mut array_1306 = object.key("ClusterNodes").start_array();
        for item_1307 in var_1305 {
            {
                let mut object_1308 = array_1306.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_cluster_node(
                    &mut object_1308,
                    item_1307,
                );
                object_1308.finish();
            }
        }
        array_1306.finish();
    }
    if let Some(var_1309) = &input.cluster_parameter_groups {
        let mut array_1310 = object.key("ClusterParameterGroups").start_array();
        for item_1311 in var_1309 {
            {
                let mut object_1312 = array_1310.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_cluster_parameter_group(&mut object_1312, item_1311);
                object_1312.finish();
            }
        }
        array_1310.finish();
    }
    if let Some(var_1313) = &input.cluster_public_key {
        object.key("ClusterPublicKey").string(var_1313);
    }
    if let Some(var_1314) = &input.cluster_revision_number {
        object.key("ClusterRevisionNumber").string(var_1314);
    }
    if let Some(var_1315) = &input.cluster_security_groups {
        let mut array_1316 = object.key("ClusterSecurityGroups").start_array();
        for item_1317 in var_1315 {
            {
                let mut object_1318 = array_1316.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_cluster_security_group(&mut object_1318, item_1317);
                object_1318.finish();
            }
        }
        array_1316.finish();
    }
    if let Some(var_1319) = &input.cluster_snapshot_copy_status {
        let mut object_1320 = object.key("ClusterSnapshotCopyStatus").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_cluster_snapshot_copy_status(&mut object_1320, var_1319);
        object_1320.finish();
    }
    if let Some(var_1321) = &input.cluster_status {
        object.key("ClusterStatus").string(var_1321);
    }
    if let Some(var_1322) = &input.cluster_subnet_group_name {
        object.key("ClusterSubnetGroupName").string(var_1322);
    }
    if let Some(var_1323) = &input.cluster_version {
        object.key("ClusterVersion").string(var_1323);
    }
    if let Some(var_1324) = &input.db_name {
        object.key("DBName").string(var_1324);
    }
    if let Some(var_1325) = &input.deferred_maintenance_windows {
        let mut array_1326 = object.key("DeferredMaintenanceWindows").start_array();
        for item_1327 in var_1325 {
            {
                let mut object_1328 = array_1326.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_deferred_maintenance_window(&mut object_1328, item_1327);
                object_1328.finish();
            }
        }
        array_1326.finish();
    }
    if let Some(var_1329) = &input.elastic_ip_status {
        let mut object_1330 = object.key("ElasticIpStatus").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_elastic_ip_status(
            &mut object_1330,
            var_1329,
        );
        object_1330.finish();
    }
    if let Some(var_1331) = &input.elastic_resize_number_of_node_options {
        object
            .key("ElasticResizeNumberOfNodeOptions")
            .string(var_1331);
    }
    if input.encrypted {
        object.key("Encrypted").boolean(input.encrypted);
    }
    if let Some(var_1332) = &input.endpoint {
        let mut object_1333 = object.key("Endpoint").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_endpoint(
            &mut object_1333,
            var_1332,
        );
        object_1333.finish();
    }
    if input.enhanced_vpc_routing {
        object
            .key("EnhancedVpcRouting")
            .boolean(input.enhanced_vpc_routing);
    }
    if let Some(var_1334) = &input.expected_next_snapshot_schedule_time {
        object
            .key("ExpectedNextSnapshotScheduleTime")
            .string(var_1334);
    }
    if let Some(var_1335) = &input.expected_next_snapshot_schedule_time_status {
        object
            .key("ExpectedNextSnapshotScheduleTimeStatus")
            .string(var_1335);
    }
    if let Some(var_1336) = &input.hsm_status {
        let mut object_1337 = object.key("HsmStatus").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_hsm_status(
            &mut object_1337,
            var_1336,
        );
        object_1337.finish();
    }
    if let Some(var_1338) = &input.iam_roles {
        let mut array_1339 = object.key("IamRoles").start_array();
        for item_1340 in var_1338 {
            {
                let mut object_1341 = array_1339.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_iam_role(
                    &mut object_1341,
                    item_1340,
                );
                object_1341.finish();
            }
        }
        array_1339.finish();
    }
    if let Some(var_1342) = &input.kms_key_id {
        object.key("KmsKeyId").string(var_1342);
    }
    if let Some(var_1343) = &input.maintenance_track_name {
        object.key("MaintenanceTrackName").string(var_1343);
    }
    if input.manual_snapshot_retention_period != 0 {
        object.key("ManualSnapshotRetentionPeriod").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.manual_snapshot_retention_period).into()),
        );
    }
    if let Some(var_1344) = &input.master_username {
        object.key("MasterUsername").string(var_1344);
    }
    if let Some(var_1345) = &input.next_maintenance_window_start_time {
        object
            .key("NextMaintenanceWindowStartTime")
            .string(var_1345);
    }
    if let Some(var_1346) = &input.node_type {
        object.key("NodeType").string(var_1346);
    }
    if input.number_of_nodes != 0 {
        object.key("NumberOfNodes").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.number_of_nodes).into()),
        );
    }
    if let Some(var_1347) = &input.pending_actions {
        let mut array_1348 = object.key("PendingActions").start_array();
        for item_1349 in var_1347 {
            {
                array_1348.value().string(item_1349);
            }
        }
        array_1348.finish();
    }
    if let Some(var_1350) = &input.pending_modified_values {
        let mut object_1351 = object.key("PendingModifiedValues").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_pending_modified_values(&mut object_1351, var_1350);
        object_1351.finish();
    }
    if let Some(var_1352) = &input.preferred_maintenance_window {
        object.key("PreferredMaintenanceWindow").string(var_1352);
    }
    if input.publicly_accessible {
        object
            .key("PubliclyAccessible")
            .boolean(input.publicly_accessible);
    }
    if let Some(var_1353) = &input.resize_info {
        let mut object_1354 = object.key("ResizeInfo").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_resize_info(
            &mut object_1354,
            var_1353,
        );
        object_1354.finish();
    }
    if let Some(var_1355) = &input.restore_status {
        let mut object_1356 = object.key("RestoreStatus").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_restore_status(
            &mut object_1356,
            var_1355,
        );
        object_1356.finish();
    }
    if let Some(var_1357) = &input.snapshot_schedule_identifier {
        object.key("SnapshotScheduleIdentifier").string(var_1357);
    }
    if let Some(var_1358) = &input.snapshot_schedule_state {
        object.key("SnapshotScheduleState").string(var_1358);
    }
    if let Some(var_1359) = &input.vpc_id {
        object.key("VpcId").string(var_1359);
    }
    if let Some(var_1360) = &input.vpc_security_groups {
        let mut array_1361 = object.key("VpcSecurityGroups").start_array();
        for item_1362 in var_1360 {
            {
                let mut object_1363 = array_1361.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_vpc_security_group(&mut object_1363, item_1362);
                object_1363.finish();
            }
        }
        array_1361.finish();
    }
}

pub fn serialize_structure_crate_model_aws_elb_load_balancer_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElbLoadBalancerDetails,
) {
    if let Some(var_1364) = &input.availability_zones {
        let mut array_1365 = object.key("AvailabilityZones").start_array();
        for item_1366 in var_1364 {
            {
                array_1365.value().string(item_1366);
            }
        }
        array_1365.finish();
    }
    if let Some(var_1367) = &input.backend_server_descriptions {
        let mut array_1368 = object.key("BackendServerDescriptions").start_array();
        for item_1369 in var_1367 {
            {
                let mut object_1370 = array_1368.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_backend_server_description(&mut object_1370, item_1369);
                object_1370.finish();
            }
        }
        array_1368.finish();
    }
    if let Some(var_1371) = &input.canonical_hosted_zone_name {
        object.key("CanonicalHostedZoneName").string(var_1371);
    }
    if let Some(var_1372) = &input.canonical_hosted_zone_name_id {
        object.key("CanonicalHostedZoneNameID").string(var_1372);
    }
    if let Some(var_1373) = &input.created_time {
        object.key("CreatedTime").string(var_1373);
    }
    if let Some(var_1374) = &input.dns_name {
        object.key("DnsName").string(var_1374);
    }
    if let Some(var_1375) = &input.health_check {
        let mut object_1376 = object.key("HealthCheck").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_health_check(
            &mut object_1376,
            var_1375,
        );
        object_1376.finish();
    }
    if let Some(var_1377) = &input.instances {
        let mut array_1378 = object.key("Instances").start_array();
        for item_1379 in var_1377 {
            {
                let mut object_1380 = array_1378.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_instance(
                    &mut object_1380,
                    item_1379,
                );
                object_1380.finish();
            }
        }
        array_1378.finish();
    }
    if let Some(var_1381) = &input.listener_descriptions {
        let mut array_1382 = object.key("ListenerDescriptions").start_array();
        for item_1383 in var_1381 {
            {
                let mut object_1384 = array_1382.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_listener_description(&mut object_1384, item_1383);
                object_1384.finish();
            }
        }
        array_1382.finish();
    }
    if let Some(var_1385) = &input.load_balancer_attributes {
        let mut object_1386 = object.key("LoadBalancerAttributes").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_attributes(
            &mut object_1386,
            var_1385,
        );
        object_1386.finish();
    }
    if let Some(var_1387) = &input.load_balancer_name {
        object.key("LoadBalancerName").string(var_1387);
    }
    if let Some(var_1388) = &input.policies {
        let mut object_1389 = object.key("Policies").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_policies(
            &mut object_1389,
            var_1388,
        );
        object_1389.finish();
    }
    if let Some(var_1390) = &input.scheme {
        object.key("Scheme").string(var_1390);
    }
    if let Some(var_1391) = &input.security_groups {
        let mut array_1392 = object.key("SecurityGroups").start_array();
        for item_1393 in var_1391 {
            {
                array_1392.value().string(item_1393);
            }
        }
        array_1392.finish();
    }
    if let Some(var_1394) = &input.source_security_group {
        let mut object_1395 = object.key("SourceSecurityGroup").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_source_security_group(&mut object_1395, var_1394);
        object_1395.finish();
    }
    if let Some(var_1396) = &input.subnets {
        let mut array_1397 = object.key("Subnets").start_array();
        for item_1398 in var_1396 {
            {
                array_1397.value().string(item_1398);
            }
        }
        array_1397.finish();
    }
    if let Some(var_1399) = &input.vpc_id {
        object.key("VpcId").string(var_1399);
    }
}

pub fn serialize_structure_crate_model_aws_iam_group_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsIamGroupDetails,
) {
    if let Some(var_1400) = &input.attached_managed_policies {
        let mut array_1401 = object.key("AttachedManagedPolicies").start_array();
        for item_1402 in var_1400 {
            {
                let mut object_1403 = array_1401.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_iam_attached_managed_policy(
                    &mut object_1403,
                    item_1402,
                );
                object_1403.finish();
            }
        }
        array_1401.finish();
    }
    if let Some(var_1404) = &input.create_date {
        object.key("CreateDate").string(var_1404);
    }
    if let Some(var_1405) = &input.group_id {
        object.key("GroupId").string(var_1405);
    }
    if let Some(var_1406) = &input.group_name {
        object.key("GroupName").string(var_1406);
    }
    if let Some(var_1407) = &input.group_policy_list {
        let mut array_1408 = object.key("GroupPolicyList").start_array();
        for item_1409 in var_1407 {
            {
                let mut object_1410 = array_1408.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_iam_group_policy(
                    &mut object_1410,
                    item_1409,
                );
                object_1410.finish();
            }
        }
        array_1408.finish();
    }
    if let Some(var_1411) = &input.path {
        object.key("Path").string(var_1411);
    }
}

pub fn serialize_structure_crate_model_aws_iam_role_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsIamRoleDetails,
) {
    if let Some(var_1412) = &input.assume_role_policy_document {
        object.key("AssumeRolePolicyDocument").string(var_1412);
    }
    if let Some(var_1413) = &input.attached_managed_policies {
        let mut array_1414 = object.key("AttachedManagedPolicies").start_array();
        for item_1415 in var_1413 {
            {
                let mut object_1416 = array_1414.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_iam_attached_managed_policy(
                    &mut object_1416,
                    item_1415,
                );
                object_1416.finish();
            }
        }
        array_1414.finish();
    }
    if let Some(var_1417) = &input.create_date {
        object.key("CreateDate").string(var_1417);
    }
    if let Some(var_1418) = &input.instance_profile_list {
        let mut array_1419 = object.key("InstanceProfileList").start_array();
        for item_1420 in var_1418 {
            {
                let mut object_1421 = array_1419.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_iam_instance_profile(
                    &mut object_1421,
                    item_1420,
                );
                object_1421.finish();
            }
        }
        array_1419.finish();
    }
    if let Some(var_1422) = &input.permissions_boundary {
        let mut object_1423 = object.key("PermissionsBoundary").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_iam_permissions_boundary(
            &mut object_1423,
            var_1422,
        );
        object_1423.finish();
    }
    if let Some(var_1424) = &input.role_id {
        object.key("RoleId").string(var_1424);
    }
    if let Some(var_1425) = &input.role_name {
        object.key("RoleName").string(var_1425);
    }
    if let Some(var_1426) = &input.role_policy_list {
        let mut array_1427 = object.key("RolePolicyList").start_array();
        for item_1428 in var_1426 {
            {
                let mut object_1429 = array_1427.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_iam_role_policy(
                    &mut object_1429,
                    item_1428,
                );
                object_1429.finish();
            }
        }
        array_1427.finish();
    }
    if input.max_session_duration != 0 {
        object.key("MaxSessionDuration").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_session_duration).into()),
        );
    }
    if let Some(var_1430) = &input.path {
        object.key("Path").string(var_1430);
    }
}

pub fn serialize_structure_crate_model_aws_kms_key_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsKmsKeyDetails,
) {
    if let Some(var_1431) = &input.aws_account_id {
        object.key("AWSAccountId").string(var_1431);
    }
    if input.creation_date != 0.0 {
        object.key("CreationDate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.creation_date).into()),
        );
    }
    if let Some(var_1432) = &input.key_id {
        object.key("KeyId").string(var_1432);
    }
    if let Some(var_1433) = &input.key_manager {
        object.key("KeyManager").string(var_1433);
    }
    if let Some(var_1434) = &input.key_state {
        object.key("KeyState").string(var_1434);
    }
    if let Some(var_1435) = &input.origin {
        object.key("Origin").string(var_1435);
    }
    if let Some(var_1436) = &input.description {
        object.key("Description").string(var_1436);
    }
    if input.key_rotation_status {
        object
            .key("KeyRotationStatus")
            .boolean(input.key_rotation_status);
    }
}

pub fn serialize_structure_crate_model_aws_lambda_function_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsLambdaFunctionDetails,
) {
    if let Some(var_1437) = &input.code {
        let mut object_1438 = object.key("Code").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_lambda_function_code(
            &mut object_1438,
            var_1437,
        );
        object_1438.finish();
    }
    if let Some(var_1439) = &input.code_sha256 {
        object.key("CodeSha256").string(var_1439);
    }
    if let Some(var_1440) = &input.dead_letter_config {
        let mut object_1441 = object.key("DeadLetterConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_lambda_function_dead_letter_config(
            &mut object_1441,
            var_1440,
        );
        object_1441.finish();
    }
    if let Some(var_1442) = &input.environment {
        let mut object_1443 = object.key("Environment").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_lambda_function_environment(
            &mut object_1443,
            var_1442,
        );
        object_1443.finish();
    }
    if let Some(var_1444) = &input.function_name {
        object.key("FunctionName").string(var_1444);
    }
    if let Some(var_1445) = &input.handler {
        object.key("Handler").string(var_1445);
    }
    if let Some(var_1446) = &input.kms_key_arn {
        object.key("KmsKeyArn").string(var_1446);
    }
    if let Some(var_1447) = &input.last_modified {
        object.key("LastModified").string(var_1447);
    }
    if let Some(var_1448) = &input.layers {
        let mut array_1449 = object.key("Layers").start_array();
        for item_1450 in var_1448 {
            {
                let mut object_1451 = array_1449.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_lambda_function_layer(
                    &mut object_1451,
                    item_1450,
                );
                object_1451.finish();
            }
        }
        array_1449.finish();
    }
    if let Some(var_1452) = &input.master_arn {
        object.key("MasterArn").string(var_1452);
    }
    if input.memory_size != 0 {
        object.key("MemorySize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.memory_size).into()),
        );
    }
    if let Some(var_1453) = &input.revision_id {
        object.key("RevisionId").string(var_1453);
    }
    if let Some(var_1454) = &input.role {
        object.key("Role").string(var_1454);
    }
    if let Some(var_1455) = &input.runtime {
        object.key("Runtime").string(var_1455);
    }
    if input.timeout != 0 {
        object.key("Timeout").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.timeout).into()),
        );
    }
    if let Some(var_1456) = &input.tracing_config {
        let mut object_1457 = object.key("TracingConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_lambda_function_tracing_config(
            &mut object_1457,
            var_1456,
        );
        object_1457.finish();
    }
    if let Some(var_1458) = &input.vpc_config {
        let mut object_1459 = object.key("VpcConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_lambda_function_vpc_config(
            &mut object_1459,
            var_1458,
        );
        object_1459.finish();
    }
    if let Some(var_1460) = &input.version {
        object.key("Version").string(var_1460);
    }
}

pub fn serialize_structure_crate_model_aws_lambda_layer_version_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsLambdaLayerVersionDetails,
) {
    if input.version != 0 {
        object.key("Version").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.version).into()),
        );
    }
    if let Some(var_1461) = &input.compatible_runtimes {
        let mut array_1462 = object.key("CompatibleRuntimes").start_array();
        for item_1463 in var_1461 {
            {
                array_1462.value().string(item_1463);
            }
        }
        array_1462.finish();
    }
    if let Some(var_1464) = &input.created_date {
        object.key("CreatedDate").string(var_1464);
    }
}

pub fn serialize_structure_crate_model_aws_rds_db_instance_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsDbInstanceDetails,
) {
    if let Some(var_1465) = &input.associated_roles {
        let mut array_1466 = object.key("AssociatedRoles").start_array();
        for item_1467 in var_1465 {
            {
                let mut object_1468 = array_1466.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_rds_db_instance_associated_role(&mut object_1468, item_1467);
                object_1468.finish();
            }
        }
        array_1466.finish();
    }
    if let Some(var_1469) = &input.ca_certificate_identifier {
        object.key("CACertificateIdentifier").string(var_1469);
    }
    if let Some(var_1470) = &input.db_cluster_identifier {
        object.key("DBClusterIdentifier").string(var_1470);
    }
    if let Some(var_1471) = &input.db_instance_identifier {
        object.key("DBInstanceIdentifier").string(var_1471);
    }
    if let Some(var_1472) = &input.db_instance_class {
        object.key("DBInstanceClass").string(var_1472);
    }
    if input.db_instance_port != 0 {
        object.key("DbInstancePort").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.db_instance_port).into()),
        );
    }
    if let Some(var_1473) = &input.dbi_resource_id {
        object.key("DbiResourceId").string(var_1473);
    }
    if let Some(var_1474) = &input.db_name {
        object.key("DBName").string(var_1474);
    }
    if input.deletion_protection {
        object
            .key("DeletionProtection")
            .boolean(input.deletion_protection);
    }
    if let Some(var_1475) = &input.endpoint {
        let mut object_1476 = object.key("Endpoint").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_rds_db_instance_endpoint(
            &mut object_1476,
            var_1475,
        );
        object_1476.finish();
    }
    if let Some(var_1477) = &input.engine {
        object.key("Engine").string(var_1477);
    }
    if let Some(var_1478) = &input.engine_version {
        object.key("EngineVersion").string(var_1478);
    }
    if input.iam_database_authentication_enabled {
        object
            .key("IAMDatabaseAuthenticationEnabled")
            .boolean(input.iam_database_authentication_enabled);
    }
    if let Some(var_1479) = &input.instance_create_time {
        object.key("InstanceCreateTime").string(var_1479);
    }
    if let Some(var_1480) = &input.kms_key_id {
        object.key("KmsKeyId").string(var_1480);
    }
    if input.publicly_accessible {
        object
            .key("PubliclyAccessible")
            .boolean(input.publicly_accessible);
    }
    if input.storage_encrypted {
        object
            .key("StorageEncrypted")
            .boolean(input.storage_encrypted);
    }
    if let Some(var_1481) = &input.tde_credential_arn {
        object.key("TdeCredentialArn").string(var_1481);
    }
    if let Some(var_1482) = &input.vpc_security_groups {
        let mut array_1483 = object.key("VpcSecurityGroups").start_array();
        for item_1484 in var_1482 {
            {
                let mut object_1485 = array_1483.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_rds_db_instance_vpc_security_group(&mut object_1485, item_1484);
                object_1485.finish();
            }
        }
        array_1483.finish();
    }
    if input.multi_az {
        object.key("MultiAz").boolean(input.multi_az);
    }
    if let Some(var_1486) = &input.enhanced_monitoring_resource_arn {
        object.key("EnhancedMonitoringResourceArn").string(var_1486);
    }
    if let Some(var_1487) = &input.db_instance_status {
        object.key("DbInstanceStatus").string(var_1487);
    }
    if let Some(var_1488) = &input.master_username {
        object.key("MasterUsername").string(var_1488);
    }
    if input.allocated_storage != 0 {
        object.key("AllocatedStorage").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.allocated_storage).into()),
        );
    }
    if let Some(var_1489) = &input.preferred_backup_window {
        object.key("PreferredBackupWindow").string(var_1489);
    }
    if input.backup_retention_period != 0 {
        object.key("BackupRetentionPeriod").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.backup_retention_period).into()),
        );
    }
    if let Some(var_1490) = &input.db_security_groups {
        let mut array_1491 = object.key("DbSecurityGroups").start_array();
        for item_1492 in var_1490 {
            {
                array_1491.value().string(item_1492);
            }
        }
        array_1491.finish();
    }
    if let Some(var_1493) = &input.db_parameter_groups {
        let mut array_1494 = object.key("DbParameterGroups").start_array();
        for item_1495 in var_1493 {
            {
                let mut object_1496 = array_1494.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_rds_db_parameter_group(
                    &mut object_1496,
                    item_1495,
                );
                object_1496.finish();
            }
        }
        array_1494.finish();
    }
    if let Some(var_1497) = &input.availability_zone {
        object.key("AvailabilityZone").string(var_1497);
    }
    if let Some(var_1498) = &input.db_subnet_group {
        let mut object_1499 = object.key("DbSubnetGroup").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_rds_db_subnet_group(
            &mut object_1499,
            var_1498,
        );
        object_1499.finish();
    }
    if let Some(var_1500) = &input.preferred_maintenance_window {
        object.key("PreferredMaintenanceWindow").string(var_1500);
    }
    if let Some(var_1501) = &input.pending_modified_values {
        let mut object_1502 = object.key("PendingModifiedValues").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_rds_db_pending_modified_values(
            &mut object_1502,
            var_1501,
        );
        object_1502.finish();
    }
    if let Some(var_1503) = &input.latest_restorable_time {
        object.key("LatestRestorableTime").string(var_1503);
    }
    if input.auto_minor_version_upgrade {
        object
            .key("AutoMinorVersionUpgrade")
            .boolean(input.auto_minor_version_upgrade);
    }
    if let Some(var_1504) = &input.read_replica_source_db_instance_identifier {
        object
            .key("ReadReplicaSourceDBInstanceIdentifier")
            .string(var_1504);
    }
    if let Some(var_1505) = &input.read_replica_db_instance_identifiers {
        let mut array_1506 = object.key("ReadReplicaDBInstanceIdentifiers").start_array();
        for item_1507 in var_1505 {
            {
                array_1506.value().string(item_1507);
            }
        }
        array_1506.finish();
    }
    if let Some(var_1508) = &input.read_replica_db_cluster_identifiers {
        let mut array_1509 = object.key("ReadReplicaDBClusterIdentifiers").start_array();
        for item_1510 in var_1508 {
            {
                array_1509.value().string(item_1510);
            }
        }
        array_1509.finish();
    }
    if let Some(var_1511) = &input.license_model {
        object.key("LicenseModel").string(var_1511);
    }
    if input.iops != 0 {
        object.key("Iops").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.iops).into()),
        );
    }
    if let Some(var_1512) = &input.option_group_memberships {
        let mut array_1513 = object.key("OptionGroupMemberships").start_array();
        for item_1514 in var_1512 {
            {
                let mut object_1515 = array_1513.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_rds_db_option_group_membership(
                    &mut object_1515,
                    item_1514,
                );
                object_1515.finish();
            }
        }
        array_1513.finish();
    }
    if let Some(var_1516) = &input.character_set_name {
        object.key("CharacterSetName").string(var_1516);
    }
    if let Some(var_1517) = &input.secondary_availability_zone {
        object.key("SecondaryAvailabilityZone").string(var_1517);
    }
    if let Some(var_1518) = &input.status_infos {
        let mut array_1519 = object.key("StatusInfos").start_array();
        for item_1520 in var_1518 {
            {
                let mut object_1521 = array_1519.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_rds_db_status_info(
                    &mut object_1521,
                    item_1520,
                );
                object_1521.finish();
            }
        }
        array_1519.finish();
    }
    if let Some(var_1522) = &input.storage_type {
        object.key("StorageType").string(var_1522);
    }
    if let Some(var_1523) = &input.domain_memberships {
        let mut array_1524 = object.key("DomainMemberships").start_array();
        for item_1525 in var_1523 {
            {
                let mut object_1526 = array_1524.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_rds_db_domain_membership(
                    &mut object_1526,
                    item_1525,
                );
                object_1526.finish();
            }
        }
        array_1524.finish();
    }
    if input.copy_tags_to_snapshot {
        object
            .key("CopyTagsToSnapshot")
            .boolean(input.copy_tags_to_snapshot);
    }
    if input.monitoring_interval != 0 {
        object.key("MonitoringInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.monitoring_interval).into()),
        );
    }
    if let Some(var_1527) = &input.monitoring_role_arn {
        object.key("MonitoringRoleArn").string(var_1527);
    }
    if input.promotion_tier != 0 {
        object.key("PromotionTier").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.promotion_tier).into()),
        );
    }
    if let Some(var_1528) = &input.timezone {
        object.key("Timezone").string(var_1528);
    }
    if input.performance_insights_enabled {
        object
            .key("PerformanceInsightsEnabled")
            .boolean(input.performance_insights_enabled);
    }
    if let Some(var_1529) = &input.performance_insights_kms_key_id {
        object.key("PerformanceInsightsKmsKeyId").string(var_1529);
    }
    if input.performance_insights_retention_period != 0 {
        object.key("PerformanceInsightsRetentionPeriod").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.performance_insights_retention_period).into()),
        );
    }
    if let Some(var_1530) = &input.enabled_cloud_watch_logs_exports {
        let mut array_1531 = object.key("EnabledCloudWatchLogsExports").start_array();
        for item_1532 in var_1530 {
            {
                array_1531.value().string(item_1532);
            }
        }
        array_1531.finish();
    }
    if let Some(var_1533) = &input.processor_features {
        let mut array_1534 = object.key("ProcessorFeatures").start_array();
        for item_1535 in var_1533 {
            {
                let mut object_1536 = array_1534.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_rds_db_processor_feature(
                    &mut object_1536,
                    item_1535,
                );
                object_1536.finish();
            }
        }
        array_1534.finish();
    }
    if let Some(var_1537) = &input.listener_endpoint {
        let mut object_1538 = object.key("ListenerEndpoint").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_rds_db_instance_endpoint(
            &mut object_1538,
            var_1537,
        );
        object_1538.finish();
    }
    if input.max_allocated_storage != 0 {
        object.key("MaxAllocatedStorage").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_allocated_storage).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_sns_topic_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsSnsTopicDetails,
) {
    if let Some(var_1539) = &input.kms_master_key_id {
        object.key("KmsMasterKeyId").string(var_1539);
    }
    if let Some(var_1540) = &input.subscription {
        let mut array_1541 = object.key("Subscription").start_array();
        for item_1542 in var_1540 {
            {
                let mut object_1543 = array_1541.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_sns_topic_subscription(
                    &mut object_1543,
                    item_1542,
                );
                object_1543.finish();
            }
        }
        array_1541.finish();
    }
    if let Some(var_1544) = &input.topic_name {
        object.key("TopicName").string(var_1544);
    }
    if let Some(var_1545) = &input.owner {
        object.key("Owner").string(var_1545);
    }
}

pub fn serialize_structure_crate_model_aws_sqs_queue_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsSqsQueueDetails,
) {
    if input.kms_data_key_reuse_period_seconds != 0 {
        object.key("KmsDataKeyReusePeriodSeconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.kms_data_key_reuse_period_seconds).into()),
        );
    }
    if let Some(var_1546) = &input.kms_master_key_id {
        object.key("KmsMasterKeyId").string(var_1546);
    }
    if let Some(var_1547) = &input.queue_name {
        object.key("QueueName").string(var_1547);
    }
    if let Some(var_1548) = &input.dead_letter_target_arn {
        object.key("DeadLetterTargetArn").string(var_1548);
    }
}

pub fn serialize_structure_crate_model_aws_waf_web_acl_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsWafWebAclDetails,
) {
    if let Some(var_1549) = &input.name {
        object.key("Name").string(var_1549);
    }
    if let Some(var_1550) = &input.default_action {
        object.key("DefaultAction").string(var_1550);
    }
    if let Some(var_1551) = &input.rules {
        let mut array_1552 = object.key("Rules").start_array();
        for item_1553 in var_1551 {
            {
                let mut object_1554 = array_1552.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_waf_web_acl_rule(
                    &mut object_1554,
                    item_1553,
                );
                object_1554.finish();
            }
        }
        array_1552.finish();
    }
    if let Some(var_1555) = &input.web_acl_id {
        object.key("WebAclId").string(var_1555);
    }
}

pub fn serialize_structure_crate_model_aws_rds_db_snapshot_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsDbSnapshotDetails,
) {
    if let Some(var_1556) = &input.db_snapshot_identifier {
        object.key("DbSnapshotIdentifier").string(var_1556);
    }
    if let Some(var_1557) = &input.db_instance_identifier {
        object.key("DbInstanceIdentifier").string(var_1557);
    }
    if let Some(var_1558) = &input.snapshot_create_time {
        object.key("SnapshotCreateTime").string(var_1558);
    }
    if let Some(var_1559) = &input.engine {
        object.key("Engine").string(var_1559);
    }
    if input.allocated_storage != 0 {
        object.key("AllocatedStorage").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.allocated_storage).into()),
        );
    }
    if let Some(var_1560) = &input.status {
        object.key("Status").string(var_1560);
    }
    if input.port != 0 {
        object.key("Port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.port).into()),
        );
    }
    if let Some(var_1561) = &input.availability_zone {
        object.key("AvailabilityZone").string(var_1561);
    }
    if let Some(var_1562) = &input.vpc_id {
        object.key("VpcId").string(var_1562);
    }
    if let Some(var_1563) = &input.instance_create_time {
        object.key("InstanceCreateTime").string(var_1563);
    }
    if let Some(var_1564) = &input.master_username {
        object.key("MasterUsername").string(var_1564);
    }
    if let Some(var_1565) = &input.engine_version {
        object.key("EngineVersion").string(var_1565);
    }
    if let Some(var_1566) = &input.license_model {
        object.key("LicenseModel").string(var_1566);
    }
    if let Some(var_1567) = &input.snapshot_type {
        object.key("SnapshotType").string(var_1567);
    }
    if input.iops != 0 {
        object.key("Iops").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.iops).into()),
        );
    }
    if let Some(var_1568) = &input.option_group_name {
        object.key("OptionGroupName").string(var_1568);
    }
    if input.percent_progress != 0 {
        object.key("PercentProgress").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.percent_progress).into()),
        );
    }
    if let Some(var_1569) = &input.source_region {
        object.key("SourceRegion").string(var_1569);
    }
    if let Some(var_1570) = &input.source_db_snapshot_identifier {
        object.key("SourceDbSnapshotIdentifier").string(var_1570);
    }
    if let Some(var_1571) = &input.storage_type {
        object.key("StorageType").string(var_1571);
    }
    if let Some(var_1572) = &input.tde_credential_arn {
        object.key("TdeCredentialArn").string(var_1572);
    }
    if input.encrypted {
        object.key("Encrypted").boolean(input.encrypted);
    }
    if let Some(var_1573) = &input.kms_key_id {
        object.key("KmsKeyId").string(var_1573);
    }
    if let Some(var_1574) = &input.timezone {
        object.key("Timezone").string(var_1574);
    }
    if input.iam_database_authentication_enabled {
        object
            .key("IamDatabaseAuthenticationEnabled")
            .boolean(input.iam_database_authentication_enabled);
    }
    if let Some(var_1575) = &input.processor_features {
        let mut array_1576 = object.key("ProcessorFeatures").start_array();
        for item_1577 in var_1575 {
            {
                let mut object_1578 = array_1576.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_rds_db_processor_feature(
                    &mut object_1578,
                    item_1577,
                );
                object_1578.finish();
            }
        }
        array_1576.finish();
    }
    if let Some(var_1579) = &input.dbi_resource_id {
        object.key("DbiResourceId").string(var_1579);
    }
}

pub fn serialize_structure_crate_model_aws_rds_db_cluster_snapshot_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsDbClusterSnapshotDetails,
) {
    if let Some(var_1580) = &input.availability_zones {
        let mut array_1581 = object.key("AvailabilityZones").start_array();
        for item_1582 in var_1580 {
            {
                array_1581.value().string(item_1582);
            }
        }
        array_1581.finish();
    }
    if let Some(var_1583) = &input.snapshot_create_time {
        object.key("SnapshotCreateTime").string(var_1583);
    }
    if let Some(var_1584) = &input.engine {
        object.key("Engine").string(var_1584);
    }
    if input.allocated_storage != 0 {
        object.key("AllocatedStorage").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.allocated_storage).into()),
        );
    }
    if let Some(var_1585) = &input.status {
        object.key("Status").string(var_1585);
    }
    if input.port != 0 {
        object.key("Port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.port).into()),
        );
    }
    if let Some(var_1586) = &input.vpc_id {
        object.key("VpcId").string(var_1586);
    }
    if let Some(var_1587) = &input.cluster_create_time {
        object.key("ClusterCreateTime").string(var_1587);
    }
    if let Some(var_1588) = &input.master_username {
        object.key("MasterUsername").string(var_1588);
    }
    if let Some(var_1589) = &input.engine_version {
        object.key("EngineVersion").string(var_1589);
    }
    if let Some(var_1590) = &input.license_model {
        object.key("LicenseModel").string(var_1590);
    }
    if let Some(var_1591) = &input.snapshot_type {
        object.key("SnapshotType").string(var_1591);
    }
    if input.percent_progress != 0 {
        object.key("PercentProgress").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.percent_progress).into()),
        );
    }
    if input.storage_encrypted {
        object
            .key("StorageEncrypted")
            .boolean(input.storage_encrypted);
    }
    if let Some(var_1592) = &input.kms_key_id {
        object.key("KmsKeyId").string(var_1592);
    }
    if let Some(var_1593) = &input.db_cluster_identifier {
        object.key("DbClusterIdentifier").string(var_1593);
    }
    if let Some(var_1594) = &input.db_cluster_snapshot_identifier {
        object.key("DbClusterSnapshotIdentifier").string(var_1594);
    }
    if input.iam_database_authentication_enabled {
        object
            .key("IamDatabaseAuthenticationEnabled")
            .boolean(input.iam_database_authentication_enabled);
    }
}

pub fn serialize_structure_crate_model_aws_rds_db_cluster_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsDbClusterDetails,
) {
    if input.allocated_storage != 0 {
        object.key("AllocatedStorage").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.allocated_storage).into()),
        );
    }
    if let Some(var_1595) = &input.availability_zones {
        let mut array_1596 = object.key("AvailabilityZones").start_array();
        for item_1597 in var_1595 {
            {
                array_1596.value().string(item_1597);
            }
        }
        array_1596.finish();
    }
    if input.backup_retention_period != 0 {
        object.key("BackupRetentionPeriod").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.backup_retention_period).into()),
        );
    }
    if let Some(var_1598) = &input.database_name {
        object.key("DatabaseName").string(var_1598);
    }
    if let Some(var_1599) = &input.status {
        object.key("Status").string(var_1599);
    }
    if let Some(var_1600) = &input.endpoint {
        object.key("Endpoint").string(var_1600);
    }
    if let Some(var_1601) = &input.reader_endpoint {
        object.key("ReaderEndpoint").string(var_1601);
    }
    if let Some(var_1602) = &input.custom_endpoints {
        let mut array_1603 = object.key("CustomEndpoints").start_array();
        for item_1604 in var_1602 {
            {
                array_1603.value().string(item_1604);
            }
        }
        array_1603.finish();
    }
    if input.multi_az {
        object.key("MultiAz").boolean(input.multi_az);
    }
    if let Some(var_1605) = &input.engine {
        object.key("Engine").string(var_1605);
    }
    if let Some(var_1606) = &input.engine_version {
        object.key("EngineVersion").string(var_1606);
    }
    if input.port != 0 {
        object.key("Port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.port).into()),
        );
    }
    if let Some(var_1607) = &input.master_username {
        object.key("MasterUsername").string(var_1607);
    }
    if let Some(var_1608) = &input.preferred_backup_window {
        object.key("PreferredBackupWindow").string(var_1608);
    }
    if let Some(var_1609) = &input.preferred_maintenance_window {
        object.key("PreferredMaintenanceWindow").string(var_1609);
    }
    if let Some(var_1610) = &input.read_replica_identifiers {
        let mut array_1611 = object.key("ReadReplicaIdentifiers").start_array();
        for item_1612 in var_1610 {
            {
                array_1611.value().string(item_1612);
            }
        }
        array_1611.finish();
    }
    if let Some(var_1613) = &input.vpc_security_groups {
        let mut array_1614 = object.key("VpcSecurityGroups").start_array();
        for item_1615 in var_1613 {
            {
                let mut object_1616 = array_1614.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_rds_db_instance_vpc_security_group(&mut object_1616, item_1615);
                object_1616.finish();
            }
        }
        array_1614.finish();
    }
    if let Some(var_1617) = &input.hosted_zone_id {
        object.key("HostedZoneId").string(var_1617);
    }
    if input.storage_encrypted {
        object
            .key("StorageEncrypted")
            .boolean(input.storage_encrypted);
    }
    if let Some(var_1618) = &input.kms_key_id {
        object.key("KmsKeyId").string(var_1618);
    }
    if let Some(var_1619) = &input.db_cluster_resource_id {
        object.key("DbClusterResourceId").string(var_1619);
    }
    if let Some(var_1620) = &input.associated_roles {
        let mut array_1621 = object.key("AssociatedRoles").start_array();
        for item_1622 in var_1620 {
            {
                let mut object_1623 = array_1621.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_rds_db_cluster_associated_role(
                    &mut object_1623,
                    item_1622,
                );
                object_1623.finish();
            }
        }
        array_1621.finish();
    }
    if let Some(var_1624) = &input.cluster_create_time {
        object.key("ClusterCreateTime").string(var_1624);
    }
    if let Some(var_1625) = &input.enabled_cloud_watch_logs_exports {
        let mut array_1626 = object.key("EnabledCloudWatchLogsExports").start_array();
        for item_1627 in var_1625 {
            {
                array_1626.value().string(item_1627);
            }
        }
        array_1626.finish();
    }
    if let Some(var_1628) = &input.engine_mode {
        object.key("EngineMode").string(var_1628);
    }
    if input.deletion_protection {
        object
            .key("DeletionProtection")
            .boolean(input.deletion_protection);
    }
    if input.http_endpoint_enabled {
        object
            .key("HttpEndpointEnabled")
            .boolean(input.http_endpoint_enabled);
    }
    if let Some(var_1629) = &input.activity_stream_status {
        object.key("ActivityStreamStatus").string(var_1629);
    }
    if input.copy_tags_to_snapshot {
        object
            .key("CopyTagsToSnapshot")
            .boolean(input.copy_tags_to_snapshot);
    }
    if input.cross_account_clone {
        object
            .key("CrossAccountClone")
            .boolean(input.cross_account_clone);
    }
    if let Some(var_1630) = &input.domain_memberships {
        let mut array_1631 = object.key("DomainMemberships").start_array();
        for item_1632 in var_1630 {
            {
                let mut object_1633 = array_1631.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_rds_db_domain_membership(
                    &mut object_1633,
                    item_1632,
                );
                object_1633.finish();
            }
        }
        array_1631.finish();
    }
    if let Some(var_1634) = &input.db_cluster_parameter_group {
        object.key("DbClusterParameterGroup").string(var_1634);
    }
    if let Some(var_1635) = &input.db_subnet_group {
        object.key("DbSubnetGroup").string(var_1635);
    }
    if let Some(var_1636) = &input.db_cluster_option_group_memberships {
        let mut array_1637 = object.key("DbClusterOptionGroupMemberships").start_array();
        for item_1638 in var_1636 {
            {
                let mut object_1639 = array_1637.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_rds_db_cluster_option_group_membership(&mut object_1639, item_1638);
                object_1639.finish();
            }
        }
        array_1637.finish();
    }
    if let Some(var_1640) = &input.db_cluster_identifier {
        object.key("DbClusterIdentifier").string(var_1640);
    }
    if let Some(var_1641) = &input.db_cluster_members {
        let mut array_1642 = object.key("DbClusterMembers").start_array();
        for item_1643 in var_1641 {
            {
                let mut object_1644 = array_1642.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_rds_db_cluster_member(
                    &mut object_1644,
                    item_1643,
                );
                object_1644.finish();
            }
        }
        array_1642.finish();
    }
    if input.iam_database_authentication_enabled {
        object
            .key("IamDatabaseAuthenticationEnabled")
            .boolean(input.iam_database_authentication_enabled);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_cluster_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsClusterDetails,
) {
    if let Some(var_1645) = &input.capacity_providers {
        let mut array_1646 = object.key("CapacityProviders").start_array();
        for item_1647 in var_1645 {
            {
                array_1646.value().string(item_1647);
            }
        }
        array_1646.finish();
    }
    if let Some(var_1648) = &input.cluster_settings {
        let mut array_1649 = object.key("ClusterSettings").start_array();
        for item_1650 in var_1648 {
            {
                let mut object_1651 = array_1649.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_cluster_cluster_settings_details(&mut object_1651, item_1650);
                object_1651.finish();
            }
        }
        array_1649.finish();
    }
    if let Some(var_1652) = &input.configuration {
        let mut object_1653 = object.key("Configuration").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_cluster_configuration_details(
            &mut object_1653,
            var_1652,
        );
        object_1653.finish();
    }
    if let Some(var_1654) = &input.default_capacity_provider_strategy {
        let mut array_1655 = object.key("DefaultCapacityProviderStrategy").start_array();
        for item_1656 in var_1654 {
            {
                let mut object_1657 = array_1655.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_cluster_default_capacity_provider_strategy_details(&mut object_1657, item_1656);
                object_1657.finish();
            }
        }
        array_1655.finish();
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionDetails,
) {
    if let Some(var_1658) = &input.container_definitions {
        let mut array_1659 = object.key("ContainerDefinitions").start_array();
        for item_1660 in var_1658 {
            {
                let mut object_1661 = array_1659.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_details(&mut object_1661, item_1660);
                object_1661.finish();
            }
        }
        array_1659.finish();
    }
    if let Some(var_1662) = &input.cpu {
        object.key("Cpu").string(var_1662);
    }
    if let Some(var_1663) = &input.execution_role_arn {
        object.key("ExecutionRoleArn").string(var_1663);
    }
    if let Some(var_1664) = &input.family {
        object.key("Family").string(var_1664);
    }
    if let Some(var_1665) = &input.inference_accelerators {
        let mut array_1666 = object.key("InferenceAccelerators").start_array();
        for item_1667 in var_1665 {
            {
                let mut object_1668 = array_1666.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_inference_accelerators_details(&mut object_1668, item_1667);
                object_1668.finish();
            }
        }
        array_1666.finish();
    }
    if let Some(var_1669) = &input.ipc_mode {
        object.key("IpcMode").string(var_1669);
    }
    if let Some(var_1670) = &input.memory {
        object.key("Memory").string(var_1670);
    }
    if let Some(var_1671) = &input.network_mode {
        object.key("NetworkMode").string(var_1671);
    }
    if let Some(var_1672) = &input.pid_mode {
        object.key("PidMode").string(var_1672);
    }
    if let Some(var_1673) = &input.placement_constraints {
        let mut array_1674 = object.key("PlacementConstraints").start_array();
        for item_1675 in var_1673 {
            {
                let mut object_1676 = array_1674.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_placement_constraints_details(&mut object_1676, item_1675);
                object_1676.finish();
            }
        }
        array_1674.finish();
    }
    if let Some(var_1677) = &input.proxy_configuration {
        let mut object_1678 = object.key("ProxyConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_proxy_configuration_details(&mut object_1678, var_1677);
        object_1678.finish();
    }
    if let Some(var_1679) = &input.requires_compatibilities {
        let mut array_1680 = object.key("RequiresCompatibilities").start_array();
        for item_1681 in var_1679 {
            {
                array_1680.value().string(item_1681);
            }
        }
        array_1680.finish();
    }
    if let Some(var_1682) = &input.task_role_arn {
        object.key("TaskRoleArn").string(var_1682);
    }
    if let Some(var_1683) = &input.volumes {
        let mut array_1684 = object.key("Volumes").start_array();
        for item_1685 in var_1683 {
            {
                let mut object_1686 = array_1684.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_volumes_details(&mut object_1686, item_1685);
                object_1686.finish();
            }
        }
        array_1684.finish();
    }
}

pub fn serialize_structure_crate_model_container_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ContainerDetails,
) {
    if let Some(var_1687) = &input.name {
        object.key("Name").string(var_1687);
    }
    if let Some(var_1688) = &input.image_id {
        object.key("ImageId").string(var_1688);
    }
    if let Some(var_1689) = &input.image_name {
        object.key("ImageName").string(var_1689);
    }
    if let Some(var_1690) = &input.launched_at {
        object.key("LaunchedAt").string(var_1690);
    }
}

pub fn serialize_structure_crate_model_aws_rds_event_subscription_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsEventSubscriptionDetails,
) {
    if let Some(var_1691) = &input.cust_subscription_id {
        object.key("CustSubscriptionId").string(var_1691);
    }
    if let Some(var_1692) = &input.customer_aws_id {
        object.key("CustomerAwsId").string(var_1692);
    }
    if input.enabled {
        object.key("Enabled").boolean(input.enabled);
    }
    if let Some(var_1693) = &input.event_categories_list {
        let mut array_1694 = object.key("EventCategoriesList").start_array();
        for item_1695 in var_1693 {
            {
                array_1694.value().string(item_1695);
            }
        }
        array_1694.finish();
    }
    if let Some(var_1696) = &input.event_subscription_arn {
        object.key("EventSubscriptionArn").string(var_1696);
    }
    if let Some(var_1697) = &input.sns_topic_arn {
        object.key("SnsTopicArn").string(var_1697);
    }
    if let Some(var_1698) = &input.source_ids_list {
        let mut array_1699 = object.key("SourceIdsList").start_array();
        for item_1700 in var_1698 {
            {
                array_1699.value().string(item_1700);
            }
        }
        array_1699.finish();
    }
    if let Some(var_1701) = &input.source_type {
        object.key("SourceType").string(var_1701);
    }
    if let Some(var_1702) = &input.status {
        object.key("Status").string(var_1702);
    }
    if let Some(var_1703) = &input.subscription_creation_time {
        object.key("SubscriptionCreationTime").string(var_1703);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_service_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsServiceDetails,
) {
    if let Some(var_1704) = &input.capacity_provider_strategy {
        let mut array_1705 = object.key("CapacityProviderStrategy").start_array();
        for item_1706 in var_1704 {
            {
                let mut object_1707 = array_1705.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_service_capacity_provider_strategy_details(&mut object_1707, item_1706);
                object_1707.finish();
            }
        }
        array_1705.finish();
    }
    if let Some(var_1708) = &input.cluster {
        object.key("Cluster").string(var_1708);
    }
    if let Some(var_1709) = &input.deployment_configuration {
        let mut object_1710 = object.key("DeploymentConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_service_deployment_configuration_details(&mut object_1710, var_1709);
        object_1710.finish();
    }
    if let Some(var_1711) = &input.deployment_controller {
        let mut object_1712 = object.key("DeploymentController").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_service_deployment_controller_details(&mut object_1712, var_1711);
        object_1712.finish();
    }
    if input.desired_count != 0 {
        object.key("DesiredCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.desired_count).into()),
        );
    }
    if input.enable_ecs_managed_tags {
        object
            .key("EnableEcsManagedTags")
            .boolean(input.enable_ecs_managed_tags);
    }
    if input.enable_execute_command {
        object
            .key("EnableExecuteCommand")
            .boolean(input.enable_execute_command);
    }
    if input.health_check_grace_period_seconds != 0 {
        object.key("HealthCheckGracePeriodSeconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.health_check_grace_period_seconds).into()),
        );
    }
    if let Some(var_1713) = &input.launch_type {
        object.key("LaunchType").string(var_1713);
    }
    if let Some(var_1714) = &input.load_balancers {
        let mut array_1715 = object.key("LoadBalancers").start_array();
        for item_1716 in var_1714 {
            {
                let mut object_1717 = array_1715.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_service_load_balancers_details(&mut object_1717, item_1716);
                object_1717.finish();
            }
        }
        array_1715.finish();
    }
    if let Some(var_1718) = &input.name {
        object.key("Name").string(var_1718);
    }
    if let Some(var_1719) = &input.network_configuration {
        let mut object_1720 = object.key("NetworkConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_service_network_configuration_details(&mut object_1720, var_1719);
        object_1720.finish();
    }
    if let Some(var_1721) = &input.placement_constraints {
        let mut array_1722 = object.key("PlacementConstraints").start_array();
        for item_1723 in var_1721 {
            {
                let mut object_1724 = array_1722.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_service_placement_constraints_details(&mut object_1724, item_1723);
                object_1724.finish();
            }
        }
        array_1722.finish();
    }
    if let Some(var_1725) = &input.placement_strategies {
        let mut array_1726 = object.key("PlacementStrategies").start_array();
        for item_1727 in var_1725 {
            {
                let mut object_1728 = array_1726.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_service_placement_strategies_details(&mut object_1728, item_1727);
                object_1728.finish();
            }
        }
        array_1726.finish();
    }
    if let Some(var_1729) = &input.platform_version {
        object.key("PlatformVersion").string(var_1729);
    }
    if let Some(var_1730) = &input.propagate_tags {
        object.key("PropagateTags").string(var_1730);
    }
    if let Some(var_1731) = &input.role {
        object.key("Role").string(var_1731);
    }
    if let Some(var_1732) = &input.scheduling_strategy {
        object.key("SchedulingStrategy").string(var_1732);
    }
    if let Some(var_1733) = &input.service_arn {
        object.key("ServiceArn").string(var_1733);
    }
    if let Some(var_1734) = &input.service_name {
        object.key("ServiceName").string(var_1734);
    }
    if let Some(var_1735) = &input.service_registries {
        let mut array_1736 = object.key("ServiceRegistries").start_array();
        for item_1737 in var_1735 {
            {
                let mut object_1738 = array_1736.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_service_service_registries_details(&mut object_1738, item_1737);
                object_1738.finish();
            }
        }
        array_1736.finish();
    }
    if let Some(var_1739) = &input.task_definition {
        object.key("TaskDefinition").string(var_1739);
    }
}

pub fn serialize_structure_crate_model_aws_auto_scaling_launch_configuration_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsAutoScalingLaunchConfigurationDetails,
) {
    if input.associate_public_ip_address {
        object
            .key("AssociatePublicIpAddress")
            .boolean(input.associate_public_ip_address);
    }
    if let Some(var_1740) = &input.block_device_mappings {
        let mut array_1741 = object.key("BlockDeviceMappings").start_array();
        for item_1742 in var_1740 {
            {
                let mut object_1743 = array_1741.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_auto_scaling_launch_configuration_block_device_mappings_details(&mut object_1743, item_1742);
                object_1743.finish();
            }
        }
        array_1741.finish();
    }
    if let Some(var_1744) = &input.classic_link_vpc_id {
        object.key("ClassicLinkVpcId").string(var_1744);
    }
    if let Some(var_1745) = &input.classic_link_vpc_security_groups {
        let mut array_1746 = object.key("ClassicLinkVpcSecurityGroups").start_array();
        for item_1747 in var_1745 {
            {
                array_1746.value().string(item_1747);
            }
        }
        array_1746.finish();
    }
    if let Some(var_1748) = &input.created_time {
        object.key("CreatedTime").string(var_1748);
    }
    if input.ebs_optimized {
        object.key("EbsOptimized").boolean(input.ebs_optimized);
    }
    if let Some(var_1749) = &input.iam_instance_profile {
        object.key("IamInstanceProfile").string(var_1749);
    }
    if let Some(var_1750) = &input.image_id {
        object.key("ImageId").string(var_1750);
    }
    if let Some(var_1751) = &input.instance_monitoring {
        let mut object_1752 = object.key("InstanceMonitoring").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_auto_scaling_launch_configuration_instance_monitoring_details(&mut object_1752, var_1751);
        object_1752.finish();
    }
    if let Some(var_1753) = &input.instance_type {
        object.key("InstanceType").string(var_1753);
    }
    if let Some(var_1754) = &input.kernel_id {
        object.key("KernelId").string(var_1754);
    }
    if let Some(var_1755) = &input.key_name {
        object.key("KeyName").string(var_1755);
    }
    if let Some(var_1756) = &input.launch_configuration_name {
        object.key("LaunchConfigurationName").string(var_1756);
    }
    if let Some(var_1757) = &input.placement_tenancy {
        object.key("PlacementTenancy").string(var_1757);
    }
    if let Some(var_1758) = &input.ramdisk_id {
        object.key("RamdiskId").string(var_1758);
    }
    if let Some(var_1759) = &input.security_groups {
        let mut array_1760 = object.key("SecurityGroups").start_array();
        for item_1761 in var_1759 {
            {
                array_1760.value().string(item_1761);
            }
        }
        array_1760.finish();
    }
    if let Some(var_1762) = &input.spot_price {
        object.key("SpotPrice").string(var_1762);
    }
    if let Some(var_1763) = &input.user_data {
        object.key("UserData").string(var_1763);
    }
}

pub fn serialize_structure_crate_model_aws_ec2_vpn_connection_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2VpnConnectionDetails,
) {
    if let Some(var_1764) = &input.vpn_connection_id {
        object.key("VpnConnectionId").string(var_1764);
    }
    if let Some(var_1765) = &input.state {
        object.key("State").string(var_1765);
    }
    if let Some(var_1766) = &input.customer_gateway_id {
        object.key("CustomerGatewayId").string(var_1766);
    }
    if let Some(var_1767) = &input.customer_gateway_configuration {
        object.key("CustomerGatewayConfiguration").string(var_1767);
    }
    if let Some(var_1768) = &input.r#type {
        object.key("Type").string(var_1768);
    }
    if let Some(var_1769) = &input.vpn_gateway_id {
        object.key("VpnGatewayId").string(var_1769);
    }
    if let Some(var_1770) = &input.category {
        object.key("Category").string(var_1770);
    }
    if let Some(var_1771) = &input.vgw_telemetry {
        let mut array_1772 = object.key("VgwTelemetry").start_array();
        for item_1773 in var_1771 {
            {
                let mut object_1774 = array_1772.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ec2_vpn_connection_vgw_telemetry_details(&mut object_1774, item_1773);
                object_1774.finish();
            }
        }
        array_1772.finish();
    }
    if let Some(var_1775) = &input.options {
        let mut object_1776 = object.key("Options").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ec2_vpn_connection_options_details(
            &mut object_1776,
            var_1775,
        );
        object_1776.finish();
    }
    if let Some(var_1777) = &input.routes {
        let mut array_1778 = object.key("Routes").start_array();
        for item_1779 in var_1777 {
            {
                let mut object_1780 = array_1778.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ec2_vpn_connection_routes_details(&mut object_1780, item_1779);
                object_1780.finish();
            }
        }
        array_1778.finish();
    }
    if let Some(var_1781) = &input.transit_gateway_id {
        object.key("TransitGatewayId").string(var_1781);
    }
}

pub fn serialize_structure_crate_model_aws_ecr_container_image_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcrContainerImageDetails,
) {
    if let Some(var_1782) = &input.registry_id {
        object.key("RegistryId").string(var_1782);
    }
    if let Some(var_1783) = &input.repository_name {
        object.key("RepositoryName").string(var_1783);
    }
    if let Some(var_1784) = &input.architecture {
        object.key("Architecture").string(var_1784);
    }
    if let Some(var_1785) = &input.image_digest {
        object.key("ImageDigest").string(var_1785);
    }
    if let Some(var_1786) = &input.image_tags {
        let mut array_1787 = object.key("ImageTags").start_array();
        for item_1788 in var_1786 {
            {
                array_1787.value().string(item_1788);
            }
        }
        array_1787.finish();
    }
    if let Some(var_1789) = &input.image_published_at {
        object.key("ImagePublishedAt").string(var_1789);
    }
}

pub fn serialize_structure_crate_model_aws_open_search_service_domain_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsOpenSearchServiceDomainDetails,
) {
    if let Some(var_1790) = &input.arn {
        object.key("Arn").string(var_1790);
    }
    if let Some(var_1791) = &input.access_policies {
        object.key("AccessPolicies").string(var_1791);
    }
    if let Some(var_1792) = &input.domain_name {
        object.key("DomainName").string(var_1792);
    }
    if let Some(var_1793) = &input.id {
        object.key("Id").string(var_1793);
    }
    if let Some(var_1794) = &input.domain_endpoint {
        object.key("DomainEndpoint").string(var_1794);
    }
    if let Some(var_1795) = &input.engine_version {
        object.key("EngineVersion").string(var_1795);
    }
    if let Some(var_1796) = &input.encryption_at_rest_options {
        let mut object_1797 = object.key("EncryptionAtRestOptions").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_encryption_at_rest_options_details(&mut object_1797, var_1796);
        object_1797.finish();
    }
    if let Some(var_1798) = &input.node_to_node_encryption_options {
        let mut object_1799 = object.key("NodeToNodeEncryptionOptions").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_node_to_node_encryption_options_details(&mut object_1799, var_1798);
        object_1799.finish();
    }
    if let Some(var_1800) = &input.service_software_options {
        let mut object_1801 = object.key("ServiceSoftwareOptions").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_service_software_options_details(&mut object_1801, var_1800);
        object_1801.finish();
    }
    if let Some(var_1802) = &input.cluster_config {
        let mut object_1803 = object.key("ClusterConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_cluster_config_details(&mut object_1803, var_1802);
        object_1803.finish();
    }
    if let Some(var_1804) = &input.domain_endpoint_options {
        let mut object_1805 = object.key("DomainEndpointOptions").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_domain_endpoint_options_details(&mut object_1805, var_1804);
        object_1805.finish();
    }
    if let Some(var_1806) = &input.vpc_options {
        let mut object_1807 = object.key("VpcOptions").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_vpc_options_details(&mut object_1807, var_1806);
        object_1807.finish();
    }
    if let Some(var_1808) = &input.log_publishing_options {
        let mut object_1809 = object.key("LogPublishingOptions").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_log_publishing_options_details(&mut object_1809, var_1808);
        object_1809.finish();
    }
    if let Some(var_1810) = &input.domain_endpoints {
        let mut object_1811 = object.key("DomainEndpoints").start_object();
        for (key_1812, value_1813) in var_1810 {
            {
                object_1811.key(key_1812).string(value_1813);
            }
        }
        object_1811.finish();
    }
}

pub fn serialize_structure_crate_model_aws_ec2_vpc_endpoint_service_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2VpcEndpointServiceDetails,
) {
    if input.acceptance_required {
        object
            .key("AcceptanceRequired")
            .boolean(input.acceptance_required);
    }
    if let Some(var_1814) = &input.availability_zones {
        let mut array_1815 = object.key("AvailabilityZones").start_array();
        for item_1816 in var_1814 {
            {
                array_1815.value().string(item_1816);
            }
        }
        array_1815.finish();
    }
    if let Some(var_1817) = &input.base_endpoint_dns_names {
        let mut array_1818 = object.key("BaseEndpointDnsNames").start_array();
        for item_1819 in var_1817 {
            {
                array_1818.value().string(item_1819);
            }
        }
        array_1818.finish();
    }
    if input.manages_vpc_endpoints {
        object
            .key("ManagesVpcEndpoints")
            .boolean(input.manages_vpc_endpoints);
    }
    if let Some(var_1820) = &input.gateway_load_balancer_arns {
        let mut array_1821 = object.key("GatewayLoadBalancerArns").start_array();
        for item_1822 in var_1820 {
            {
                array_1821.value().string(item_1822);
            }
        }
        array_1821.finish();
    }
    if let Some(var_1823) = &input.network_load_balancer_arns {
        let mut array_1824 = object.key("NetworkLoadBalancerArns").start_array();
        for item_1825 in var_1823 {
            {
                array_1824.value().string(item_1825);
            }
        }
        array_1824.finish();
    }
    if let Some(var_1826) = &input.private_dns_name {
        object.key("PrivateDnsName").string(var_1826);
    }
    if let Some(var_1827) = &input.service_id {
        object.key("ServiceId").string(var_1827);
    }
    if let Some(var_1828) = &input.service_name {
        object.key("ServiceName").string(var_1828);
    }
    if let Some(var_1829) = &input.service_state {
        object.key("ServiceState").string(var_1829);
    }
    if let Some(var_1830) = &input.service_type {
        let mut array_1831 = object.key("ServiceType").start_array();
        for item_1832 in var_1830 {
            {
                let mut object_1833 = array_1831.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ec2_vpc_endpoint_service_service_type_details(&mut object_1833, item_1832);
                object_1833.finish();
            }
        }
        array_1831.finish();
    }
}

pub fn serialize_structure_crate_model_aws_xray_encryption_config_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsXrayEncryptionConfigDetails,
) {
    if let Some(var_1834) = &input.key_id {
        object.key("KeyId").string(var_1834);
    }
    if let Some(var_1835) = &input.status {
        object.key("Status").string(var_1835);
    }
    if let Some(var_1836) = &input.r#type {
        object.key("Type").string(var_1836);
    }
}

pub fn serialize_structure_crate_model_aws_waf_rate_based_rule_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsWafRateBasedRuleDetails,
) {
    if let Some(var_1837) = &input.metric_name {
        object.key("MetricName").string(var_1837);
    }
    if let Some(var_1838) = &input.name {
        object.key("Name").string(var_1838);
    }
    if let Some(var_1839) = &input.rate_key {
        object.key("RateKey").string(var_1839);
    }
    if input.rate_limit != 0 {
        object.key("RateLimit").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.rate_limit).into()),
        );
    }
    if let Some(var_1840) = &input.rule_id {
        object.key("RuleId").string(var_1840);
    }
    if let Some(var_1841) = &input.match_predicates {
        let mut array_1842 = object.key("MatchPredicates").start_array();
        for item_1843 in var_1841 {
            {
                let mut object_1844 = array_1842.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_waf_rate_based_rule_match_predicate(&mut object_1844, item_1843);
                object_1844.finish();
            }
        }
        array_1842.finish();
    }
}

pub fn serialize_structure_crate_model_aws_waf_regional_rate_based_rule_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsWafRegionalRateBasedRuleDetails,
) {
    if let Some(var_1845) = &input.metric_name {
        object.key("MetricName").string(var_1845);
    }
    if let Some(var_1846) = &input.name {
        object.key("Name").string(var_1846);
    }
    if let Some(var_1847) = &input.rate_key {
        object.key("RateKey").string(var_1847);
    }
    if input.rate_limit != 0 {
        object.key("RateLimit").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.rate_limit).into()),
        );
    }
    if let Some(var_1848) = &input.rule_id {
        object.key("RuleId").string(var_1848);
    }
    if let Some(var_1849) = &input.match_predicates {
        let mut array_1850 = object.key("MatchPredicates").start_array();
        for item_1851 in var_1849 {
            {
                let mut object_1852 = array_1850.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_waf_regional_rate_based_rule_match_predicate(&mut object_1852, item_1851);
                object_1852.finish();
            }
        }
        array_1850.finish();
    }
}

pub fn serialize_structure_crate_model_aws_ecr_repository_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcrRepositoryDetails,
) {
    if let Some(var_1853) = &input.arn {
        object.key("Arn").string(var_1853);
    }
    if let Some(var_1854) = &input.image_scanning_configuration {
        let mut object_1855 = object.key("ImageScanningConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecr_repository_image_scanning_configuration_details(&mut object_1855, var_1854);
        object_1855.finish();
    }
    if let Some(var_1856) = &input.image_tag_mutability {
        object.key("ImageTagMutability").string(var_1856);
    }
    if let Some(var_1857) = &input.lifecycle_policy {
        let mut object_1858 = object.key("LifecyclePolicy").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecr_repository_lifecycle_policy_details(&mut object_1858, var_1857);
        object_1858.finish();
    }
    if let Some(var_1859) = &input.repository_name {
        object.key("RepositoryName").string(var_1859);
    }
    if let Some(var_1860) = &input.repository_policy_text {
        object.key("RepositoryPolicyText").string(var_1860);
    }
}

pub fn serialize_structure_crate_model_aws_eks_cluster_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEksClusterDetails,
) {
    if let Some(var_1861) = &input.arn {
        object.key("Arn").string(var_1861);
    }
    if let Some(var_1862) = &input.certificate_authority_data {
        object.key("CertificateAuthorityData").string(var_1862);
    }
    if let Some(var_1863) = &input.cluster_status {
        object.key("ClusterStatus").string(var_1863);
    }
    if let Some(var_1864) = &input.endpoint {
        object.key("Endpoint").string(var_1864);
    }
    if let Some(var_1865) = &input.name {
        object.key("Name").string(var_1865);
    }
    if let Some(var_1866) = &input.resources_vpc_config {
        let mut object_1867 = object.key("ResourcesVpcConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_eks_cluster_resources_vpc_config_details(&mut object_1867, var_1866);
        object_1867.finish();
    }
    if let Some(var_1868) = &input.role_arn {
        object.key("RoleArn").string(var_1868);
    }
    if let Some(var_1869) = &input.version {
        object.key("Version").string(var_1869);
    }
    if let Some(var_1870) = &input.logging {
        let mut object_1871 = object.key("Logging").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_eks_cluster_logging_details(
            &mut object_1871,
            var_1870,
        );
        object_1871.finish();
    }
}

pub fn serialize_structure_crate_model_adjustment(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Adjustment,
) {
    if let Some(var_1872) = &input.metric {
        object.key("Metric").string(var_1872);
    }
    if let Some(var_1873) = &input.reason {
        object.key("Reason").string(var_1873);
    }
}

pub fn serialize_structure_crate_model_action_remote_ip_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ActionRemoteIpDetails,
) {
    if let Some(var_1874) = &input.ip_address_v4 {
        object.key("IpAddressV4").string(var_1874);
    }
    if let Some(var_1875) = &input.organization {
        let mut object_1876 = object.key("Organization").start_object();
        crate::json_ser::serialize_structure_crate_model_ip_organization_details(
            &mut object_1876,
            var_1875,
        );
        object_1876.finish();
    }
    if let Some(var_1877) = &input.country {
        let mut object_1878 = object.key("Country").start_object();
        crate::json_ser::serialize_structure_crate_model_country(&mut object_1878, var_1877);
        object_1878.finish();
    }
    if let Some(var_1879) = &input.city {
        let mut object_1880 = object.key("City").start_object();
        crate::json_ser::serialize_structure_crate_model_city(&mut object_1880, var_1879);
        object_1880.finish();
    }
    if let Some(var_1881) = &input.geo_location {
        let mut object_1882 = object.key("GeoLocation").start_object();
        crate::json_ser::serialize_structure_crate_model_geo_location(&mut object_1882, var_1881);
        object_1882.finish();
    }
}

pub fn serialize_structure_crate_model_action_remote_port_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ActionRemotePortDetails,
) {
    if input.port != 0 {
        object.key("Port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.port).into()),
        );
    }
    if let Some(var_1883) = &input.port_name {
        object.key("PortName").string(var_1883);
    }
}

pub fn serialize_structure_crate_model_action_local_port_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ActionLocalPortDetails,
) {
    if input.port != 0 {
        object.key("Port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.port).into()),
        );
    }
    if let Some(var_1884) = &input.port_name {
        object.key("PortName").string(var_1884);
    }
}

pub fn serialize_structure_crate_model_aws_api_call_action_domain_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsApiCallActionDomainDetails,
) {
    if let Some(var_1885) = &input.domain {
        object.key("Domain").string(var_1885);
    }
}

pub fn serialize_structure_crate_model_port_probe_detail(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::PortProbeDetail,
) {
    if let Some(var_1886) = &input.local_port_details {
        let mut object_1887 = object.key("LocalPortDetails").start_object();
        crate::json_ser::serialize_structure_crate_model_action_local_port_details(
            &mut object_1887,
            var_1886,
        );
        object_1887.finish();
    }
    if let Some(var_1888) = &input.local_ip_details {
        let mut object_1889 = object.key("LocalIpDetails").start_object();
        crate::json_ser::serialize_structure_crate_model_action_local_ip_details(
            &mut object_1889,
            var_1888,
        );
        object_1889.finish();
    }
    if let Some(var_1890) = &input.remote_ip_details {
        let mut object_1891 = object.key("RemoteIpDetails").start_object();
        crate::json_ser::serialize_structure_crate_model_action_remote_ip_details(
            &mut object_1891,
            var_1890,
        );
        object_1891.finish();
    }
}

pub fn serialize_structure_crate_model_classification_status(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ClassificationStatus,
) {
    if let Some(var_1892) = &input.code {
        object.key("Code").string(var_1892);
    }
    if let Some(var_1893) = &input.reason {
        object.key("Reason").string(var_1893);
    }
}

pub fn serialize_structure_crate_model_sensitive_data_result(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SensitiveDataResult,
) {
    if let Some(var_1894) = &input.category {
        object.key("Category").string(var_1894);
    }
    if let Some(var_1895) = &input.detections {
        let mut array_1896 = object.key("Detections").start_array();
        for item_1897 in var_1895 {
            {
                let mut object_1898 = array_1896.value().start_object();
                crate::json_ser::serialize_structure_crate_model_sensitive_data_detections(
                    &mut object_1898,
                    item_1897,
                );
                object_1898.finish();
            }
        }
        array_1896.finish();
    }
    if input.total_count != 0 {
        object.key("TotalCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.total_count).into()),
        );
    }
}

pub fn serialize_structure_crate_model_custom_data_identifiers_result(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CustomDataIdentifiersResult,
) {
    if let Some(var_1899) = &input.detections {
        let mut array_1900 = object.key("Detections").start_array();
        for item_1901 in var_1899 {
            {
                let mut object_1902 = array_1900.value().start_object();
                crate::json_ser::serialize_structure_crate_model_custom_data_identifiers_detections(
                    &mut object_1902,
                    item_1901,
                );
                object_1902.finish();
            }
        }
        array_1900.finish();
    }
    if input.total_count != 0 {
        object.key("TotalCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.total_count).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_code_build_project_artifacts_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCodeBuildProjectArtifactsDetails,
) {
    if let Some(var_1903) = &input.artifact_identifier {
        object.key("ArtifactIdentifier").string(var_1903);
    }
    if input.encryption_disabled {
        object
            .key("EncryptionDisabled")
            .boolean(input.encryption_disabled);
    }
    if let Some(var_1904) = &input.location {
        object.key("Location").string(var_1904);
    }
    if let Some(var_1905) = &input.name {
        object.key("Name").string(var_1905);
    }
    if let Some(var_1906) = &input.namespace_type {
        object.key("NamespaceType").string(var_1906);
    }
    if input.override_artifact_name {
        object
            .key("OverrideArtifactName")
            .boolean(input.override_artifact_name);
    }
    if let Some(var_1907) = &input.packaging {
        object.key("Packaging").string(var_1907);
    }
    if let Some(var_1908) = &input.path {
        object.key("Path").string(var_1908);
    }
    if let Some(var_1909) = &input.r#type {
        object.key("Type").string(var_1909);
    }
}

pub fn serialize_structure_crate_model_aws_code_build_project_environment(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCodeBuildProjectEnvironment,
) {
    if let Some(var_1910) = &input.certificate {
        object.key("Certificate").string(var_1910);
    }
    if let Some(var_1911) = &input.environment_variables {
        let mut array_1912 = object.key("EnvironmentVariables").start_array();
        for item_1913 in var_1911 {
            {
                let mut object_1914 = array_1912.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_code_build_project_environment_environment_variables_details(&mut object_1914, item_1913);
                object_1914.finish();
            }
        }
        array_1912.finish();
    }
    if input.privileged_mode {
        object.key("PrivilegedMode").boolean(input.privileged_mode);
    }
    if let Some(var_1915) = &input.image_pull_credentials_type {
        object.key("ImagePullCredentialsType").string(var_1915);
    }
    if let Some(var_1916) = &input.registry_credential {
        let mut object_1917 = object.key("RegistryCredential").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_code_build_project_environment_registry_credential(&mut object_1917, var_1916);
        object_1917.finish();
    }
    if let Some(var_1918) = &input.r#type {
        object.key("Type").string(var_1918);
    }
}

pub fn serialize_structure_crate_model_aws_code_build_project_source(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCodeBuildProjectSource,
) {
    if let Some(var_1919) = &input.r#type {
        object.key("Type").string(var_1919);
    }
    if let Some(var_1920) = &input.location {
        object.key("Location").string(var_1920);
    }
    if input.git_clone_depth != 0 {
        object.key("GitCloneDepth").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.git_clone_depth).into()),
        );
    }
    if input.insecure_ssl {
        object.key("InsecureSsl").boolean(input.insecure_ssl);
    }
}

pub fn serialize_structure_crate_model_aws_code_build_project_logs_config_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCodeBuildProjectLogsConfigDetails,
) {
    if let Some(var_1921) = &input.cloud_watch_logs {
        let mut object_1922 = object.key("CloudWatchLogs").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_code_build_project_logs_config_cloud_watch_logs_details(&mut object_1922, var_1921);
        object_1922.finish();
    }
    if let Some(var_1923) = &input.s3_logs {
        let mut object_1924 = object.key("S3Logs").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_code_build_project_logs_config_s3_logs_details(&mut object_1924, var_1923);
        object_1924.finish();
    }
}

pub fn serialize_structure_crate_model_aws_code_build_project_vpc_config(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCodeBuildProjectVpcConfig,
) {
    if let Some(var_1925) = &input.vpc_id {
        object.key("VpcId").string(var_1925);
    }
    if let Some(var_1926) = &input.subnets {
        let mut array_1927 = object.key("Subnets").start_array();
        for item_1928 in var_1926 {
            {
                array_1927.value().string(item_1928);
            }
        }
        array_1927.finish();
    }
    if let Some(var_1929) = &input.security_group_ids {
        let mut array_1930 = object.key("SecurityGroupIds").start_array();
        for item_1931 in var_1929 {
            {
                array_1930.value().string(item_1931);
            }
        }
        array_1930.finish();
    }
}

pub fn serialize_structure_crate_model_aws_cloud_front_distribution_cache_behaviors(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCloudFrontDistributionCacheBehaviors,
) {
    if let Some(var_1932) = &input.items {
        let mut array_1933 = object.key("Items").start_array();
        for item_1934 in var_1932 {
            {
                let mut object_1935 = array_1933.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_cache_behavior(&mut object_1935, item_1934);
                object_1935.finish();
            }
        }
        array_1933.finish();
    }
}

pub fn serialize_structure_crate_model_aws_cloud_front_distribution_default_cache_behavior(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCloudFrontDistributionDefaultCacheBehavior,
) {
    if let Some(var_1936) = &input.viewer_protocol_policy {
        object.key("ViewerProtocolPolicy").string(var_1936);
    }
}

pub fn serialize_structure_crate_model_aws_cloud_front_distribution_logging(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCloudFrontDistributionLogging,
) {
    if let Some(var_1937) = &input.bucket {
        object.key("Bucket").string(var_1937);
    }
    if input.enabled {
        object.key("Enabled").boolean(input.enabled);
    }
    if input.include_cookies {
        object.key("IncludeCookies").boolean(input.include_cookies);
    }
    if let Some(var_1938) = &input.prefix {
        object.key("Prefix").string(var_1938);
    }
}

pub fn serialize_structure_crate_model_aws_cloud_front_distribution_origins(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCloudFrontDistributionOrigins,
) {
    if let Some(var_1939) = &input.items {
        let mut array_1940 = object.key("Items").start_array();
        for item_1941 in var_1939 {
            {
                let mut object_1942 = array_1940.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_origin_item(&mut object_1942, item_1941);
                object_1942.finish();
            }
        }
        array_1940.finish();
    }
}

pub fn serialize_structure_crate_model_aws_cloud_front_distribution_origin_groups(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCloudFrontDistributionOriginGroups,
) {
    if let Some(var_1943) = &input.items {
        let mut array_1944 = object.key("Items").start_array();
        for item_1945 in var_1943 {
            {
                let mut object_1946 = array_1944.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_origin_group(&mut object_1946, item_1945);
                object_1946.finish();
            }
        }
        array_1944.finish();
    }
}

pub fn serialize_structure_crate_model_aws_cloud_front_distribution_viewer_certificate(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCloudFrontDistributionViewerCertificate,
) {
    if let Some(var_1947) = &input.acm_certificate_arn {
        object.key("AcmCertificateArn").string(var_1947);
    }
    if let Some(var_1948) = &input.certificate {
        object.key("Certificate").string(var_1948);
    }
    if let Some(var_1949) = &input.certificate_source {
        object.key("CertificateSource").string(var_1949);
    }
    if input.cloud_front_default_certificate {
        object
            .key("CloudFrontDefaultCertificate")
            .boolean(input.cloud_front_default_certificate);
    }
    if let Some(var_1950) = &input.iam_certificate_id {
        object.key("IamCertificateId").string(var_1950);
    }
    if let Some(var_1951) = &input.minimum_protocol_version {
        object.key("MinimumProtocolVersion").string(var_1951);
    }
    if let Some(var_1952) = &input.ssl_support_method {
        object.key("SslSupportMethod").string(var_1952);
    }
}

pub fn serialize_structure_crate_model_aws_ec2_instance_network_interfaces_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2InstanceNetworkInterfacesDetails,
) {
    if let Some(var_1953) = &input.network_interface_id {
        object.key("NetworkInterfaceId").string(var_1953);
    }
}

pub fn serialize_structure_crate_model_aws_ec2_network_interface_attachment(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2NetworkInterfaceAttachment,
) {
    if let Some(var_1954) = &input.attach_time {
        object.key("AttachTime").string(var_1954);
    }
    if let Some(var_1955) = &input.attachment_id {
        object.key("AttachmentId").string(var_1955);
    }
    if input.delete_on_termination {
        object
            .key("DeleteOnTermination")
            .boolean(input.delete_on_termination);
    }
    if input.device_index != 0 {
        object.key("DeviceIndex").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.device_index).into()),
        );
    }
    if let Some(var_1956) = &input.instance_id {
        object.key("InstanceId").string(var_1956);
    }
    if let Some(var_1957) = &input.instance_owner_id {
        object.key("InstanceOwnerId").string(var_1957);
    }
    if let Some(var_1958) = &input.status {
        object.key("Status").string(var_1958);
    }
}

pub fn serialize_structure_crate_model_aws_ec2_network_interface_security_group(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2NetworkInterfaceSecurityGroup,
) {
    if let Some(var_1959) = &input.group_name {
        object.key("GroupName").string(var_1959);
    }
    if let Some(var_1960) = &input.group_id {
        object.key("GroupId").string(var_1960);
    }
}

pub fn serialize_structure_crate_model_aws_ec2_network_interface_ip_v6_address_detail(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2NetworkInterfaceIpV6AddressDetail,
) {
    if let Some(var_1961) = &input.ip_v6_address {
        object.key("IpV6Address").string(var_1961);
    }
}

pub fn serialize_structure_crate_model_aws_ec2_network_interface_private_ip_address_detail(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2NetworkInterfacePrivateIpAddressDetail,
) {
    if let Some(var_1962) = &input.private_ip_address {
        object.key("PrivateIpAddress").string(var_1962);
    }
    if let Some(var_1963) = &input.private_dns_name {
        object.key("PrivateDnsName").string(var_1963);
    }
}

pub fn serialize_structure_crate_model_aws_ec2_security_group_ip_permission(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2SecurityGroupIpPermission,
) {
    if let Some(var_1964) = &input.ip_protocol {
        object.key("IpProtocol").string(var_1964);
    }
    if input.from_port != 0 {
        object.key("FromPort").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.from_port).into()),
        );
    }
    if input.to_port != 0 {
        object.key("ToPort").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.to_port).into()),
        );
    }
    if let Some(var_1965) = &input.user_id_group_pairs {
        let mut array_1966 = object.key("UserIdGroupPairs").start_array();
        for item_1967 in var_1965 {
            {
                let mut object_1968 = array_1966.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ec2_security_group_user_id_group_pair(&mut object_1968, item_1967);
                object_1968.finish();
            }
        }
        array_1966.finish();
    }
    if let Some(var_1969) = &input.ip_ranges {
        let mut array_1970 = object.key("IpRanges").start_array();
        for item_1971 in var_1969 {
            {
                let mut object_1972 = array_1970.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ec2_security_group_ip_range(
                    &mut object_1972,
                    item_1971,
                );
                object_1972.finish();
            }
        }
        array_1970.finish();
    }
    if let Some(var_1973) = &input.ipv6_ranges {
        let mut array_1974 = object.key("Ipv6Ranges").start_array();
        for item_1975 in var_1973 {
            {
                let mut object_1976 = array_1974.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ec2_security_group_ipv6_range(
                    &mut object_1976,
                    item_1975,
                );
                object_1976.finish();
            }
        }
        array_1974.finish();
    }
    if let Some(var_1977) = &input.prefix_list_ids {
        let mut array_1978 = object.key("PrefixListIds").start_array();
        for item_1979 in var_1977 {
            {
                let mut object_1980 = array_1978.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ec2_security_group_prefix_list_id(&mut object_1980, item_1979);
                object_1980.finish();
            }
        }
        array_1978.finish();
    }
}

pub fn serialize_structure_crate_model_aws_ec2_volume_attachment(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2VolumeAttachment,
) {
    if let Some(var_1981) = &input.attach_time {
        object.key("AttachTime").string(var_1981);
    }
    if input.delete_on_termination {
        object
            .key("DeleteOnTermination")
            .boolean(input.delete_on_termination);
    }
    if let Some(var_1982) = &input.instance_id {
        object.key("InstanceId").string(var_1982);
    }
    if let Some(var_1983) = &input.status {
        object.key("Status").string(var_1983);
    }
}

pub fn serialize_structure_crate_model_cidr_block_association(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CidrBlockAssociation,
) {
    if let Some(var_1984) = &input.association_id {
        object.key("AssociationId").string(var_1984);
    }
    if let Some(var_1985) = &input.cidr_block {
        object.key("CidrBlock").string(var_1985);
    }
    if let Some(var_1986) = &input.cidr_block_state {
        object.key("CidrBlockState").string(var_1986);
    }
}

pub fn serialize_structure_crate_model_ipv6_cidr_block_association(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Ipv6CidrBlockAssociation,
) {
    if let Some(var_1987) = &input.association_id {
        object.key("AssociationId").string(var_1987);
    }
    if let Some(var_1988) = &input.ipv6_cidr_block {
        object.key("Ipv6CidrBlock").string(var_1988);
    }
    if let Some(var_1989) = &input.cidr_block_state {
        object.key("CidrBlockState").string(var_1989);
    }
}

pub fn serialize_structure_crate_model_aws_ec2_network_acl_association(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2NetworkAclAssociation,
) {
    if let Some(var_1990) = &input.network_acl_association_id {
        object.key("NetworkAclAssociationId").string(var_1990);
    }
    if let Some(var_1991) = &input.network_acl_id {
        object.key("NetworkAclId").string(var_1991);
    }
    if let Some(var_1992) = &input.subnet_id {
        object.key("SubnetId").string(var_1992);
    }
}

pub fn serialize_structure_crate_model_aws_ec2_network_acl_entry(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2NetworkAclEntry,
) {
    if let Some(var_1993) = &input.cidr_block {
        object.key("CidrBlock").string(var_1993);
    }
    if input.egress {
        object.key("Egress").boolean(input.egress);
    }
    if let Some(var_1994) = &input.icmp_type_code {
        let mut object_1995 = object.key("IcmpTypeCode").start_object();
        crate::json_ser::serialize_structure_crate_model_icmp_type_code(&mut object_1995, var_1994);
        object_1995.finish();
    }
    if let Some(var_1996) = &input.ipv6_cidr_block {
        object.key("Ipv6CidrBlock").string(var_1996);
    }
    if let Some(var_1997) = &input.port_range {
        let mut object_1998 = object.key("PortRange").start_object();
        crate::json_ser::serialize_structure_crate_model_port_range_from_to(
            &mut object_1998,
            var_1997,
        );
        object_1998.finish();
    }
    if let Some(var_1999) = &input.protocol {
        object.key("Protocol").string(var_1999);
    }
    if let Some(var_2000) = &input.rule_action {
        object.key("RuleAction").string(var_2000);
    }
    if input.rule_number != 0 {
        object.key("RuleNumber").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.rule_number).into()),
        );
    }
}

pub fn serialize_structure_crate_model_availability_zone(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AvailabilityZone,
) {
    if let Some(var_2001) = &input.zone_name {
        object.key("ZoneName").string(var_2001);
    }
    if let Some(var_2002) = &input.subnet_id {
        object.key("SubnetId").string(var_2002);
    }
}

pub fn serialize_structure_crate_model_load_balancer_state(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::LoadBalancerState,
) {
    if let Some(var_2003) = &input.code {
        object.key("Code").string(var_2003);
    }
    if let Some(var_2004) = &input.reason {
        object.key("Reason").string(var_2004);
    }
}

pub fn serialize_structure_crate_model_aws_elbv2_load_balancer_attribute(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElbv2LoadBalancerAttribute,
) {
    if let Some(var_2005) = &input.key {
        object.key("Key").string(var_2005);
    }
    if let Some(var_2006) = &input.value {
        object.key("Value").string(var_2006);
    }
}

pub fn serialize_structure_crate_model_aws_elastic_beanstalk_environment_environment_link(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElasticBeanstalkEnvironmentEnvironmentLink,
) {
    if let Some(var_2007) = &input.environment_name {
        object.key("EnvironmentName").string(var_2007);
    }
    if let Some(var_2008) = &input.link_name {
        object.key("LinkName").string(var_2008);
    }
}

pub fn serialize_structure_crate_model_aws_elastic_beanstalk_environment_option_setting(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElasticBeanstalkEnvironmentOptionSetting,
) {
    if let Some(var_2009) = &input.namespace {
        object.key("Namespace").string(var_2009);
    }
    if let Some(var_2010) = &input.option_name {
        object.key("OptionName").string(var_2010);
    }
    if let Some(var_2011) = &input.resource_name {
        object.key("ResourceName").string(var_2011);
    }
    if let Some(var_2012) = &input.value {
        object.key("Value").string(var_2012);
    }
}

pub fn serialize_structure_crate_model_aws_elastic_beanstalk_environment_tier(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElasticBeanstalkEnvironmentTier,
) {
    if let Some(var_2013) = &input.name {
        object.key("Name").string(var_2013);
    }
    if let Some(var_2014) = &input.r#type {
        object.key("Type").string(var_2014);
    }
    if let Some(var_2015) = &input.version {
        object.key("Version").string(var_2015);
    }
}

pub fn serialize_structure_crate_model_aws_elasticsearch_domain_domain_endpoint_options(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElasticsearchDomainDomainEndpointOptions,
) {
    if input.enforce_https {
        object.key("EnforceHTTPS").boolean(input.enforce_https);
    }
    if let Some(var_2016) = &input.tls_security_policy {
        object.key("TLSSecurityPolicy").string(var_2016);
    }
}

pub fn serialize_structure_crate_model_aws_elasticsearch_domain_elasticsearch_cluster_config_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElasticsearchDomainElasticsearchClusterConfigDetails,
) {
    if input.dedicated_master_count != 0 {
        object.key("DedicatedMasterCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.dedicated_master_count).into()),
        );
    }
    if input.dedicated_master_enabled {
        object
            .key("DedicatedMasterEnabled")
            .boolean(input.dedicated_master_enabled);
    }
    if let Some(var_2017) = &input.dedicated_master_type {
        object.key("DedicatedMasterType").string(var_2017);
    }
    if input.instance_count != 0 {
        object.key("InstanceCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.instance_count).into()),
        );
    }
    if let Some(var_2018) = &input.instance_type {
        object.key("InstanceType").string(var_2018);
    }
    if let Some(var_2019) = &input.zone_awareness_config {
        let mut object_2020 = object.key("ZoneAwarenessConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_elasticsearch_cluster_config_zone_awareness_config_details(&mut object_2020, var_2019);
        object_2020.finish();
    }
    if input.zone_awareness_enabled {
        object
            .key("ZoneAwarenessEnabled")
            .boolean(input.zone_awareness_enabled);
    }
}

pub fn serialize_structure_crate_model_aws_elasticsearch_domain_encryption_at_rest_options(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElasticsearchDomainEncryptionAtRestOptions,
) {
    if input.enabled {
        object.key("Enabled").boolean(input.enabled);
    }
    if let Some(var_2021) = &input.kms_key_id {
        object.key("KmsKeyId").string(var_2021);
    }
}

pub fn serialize_structure_crate_model_aws_elasticsearch_domain_log_publishing_options(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElasticsearchDomainLogPublishingOptions,
) {
    if let Some(var_2022) = &input.index_slow_logs {
        let mut object_2023 = object.key("IndexSlowLogs").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_log_publishing_options_log_config(&mut object_2023, var_2022);
        object_2023.finish();
    }
    if let Some(var_2024) = &input.search_slow_logs {
        let mut object_2025 = object.key("SearchSlowLogs").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_log_publishing_options_log_config(&mut object_2025, var_2024);
        object_2025.finish();
    }
    if let Some(var_2026) = &input.audit_logs {
        let mut object_2027 = object.key("AuditLogs").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elasticsearch_domain_log_publishing_options_log_config(&mut object_2027, var_2026);
        object_2027.finish();
    }
}

pub fn serialize_structure_crate_model_aws_elasticsearch_domain_node_to_node_encryption_options(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElasticsearchDomainNodeToNodeEncryptionOptions,
) {
    if input.enabled {
        object.key("Enabled").boolean(input.enabled);
    }
}

pub fn serialize_structure_crate_model_aws_elasticsearch_domain_service_software_options(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElasticsearchDomainServiceSoftwareOptions,
) {
    if let Some(var_2028) = &input.automated_update_date {
        object.key("AutomatedUpdateDate").string(var_2028);
    }
    if input.cancellable {
        object.key("Cancellable").boolean(input.cancellable);
    }
    if let Some(var_2029) = &input.current_version {
        object.key("CurrentVersion").string(var_2029);
    }
    if let Some(var_2030) = &input.description {
        object.key("Description").string(var_2030);
    }
    if let Some(var_2031) = &input.new_version {
        object.key("NewVersion").string(var_2031);
    }
    if input.update_available {
        object
            .key("UpdateAvailable")
            .boolean(input.update_available);
    }
    if let Some(var_2032) = &input.update_status {
        object.key("UpdateStatus").string(var_2032);
    }
}

pub fn serialize_structure_crate_model_aws_elasticsearch_domain_vpc_options(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElasticsearchDomainVpcOptions,
) {
    if let Some(var_2033) = &input.availability_zones {
        let mut array_2034 = object.key("AvailabilityZones").start_array();
        for item_2035 in var_2033 {
            {
                array_2034.value().string(item_2035);
            }
        }
        array_2034.finish();
    }
    if let Some(var_2036) = &input.security_group_ids {
        let mut array_2037 = object.key("SecurityGroupIds").start_array();
        for item_2038 in var_2036 {
            {
                array_2037.value().string(item_2038);
            }
        }
        array_2037.finish();
    }
    if let Some(var_2039) = &input.subnet_ids {
        let mut array_2040 = object.key("SubnetIds").start_array();
        for item_2041 in var_2039 {
            {
                array_2040.value().string(item_2041);
            }
        }
        array_2040.finish();
    }
    if let Some(var_2042) = &input.vpc_id {
        object.key("VPCId").string(var_2042);
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_server_side_encryption_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketServerSideEncryptionConfiguration,
) {
    if let Some(var_2043) = &input.rules {
        let mut array_2044 = object.key("Rules").start_array();
        for item_2045 in var_2043 {
            {
                let mut object_2046 = array_2044.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_server_side_encryption_rule(&mut object_2046, item_2045);
                object_2046.finish();
            }
        }
        array_2044.finish();
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketBucketLifecycleConfigurationDetails,
) {
    if let Some(var_2047) = &input.rules {
        let mut array_2048 = object.key("Rules").start_array();
        for item_2049 in var_2047 {
            {
                let mut object_2050 = array_2048.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_details(&mut object_2050, item_2049);
                object_2050.finish();
            }
        }
        array_2048.finish();
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_logging_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketLoggingConfiguration,
) {
    if let Some(var_2051) = &input.destination_bucket_name {
        object.key("DestinationBucketName").string(var_2051);
    }
    if let Some(var_2052) = &input.log_file_prefix {
        object.key("LogFilePrefix").string(var_2052);
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_website_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketWebsiteConfiguration,
) {
    if let Some(var_2053) = &input.error_document {
        object.key("ErrorDocument").string(var_2053);
    }
    if let Some(var_2054) = &input.index_document_suffix {
        object.key("IndexDocumentSuffix").string(var_2054);
    }
    if let Some(var_2055) = &input.redirect_all_requests_to {
        let mut object_2056 = object.key("RedirectAllRequestsTo").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_website_configuration_redirect_to(&mut object_2056, var_2055);
        object_2056.finish();
    }
    if let Some(var_2057) = &input.routing_rules {
        let mut array_2058 = object.key("RoutingRules").start_array();
        for item_2059 in var_2057 {
            {
                let mut object_2060 = array_2058.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_website_configuration_routing_rule(&mut object_2060, item_2059);
                object_2060.finish();
            }
        }
        array_2058.finish();
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_notification_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketNotificationConfiguration,
) {
    if let Some(var_2061) = &input.configurations {
        let mut array_2062 = object.key("Configurations").start_array();
        for item_2063 in var_2061 {
            {
                let mut object_2064 = array_2062.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_notification_configuration_detail(&mut object_2064, item_2063);
                object_2064.finish();
            }
        }
        array_2062.finish();
    }
}

pub fn serialize_structure_crate_model_aws_secrets_manager_secret_rotation_rules(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsSecretsManagerSecretRotationRules,
) {
    if input.automatically_after_days != 0 {
        object.key("AutomaticallyAfterDays").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.automatically_after_days).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_iam_access_key_session_context(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsIamAccessKeySessionContext,
) {
    if let Some(var_2065) = &input.attributes {
        let mut object_2066 = object.key("Attributes").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_iam_access_key_session_context_attributes(&mut object_2066, var_2065);
        object_2066.finish();
    }
    if let Some(var_2067) = &input.session_issuer {
        let mut object_2068 = object.key("SessionIssuer").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_iam_access_key_session_context_session_issuer(&mut object_2068, var_2067);
        object_2068.finish();
    }
}

pub fn serialize_structure_crate_model_aws_iam_attached_managed_policy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsIamAttachedManagedPolicy,
) {
    if let Some(var_2069) = &input.policy_name {
        object.key("PolicyName").string(var_2069);
    }
    if let Some(var_2070) = &input.policy_arn {
        object.key("PolicyArn").string(var_2070);
    }
}

pub fn serialize_structure_crate_model_aws_iam_permissions_boundary(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsIamPermissionsBoundary,
) {
    if let Some(var_2071) = &input.permissions_boundary_arn {
        object.key("PermissionsBoundaryArn").string(var_2071);
    }
    if let Some(var_2072) = &input.permissions_boundary_type {
        object.key("PermissionsBoundaryType").string(var_2072);
    }
}

pub fn serialize_structure_crate_model_aws_iam_user_policy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsIamUserPolicy,
) {
    if let Some(var_2073) = &input.policy_name {
        object.key("PolicyName").string(var_2073);
    }
}

pub fn serialize_structure_crate_model_aws_iam_policy_version(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsIamPolicyVersion,
) {
    if let Some(var_2074) = &input.version_id {
        object.key("VersionId").string(var_2074);
    }
    if input.is_default_version {
        object
            .key("IsDefaultVersion")
            .boolean(input.is_default_version);
    }
    if let Some(var_2075) = &input.create_date {
        object.key("CreateDate").string(var_2075);
    }
}

pub fn serialize_structure_crate_model_aws_api_gateway_v2_route_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsApiGatewayV2RouteSettings,
) {
    if input.detailed_metrics_enabled {
        object
            .key("DetailedMetricsEnabled")
            .boolean(input.detailed_metrics_enabled);
    }
    if let Some(var_2076) = &input.logging_level {
        object.key("LoggingLevel").string(var_2076);
    }
    if input.data_trace_enabled {
        object
            .key("DataTraceEnabled")
            .boolean(input.data_trace_enabled);
    }
    if input.throttling_burst_limit != 0 {
        object.key("ThrottlingBurstLimit").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.throttling_burst_limit).into()),
        );
    }
    if input.throttling_rate_limit != 0.0 {
        object.key("ThrottlingRateLimit").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.throttling_rate_limit).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_api_gateway_access_log_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsApiGatewayAccessLogSettings,
) {
    if let Some(var_2077) = &input.format {
        object.key("Format").string(var_2077);
    }
    if let Some(var_2078) = &input.destination_arn {
        object.key("DestinationArn").string(var_2078);
    }
}

pub fn serialize_structure_crate_model_aws_cors_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCorsConfiguration,
) {
    if let Some(var_2079) = &input.allow_origins {
        let mut array_2080 = object.key("AllowOrigins").start_array();
        for item_2081 in var_2079 {
            {
                array_2080.value().string(item_2081);
            }
        }
        array_2080.finish();
    }
    if input.allow_credentials {
        object
            .key("AllowCredentials")
            .boolean(input.allow_credentials);
    }
    if let Some(var_2082) = &input.expose_headers {
        let mut array_2083 = object.key("ExposeHeaders").start_array();
        for item_2084 in var_2082 {
            {
                array_2083.value().string(item_2084);
            }
        }
        array_2083.finish();
    }
    if input.max_age != 0 {
        object.key("MaxAge").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_age).into()),
        );
    }
    if let Some(var_2085) = &input.allow_methods {
        let mut array_2086 = object.key("AllowMethods").start_array();
        for item_2087 in var_2085 {
            {
                array_2086.value().string(item_2087);
            }
        }
        array_2086.finish();
    }
    if let Some(var_2088) = &input.allow_headers {
        let mut array_2089 = object.key("AllowHeaders").start_array();
        for item_2090 in var_2088 {
            {
                array_2089.value().string(item_2090);
            }
        }
        array_2089.finish();
    }
}

pub fn serialize_structure_crate_model_aws_dynamo_db_table_attribute_definition(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsDynamoDbTableAttributeDefinition,
) {
    if let Some(var_2091) = &input.attribute_name {
        object.key("AttributeName").string(var_2091);
    }
    if let Some(var_2092) = &input.attribute_type {
        object.key("AttributeType").string(var_2092);
    }
}

pub fn serialize_structure_crate_model_aws_dynamo_db_table_billing_mode_summary(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsDynamoDbTableBillingModeSummary,
) {
    if let Some(var_2093) = &input.billing_mode {
        object.key("BillingMode").string(var_2093);
    }
    if let Some(var_2094) = &input.last_update_to_pay_per_request_date_time {
        object
            .key("LastUpdateToPayPerRequestDateTime")
            .string(var_2094);
    }
}

pub fn serialize_structure_crate_model_aws_dynamo_db_table_global_secondary_index(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsDynamoDbTableGlobalSecondaryIndex,
) {
    if input.backfilling {
        object.key("Backfilling").boolean(input.backfilling);
    }
    if let Some(var_2095) = &input.index_arn {
        object.key("IndexArn").string(var_2095);
    }
    if let Some(var_2096) = &input.index_name {
        object.key("IndexName").string(var_2096);
    }
    if input.index_size_bytes != 0 {
        object.key("IndexSizeBytes").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.index_size_bytes).into()),
        );
    }
    if let Some(var_2097) = &input.index_status {
        object.key("IndexStatus").string(var_2097);
    }
    if input.item_count != 0 {
        object.key("ItemCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.item_count).into()),
        );
    }
    if let Some(var_2098) = &input.key_schema {
        let mut array_2099 = object.key("KeySchema").start_array();
        for item_2100 in var_2098 {
            {
                let mut object_2101 = array_2099.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_key_schema(
                    &mut object_2101,
                    item_2100,
                );
                object_2101.finish();
            }
        }
        array_2099.finish();
    }
    if let Some(var_2102) = &input.projection {
        let mut object_2103 = object.key("Projection").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_projection(
            &mut object_2103,
            var_2102,
        );
        object_2103.finish();
    }
    if let Some(var_2104) = &input.provisioned_throughput {
        let mut object_2105 = object.key("ProvisionedThroughput").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_provisioned_throughput(
            &mut object_2105,
            var_2104,
        );
        object_2105.finish();
    }
}

pub fn serialize_structure_crate_model_aws_dynamo_db_table_key_schema(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsDynamoDbTableKeySchema,
) {
    if let Some(var_2106) = &input.attribute_name {
        object.key("AttributeName").string(var_2106);
    }
    if let Some(var_2107) = &input.key_type {
        object.key("KeyType").string(var_2107);
    }
}

pub fn serialize_structure_crate_model_aws_dynamo_db_table_local_secondary_index(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsDynamoDbTableLocalSecondaryIndex,
) {
    if let Some(var_2108) = &input.index_arn {
        object.key("IndexArn").string(var_2108);
    }
    if let Some(var_2109) = &input.index_name {
        object.key("IndexName").string(var_2109);
    }
    if let Some(var_2110) = &input.key_schema {
        let mut array_2111 = object.key("KeySchema").start_array();
        for item_2112 in var_2110 {
            {
                let mut object_2113 = array_2111.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_key_schema(
                    &mut object_2113,
                    item_2112,
                );
                object_2113.finish();
            }
        }
        array_2111.finish();
    }
    if let Some(var_2114) = &input.projection {
        let mut object_2115 = object.key("Projection").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_projection(
            &mut object_2115,
            var_2114,
        );
        object_2115.finish();
    }
}

pub fn serialize_structure_crate_model_aws_dynamo_db_table_provisioned_throughput(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsDynamoDbTableProvisionedThroughput,
) {
    if let Some(var_2116) = &input.last_decrease_date_time {
        object.key("LastDecreaseDateTime").string(var_2116);
    }
    if let Some(var_2117) = &input.last_increase_date_time {
        object.key("LastIncreaseDateTime").string(var_2117);
    }
    if input.number_of_decreases_today != 0 {
        object.key("NumberOfDecreasesToday").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.number_of_decreases_today).into()),
        );
    }
    if input.read_capacity_units != 0 {
        object.key("ReadCapacityUnits").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.read_capacity_units).into()),
        );
    }
    if input.write_capacity_units != 0 {
        object.key("WriteCapacityUnits").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.write_capacity_units).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_dynamo_db_table_replica(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsDynamoDbTableReplica,
) {
    if let Some(var_2118) = &input.global_secondary_indexes {
        let mut array_2119 = object.key("GlobalSecondaryIndexes").start_array();
        for item_2120 in var_2118 {
            {
                let mut object_2121 = array_2119.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_replica_global_secondary_index(&mut object_2121, item_2120);
                object_2121.finish();
            }
        }
        array_2119.finish();
    }
    if let Some(var_2122) = &input.kms_master_key_id {
        object.key("KmsMasterKeyId").string(var_2122);
    }
    if let Some(var_2123) = &input.provisioned_throughput_override {
        let mut object_2124 = object.key("ProvisionedThroughputOverride").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_provisioned_throughput_override(&mut object_2124, var_2123);
        object_2124.finish();
    }
    if let Some(var_2125) = &input.region_name {
        object.key("RegionName").string(var_2125);
    }
    if let Some(var_2126) = &input.replica_status {
        object.key("ReplicaStatus").string(var_2126);
    }
    if let Some(var_2127) = &input.replica_status_description {
        object.key("ReplicaStatusDescription").string(var_2127);
    }
}

pub fn serialize_structure_crate_model_aws_dynamo_db_table_restore_summary(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsDynamoDbTableRestoreSummary,
) {
    if let Some(var_2128) = &input.source_backup_arn {
        object.key("SourceBackupArn").string(var_2128);
    }
    if let Some(var_2129) = &input.source_table_arn {
        object.key("SourceTableArn").string(var_2129);
    }
    if let Some(var_2130) = &input.restore_date_time {
        object.key("RestoreDateTime").string(var_2130);
    }
    if input.restore_in_progress {
        object
            .key("RestoreInProgress")
            .boolean(input.restore_in_progress);
    }
}

pub fn serialize_structure_crate_model_aws_dynamo_db_table_sse_description(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsDynamoDbTableSseDescription,
) {
    if let Some(var_2131) = &input.inaccessible_encryption_date_time {
        object
            .key("InaccessibleEncryptionDateTime")
            .string(var_2131);
    }
    if let Some(var_2132) = &input.status {
        object.key("Status").string(var_2132);
    }
    if let Some(var_2133) = &input.sse_type {
        object.key("SseType").string(var_2133);
    }
    if let Some(var_2134) = &input.kms_master_key_arn {
        object.key("KmsMasterKeyArn").string(var_2134);
    }
}

pub fn serialize_structure_crate_model_aws_dynamo_db_table_stream_specification(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsDynamoDbTableStreamSpecification,
) {
    if input.stream_enabled {
        object.key("StreamEnabled").boolean(input.stream_enabled);
    }
    if let Some(var_2135) = &input.stream_view_type {
        object.key("StreamViewType").string(var_2135);
    }
}

pub fn serialize_structure_crate_model_aws_api_gateway_method_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsApiGatewayMethodSettings,
) {
    if input.metrics_enabled {
        object.key("MetricsEnabled").boolean(input.metrics_enabled);
    }
    if let Some(var_2136) = &input.logging_level {
        object.key("LoggingLevel").string(var_2136);
    }
    if input.data_trace_enabled {
        object
            .key("DataTraceEnabled")
            .boolean(input.data_trace_enabled);
    }
    if input.throttling_burst_limit != 0 {
        object.key("ThrottlingBurstLimit").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.throttling_burst_limit).into()),
        );
    }
    if input.throttling_rate_limit != 0.0 {
        object.key("ThrottlingRateLimit").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.throttling_rate_limit).into()),
        );
    }
    if input.caching_enabled {
        object.key("CachingEnabled").boolean(input.caching_enabled);
    }
    if input.cache_ttl_in_seconds != 0 {
        object.key("CacheTtlInSeconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.cache_ttl_in_seconds).into()),
        );
    }
    if input.cache_data_encrypted {
        object
            .key("CacheDataEncrypted")
            .boolean(input.cache_data_encrypted);
    }
    if input.require_authorization_for_cache_control {
        object
            .key("RequireAuthorizationForCacheControl")
            .boolean(input.require_authorization_for_cache_control);
    }
    if let Some(var_2137) = &input.unauthorized_cache_control_header_strategy {
        object
            .key("UnauthorizedCacheControlHeaderStrategy")
            .string(var_2137);
    }
    if let Some(var_2138) = &input.http_method {
        object.key("HttpMethod").string(var_2138);
    }
    if let Some(var_2139) = &input.resource_path {
        object.key("ResourcePath").string(var_2139);
    }
}

pub fn serialize_structure_crate_model_aws_api_gateway_canary_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsApiGatewayCanarySettings,
) {
    if input.percent_traffic != 0.0 {
        object.key("PercentTraffic").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.percent_traffic).into()),
        );
    }
    if let Some(var_2140) = &input.deployment_id {
        object.key("DeploymentId").string(var_2140);
    }
    if let Some(var_2141) = &input.stage_variable_overrides {
        let mut object_2142 = object.key("StageVariableOverrides").start_object();
        for (key_2143, value_2144) in var_2141 {
            {
                object_2142.key(key_2143).string(value_2144);
            }
        }
        object_2142.finish();
    }
    if input.use_stage_cache {
        object.key("UseStageCache").boolean(input.use_stage_cache);
    }
}

pub fn serialize_structure_crate_model_aws_api_gateway_endpoint_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsApiGatewayEndpointConfiguration,
) {
    if let Some(var_2145) = &input.types {
        let mut array_2146 = object.key("Types").start_array();
        for item_2147 in var_2145 {
            {
                array_2146.value().string(item_2147);
            }
        }
        array_2146.finish();
    }
}

pub fn serialize_structure_crate_model_aws_ssm_patch(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsSsmPatch,
) {
    if let Some(var_2148) = &input.compliance_summary {
        let mut object_2149 = object.key("ComplianceSummary").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ssm_compliance_summary(
            &mut object_2149,
            var_2148,
        );
        object_2149.finish();
    }
}

pub fn serialize_structure_crate_model_aws_certificate_manager_certificate_domain_validation_option(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCertificateManagerCertificateDomainValidationOption,
) {
    if let Some(var_2150) = &input.domain_name {
        object.key("DomainName").string(var_2150);
    }
    if let Some(var_2151) = &input.resource_record {
        let mut object_2152 = object.key("ResourceRecord").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_certificate_manager_certificate_resource_record(&mut object_2152, var_2151);
        object_2152.finish();
    }
    if let Some(var_2153) = &input.validation_domain {
        object.key("ValidationDomain").string(var_2153);
    }
    if let Some(var_2154) = &input.validation_emails {
        let mut array_2155 = object.key("ValidationEmails").start_array();
        for item_2156 in var_2154 {
            {
                array_2155.value().string(item_2156);
            }
        }
        array_2155.finish();
    }
    if let Some(var_2157) = &input.validation_method {
        object.key("ValidationMethod").string(var_2157);
    }
    if let Some(var_2158) = &input.validation_status {
        object.key("ValidationStatus").string(var_2158);
    }
}

pub fn serialize_structure_crate_model_aws_certificate_manager_certificate_extended_key_usage(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCertificateManagerCertificateExtendedKeyUsage,
) {
    if let Some(var_2159) = &input.name {
        object.key("Name").string(var_2159);
    }
    if let Some(var_2160) = &input.o_id {
        object.key("OId").string(var_2160);
    }
}

pub fn serialize_structure_crate_model_aws_certificate_manager_certificate_key_usage(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCertificateManagerCertificateKeyUsage,
) {
    if let Some(var_2161) = &input.name {
        object.key("Name").string(var_2161);
    }
}

pub fn serialize_structure_crate_model_aws_certificate_manager_certificate_options(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCertificateManagerCertificateOptions,
) {
    if let Some(var_2162) = &input.certificate_transparency_logging_preference {
        object
            .key("CertificateTransparencyLoggingPreference")
            .string(var_2162);
    }
}

pub fn serialize_structure_crate_model_aws_certificate_manager_certificate_renewal_summary(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCertificateManagerCertificateRenewalSummary,
) {
    if let Some(var_2163) = &input.domain_validation_options {
        let mut array_2164 = object.key("DomainValidationOptions").start_array();
        for item_2165 in var_2163 {
            {
                let mut object_2166 = array_2164.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_certificate_manager_certificate_domain_validation_option(&mut object_2166, item_2165);
                object_2166.finish();
            }
        }
        array_2164.finish();
    }
    if let Some(var_2167) = &input.renewal_status {
        object.key("RenewalStatus").string(var_2167);
    }
    if let Some(var_2168) = &input.renewal_status_reason {
        object.key("RenewalStatusReason").string(var_2168);
    }
    if let Some(var_2169) = &input.updated_at {
        object.key("UpdatedAt").string(var_2169);
    }
}

pub fn serialize_structure_crate_model_aws_redshift_cluster_cluster_node(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRedshiftClusterClusterNode,
) {
    if let Some(var_2170) = &input.node_role {
        object.key("NodeRole").string(var_2170);
    }
    if let Some(var_2171) = &input.private_ip_address {
        object.key("PrivateIpAddress").string(var_2171);
    }
    if let Some(var_2172) = &input.public_ip_address {
        object.key("PublicIpAddress").string(var_2172);
    }
}

pub fn serialize_structure_crate_model_aws_redshift_cluster_cluster_parameter_group(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRedshiftClusterClusterParameterGroup,
) {
    if let Some(var_2173) = &input.cluster_parameter_status_list {
        let mut array_2174 = object.key("ClusterParameterStatusList").start_array();
        for item_2175 in var_2173 {
            {
                let mut object_2176 = array_2174.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_redshift_cluster_cluster_parameter_status(&mut object_2176, item_2175);
                object_2176.finish();
            }
        }
        array_2174.finish();
    }
    if let Some(var_2177) = &input.parameter_apply_status {
        object.key("ParameterApplyStatus").string(var_2177);
    }
    if let Some(var_2178) = &input.parameter_group_name {
        object.key("ParameterGroupName").string(var_2178);
    }
}

pub fn serialize_structure_crate_model_aws_redshift_cluster_cluster_security_group(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRedshiftClusterClusterSecurityGroup,
) {
    if let Some(var_2179) = &input.cluster_security_group_name {
        object.key("ClusterSecurityGroupName").string(var_2179);
    }
    if let Some(var_2180) = &input.status {
        object.key("Status").string(var_2180);
    }
}

pub fn serialize_structure_crate_model_aws_redshift_cluster_cluster_snapshot_copy_status(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRedshiftClusterClusterSnapshotCopyStatus,
) {
    if let Some(var_2181) = &input.destination_region {
        object.key("DestinationRegion").string(var_2181);
    }
    if input.manual_snapshot_retention_period != 0 {
        object.key("ManualSnapshotRetentionPeriod").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.manual_snapshot_retention_period).into()),
        );
    }
    if input.retention_period != 0 {
        object.key("RetentionPeriod").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.retention_period).into()),
        );
    }
    if let Some(var_2182) = &input.snapshot_copy_grant_name {
        object.key("SnapshotCopyGrantName").string(var_2182);
    }
}

pub fn serialize_structure_crate_model_aws_redshift_cluster_deferred_maintenance_window(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRedshiftClusterDeferredMaintenanceWindow,
) {
    if let Some(var_2183) = &input.defer_maintenance_end_time {
        object.key("DeferMaintenanceEndTime").string(var_2183);
    }
    if let Some(var_2184) = &input.defer_maintenance_identifier {
        object.key("DeferMaintenanceIdentifier").string(var_2184);
    }
    if let Some(var_2185) = &input.defer_maintenance_start_time {
        object.key("DeferMaintenanceStartTime").string(var_2185);
    }
}

pub fn serialize_structure_crate_model_aws_redshift_cluster_elastic_ip_status(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRedshiftClusterElasticIpStatus,
) {
    if let Some(var_2186) = &input.elastic_ip {
        object.key("ElasticIp").string(var_2186);
    }
    if let Some(var_2187) = &input.status {
        object.key("Status").string(var_2187);
    }
}

pub fn serialize_structure_crate_model_aws_redshift_cluster_endpoint(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRedshiftClusterEndpoint,
) {
    if let Some(var_2188) = &input.address {
        object.key("Address").string(var_2188);
    }
    if input.port != 0 {
        object.key("Port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.port).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_redshift_cluster_hsm_status(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRedshiftClusterHsmStatus,
) {
    if let Some(var_2189) = &input.hsm_client_certificate_identifier {
        object
            .key("HsmClientCertificateIdentifier")
            .string(var_2189);
    }
    if let Some(var_2190) = &input.hsm_configuration_identifier {
        object.key("HsmConfigurationIdentifier").string(var_2190);
    }
    if let Some(var_2191) = &input.status {
        object.key("Status").string(var_2191);
    }
}

pub fn serialize_structure_crate_model_aws_redshift_cluster_iam_role(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRedshiftClusterIamRole,
) {
    if let Some(var_2192) = &input.apply_status {
        object.key("ApplyStatus").string(var_2192);
    }
    if let Some(var_2193) = &input.iam_role_arn {
        object.key("IamRoleArn").string(var_2193);
    }
}

pub fn serialize_structure_crate_model_aws_redshift_cluster_pending_modified_values(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRedshiftClusterPendingModifiedValues,
) {
    if input.automated_snapshot_retention_period != 0 {
        object.key("AutomatedSnapshotRetentionPeriod").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.automated_snapshot_retention_period).into()),
        );
    }
    if let Some(var_2194) = &input.cluster_identifier {
        object.key("ClusterIdentifier").string(var_2194);
    }
    if let Some(var_2195) = &input.cluster_type {
        object.key("ClusterType").string(var_2195);
    }
    if let Some(var_2196) = &input.cluster_version {
        object.key("ClusterVersion").string(var_2196);
    }
    if let Some(var_2197) = &input.encryption_type {
        object.key("EncryptionType").string(var_2197);
    }
    if input.enhanced_vpc_routing {
        object
            .key("EnhancedVpcRouting")
            .boolean(input.enhanced_vpc_routing);
    }
    if let Some(var_2198) = &input.maintenance_track_name {
        object.key("MaintenanceTrackName").string(var_2198);
    }
    if let Some(var_2199) = &input.master_user_password {
        object.key("MasterUserPassword").string(var_2199);
    }
    if let Some(var_2200) = &input.node_type {
        object.key("NodeType").string(var_2200);
    }
    if input.number_of_nodes != 0 {
        object.key("NumberOfNodes").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.number_of_nodes).into()),
        );
    }
    if input.publicly_accessible {
        object
            .key("PubliclyAccessible")
            .boolean(input.publicly_accessible);
    }
}

pub fn serialize_structure_crate_model_aws_redshift_cluster_resize_info(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRedshiftClusterResizeInfo,
) {
    if input.allow_cancel_resize {
        object
            .key("AllowCancelResize")
            .boolean(input.allow_cancel_resize);
    }
    if let Some(var_2201) = &input.resize_type {
        object.key("ResizeType").string(var_2201);
    }
}

pub fn serialize_structure_crate_model_aws_redshift_cluster_restore_status(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRedshiftClusterRestoreStatus,
) {
    if input.current_restore_rate_in_mega_bytes_per_second != 0.0 {
        object.key("CurrentRestoreRateInMegaBytesPerSecond").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float(
                (input.current_restore_rate_in_mega_bytes_per_second).into(),
            ),
        );
    }
    if input.elapsed_time_in_seconds != 0 {
        object.key("ElapsedTimeInSeconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.elapsed_time_in_seconds).into()),
        );
    }
    if input.estimated_time_to_completion_in_seconds != 0 {
        object.key("EstimatedTimeToCompletionInSeconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt(
                (input.estimated_time_to_completion_in_seconds).into(),
            ),
        );
    }
    if input.progress_in_mega_bytes != 0 {
        object.key("ProgressInMegaBytes").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.progress_in_mega_bytes).into()),
        );
    }
    if input.snapshot_size_in_mega_bytes != 0 {
        object.key("SnapshotSizeInMegaBytes").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.snapshot_size_in_mega_bytes).into()),
        );
    }
    if let Some(var_2202) = &input.status {
        object.key("Status").string(var_2202);
    }
}

pub fn serialize_structure_crate_model_aws_redshift_cluster_vpc_security_group(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRedshiftClusterVpcSecurityGroup,
) {
    if let Some(var_2203) = &input.status {
        object.key("Status").string(var_2203);
    }
    if let Some(var_2204) = &input.vpc_security_group_id {
        object.key("VpcSecurityGroupId").string(var_2204);
    }
}

pub fn serialize_structure_crate_model_aws_elb_load_balancer_backend_server_description(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElbLoadBalancerBackendServerDescription,
) {
    if input.instance_port != 0 {
        object.key("InstancePort").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.instance_port).into()),
        );
    }
    if let Some(var_2205) = &input.policy_names {
        let mut array_2206 = object.key("PolicyNames").start_array();
        for item_2207 in var_2205 {
            {
                array_2206.value().string(item_2207);
            }
        }
        array_2206.finish();
    }
}

pub fn serialize_structure_crate_model_aws_elb_load_balancer_health_check(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElbLoadBalancerHealthCheck,
) {
    if input.healthy_threshold != 0 {
        object.key("HealthyThreshold").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.healthy_threshold).into()),
        );
    }
    if input.interval != 0 {
        object.key("Interval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.interval).into()),
        );
    }
    if let Some(var_2208) = &input.target {
        object.key("Target").string(var_2208);
    }
    if input.timeout != 0 {
        object.key("Timeout").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.timeout).into()),
        );
    }
    if input.unhealthy_threshold != 0 {
        object.key("UnhealthyThreshold").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.unhealthy_threshold).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_elb_load_balancer_instance(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElbLoadBalancerInstance,
) {
    if let Some(var_2209) = &input.instance_id {
        object.key("InstanceId").string(var_2209);
    }
}

pub fn serialize_structure_crate_model_aws_elb_load_balancer_listener_description(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElbLoadBalancerListenerDescription,
) {
    if let Some(var_2210) = &input.listener {
        let mut object_2211 = object.key("Listener").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_listener(
            &mut object_2211,
            var_2210,
        );
        object_2211.finish();
    }
    if let Some(var_2212) = &input.policy_names {
        let mut array_2213 = object.key("PolicyNames").start_array();
        for item_2214 in var_2212 {
            {
                array_2213.value().string(item_2214);
            }
        }
        array_2213.finish();
    }
}

pub fn serialize_structure_crate_model_aws_elb_load_balancer_attributes(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElbLoadBalancerAttributes,
) {
    if let Some(var_2215) = &input.access_log {
        let mut object_2216 = object.key("AccessLog").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_access_log(
            &mut object_2216,
            var_2215,
        );
        object_2216.finish();
    }
    if let Some(var_2217) = &input.connection_draining {
        let mut object_2218 = object.key("ConnectionDraining").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_connection_draining(
            &mut object_2218,
            var_2217,
        );
        object_2218.finish();
    }
    if let Some(var_2219) = &input.connection_settings {
        let mut object_2220 = object.key("ConnectionSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_connection_settings(
            &mut object_2220,
            var_2219,
        );
        object_2220.finish();
    }
    if let Some(var_2221) = &input.cross_zone_load_balancing {
        let mut object_2222 = object.key("CrossZoneLoadBalancing").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_elb_load_balancer_cross_zone_load_balancing(&mut object_2222, var_2221);
        object_2222.finish();
    }
}

pub fn serialize_structure_crate_model_aws_elb_load_balancer_policies(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElbLoadBalancerPolicies,
) {
    if let Some(var_2223) = &input.app_cookie_stickiness_policies {
        let mut array_2224 = object.key("AppCookieStickinessPolicies").start_array();
        for item_2225 in var_2223 {
            {
                let mut object_2226 = array_2224.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_elb_app_cookie_stickiness_policy(&mut object_2226, item_2225);
                object_2226.finish();
            }
        }
        array_2224.finish();
    }
    if let Some(var_2227) = &input.lb_cookie_stickiness_policies {
        let mut array_2228 = object.key("LbCookieStickinessPolicies").start_array();
        for item_2229 in var_2227 {
            {
                let mut object_2230 = array_2228.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_elb_lb_cookie_stickiness_policy(&mut object_2230, item_2229);
                object_2230.finish();
            }
        }
        array_2228.finish();
    }
    if let Some(var_2231) = &input.other_policies {
        let mut array_2232 = object.key("OtherPolicies").start_array();
        for item_2233 in var_2231 {
            {
                array_2232.value().string(item_2233);
            }
        }
        array_2232.finish();
    }
}

pub fn serialize_structure_crate_model_aws_elb_load_balancer_source_security_group(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElbLoadBalancerSourceSecurityGroup,
) {
    if let Some(var_2234) = &input.group_name {
        object.key("GroupName").string(var_2234);
    }
    if let Some(var_2235) = &input.owner_alias {
        object.key("OwnerAlias").string(var_2235);
    }
}

pub fn serialize_structure_crate_model_aws_iam_group_policy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsIamGroupPolicy,
) {
    if let Some(var_2236) = &input.policy_name {
        object.key("PolicyName").string(var_2236);
    }
}

pub fn serialize_structure_crate_model_aws_iam_instance_profile(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsIamInstanceProfile,
) {
    if let Some(var_2237) = &input.arn {
        object.key("Arn").string(var_2237);
    }
    if let Some(var_2238) = &input.create_date {
        object.key("CreateDate").string(var_2238);
    }
    if let Some(var_2239) = &input.instance_profile_id {
        object.key("InstanceProfileId").string(var_2239);
    }
    if let Some(var_2240) = &input.instance_profile_name {
        object.key("InstanceProfileName").string(var_2240);
    }
    if let Some(var_2241) = &input.path {
        object.key("Path").string(var_2241);
    }
    if let Some(var_2242) = &input.roles {
        let mut array_2243 = object.key("Roles").start_array();
        for item_2244 in var_2242 {
            {
                let mut object_2245 = array_2243.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_iam_instance_profile_role(
                    &mut object_2245,
                    item_2244,
                );
                object_2245.finish();
            }
        }
        array_2243.finish();
    }
}

pub fn serialize_structure_crate_model_aws_iam_role_policy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsIamRolePolicy,
) {
    if let Some(var_2246) = &input.policy_name {
        object.key("PolicyName").string(var_2246);
    }
}

pub fn serialize_structure_crate_model_aws_lambda_function_code(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsLambdaFunctionCode,
) {
    if let Some(var_2247) = &input.s3_bucket {
        object.key("S3Bucket").string(var_2247);
    }
    if let Some(var_2248) = &input.s3_key {
        object.key("S3Key").string(var_2248);
    }
    if let Some(var_2249) = &input.s3_object_version {
        object.key("S3ObjectVersion").string(var_2249);
    }
    if let Some(var_2250) = &input.zip_file {
        object.key("ZipFile").string(var_2250);
    }
}

pub fn serialize_structure_crate_model_aws_lambda_function_dead_letter_config(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsLambdaFunctionDeadLetterConfig,
) {
    if let Some(var_2251) = &input.target_arn {
        object.key("TargetArn").string(var_2251);
    }
}

pub fn serialize_structure_crate_model_aws_lambda_function_environment(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsLambdaFunctionEnvironment,
) {
    if let Some(var_2252) = &input.variables {
        let mut object_2253 = object.key("Variables").start_object();
        for (key_2254, value_2255) in var_2252 {
            {
                object_2253.key(key_2254).string(value_2255);
            }
        }
        object_2253.finish();
    }
    if let Some(var_2256) = &input.error {
        let mut object_2257 = object.key("Error").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_lambda_function_environment_error(
            &mut object_2257,
            var_2256,
        );
        object_2257.finish();
    }
}

pub fn serialize_structure_crate_model_aws_lambda_function_layer(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsLambdaFunctionLayer,
) {
    if let Some(var_2258) = &input.arn {
        object.key("Arn").string(var_2258);
    }
    if input.code_size != 0 {
        object.key("CodeSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.code_size).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_lambda_function_tracing_config(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsLambdaFunctionTracingConfig,
) {
    if let Some(var_2259) = &input.mode {
        object.key("Mode").string(var_2259);
    }
}

pub fn serialize_structure_crate_model_aws_lambda_function_vpc_config(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsLambdaFunctionVpcConfig,
) {
    if let Some(var_2260) = &input.security_group_ids {
        let mut array_2261 = object.key("SecurityGroupIds").start_array();
        for item_2262 in var_2260 {
            {
                array_2261.value().string(item_2262);
            }
        }
        array_2261.finish();
    }
    if let Some(var_2263) = &input.subnet_ids {
        let mut array_2264 = object.key("SubnetIds").start_array();
        for item_2265 in var_2263 {
            {
                array_2264.value().string(item_2265);
            }
        }
        array_2264.finish();
    }
    if let Some(var_2266) = &input.vpc_id {
        object.key("VpcId").string(var_2266);
    }
}

pub fn serialize_structure_crate_model_aws_rds_db_instance_associated_role(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsDbInstanceAssociatedRole,
) {
    if let Some(var_2267) = &input.role_arn {
        object.key("RoleArn").string(var_2267);
    }
    if let Some(var_2268) = &input.feature_name {
        object.key("FeatureName").string(var_2268);
    }
    if let Some(var_2269) = &input.status {
        object.key("Status").string(var_2269);
    }
}

pub fn serialize_structure_crate_model_aws_rds_db_instance_endpoint(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsDbInstanceEndpoint,
) {
    if let Some(var_2270) = &input.address {
        object.key("Address").string(var_2270);
    }
    if input.port != 0 {
        object.key("Port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.port).into()),
        );
    }
    if let Some(var_2271) = &input.hosted_zone_id {
        object.key("HostedZoneId").string(var_2271);
    }
}

pub fn serialize_structure_crate_model_aws_rds_db_instance_vpc_security_group(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsDbInstanceVpcSecurityGroup,
) {
    if let Some(var_2272) = &input.vpc_security_group_id {
        object.key("VpcSecurityGroupId").string(var_2272);
    }
    if let Some(var_2273) = &input.status {
        object.key("Status").string(var_2273);
    }
}

pub fn serialize_structure_crate_model_aws_rds_db_parameter_group(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsDbParameterGroup,
) {
    if let Some(var_2274) = &input.db_parameter_group_name {
        object.key("DbParameterGroupName").string(var_2274);
    }
    if let Some(var_2275) = &input.parameter_apply_status {
        object.key("ParameterApplyStatus").string(var_2275);
    }
}

pub fn serialize_structure_crate_model_aws_rds_db_subnet_group(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsDbSubnetGroup,
) {
    if let Some(var_2276) = &input.db_subnet_group_name {
        object.key("DbSubnetGroupName").string(var_2276);
    }
    if let Some(var_2277) = &input.db_subnet_group_description {
        object.key("DbSubnetGroupDescription").string(var_2277);
    }
    if let Some(var_2278) = &input.vpc_id {
        object.key("VpcId").string(var_2278);
    }
    if let Some(var_2279) = &input.subnet_group_status {
        object.key("SubnetGroupStatus").string(var_2279);
    }
    if let Some(var_2280) = &input.subnets {
        let mut array_2281 = object.key("Subnets").start_array();
        for item_2282 in var_2280 {
            {
                let mut object_2283 = array_2281.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_rds_db_subnet_group_subnet(
                    &mut object_2283,
                    item_2282,
                );
                object_2283.finish();
            }
        }
        array_2281.finish();
    }
    if let Some(var_2284) = &input.db_subnet_group_arn {
        object.key("DbSubnetGroupArn").string(var_2284);
    }
}

pub fn serialize_structure_crate_model_aws_rds_db_pending_modified_values(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsDbPendingModifiedValues,
) {
    if let Some(var_2285) = &input.db_instance_class {
        object.key("DbInstanceClass").string(var_2285);
    }
    if input.allocated_storage != 0 {
        object.key("AllocatedStorage").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.allocated_storage).into()),
        );
    }
    if let Some(var_2286) = &input.master_user_password {
        object.key("MasterUserPassword").string(var_2286);
    }
    if input.port != 0 {
        object.key("Port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.port).into()),
        );
    }
    if input.backup_retention_period != 0 {
        object.key("BackupRetentionPeriod").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.backup_retention_period).into()),
        );
    }
    if input.multi_az {
        object.key("MultiAZ").boolean(input.multi_az);
    }
    if let Some(var_2287) = &input.engine_version {
        object.key("EngineVersion").string(var_2287);
    }
    if let Some(var_2288) = &input.license_model {
        object.key("LicenseModel").string(var_2288);
    }
    if input.iops != 0 {
        object.key("Iops").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.iops).into()),
        );
    }
    if let Some(var_2289) = &input.db_instance_identifier {
        object.key("DbInstanceIdentifier").string(var_2289);
    }
    if let Some(var_2290) = &input.storage_type {
        object.key("StorageType").string(var_2290);
    }
    if let Some(var_2291) = &input.ca_certificate_identifier {
        object.key("CaCertificateIdentifier").string(var_2291);
    }
    if let Some(var_2292) = &input.db_subnet_group_name {
        object.key("DbSubnetGroupName").string(var_2292);
    }
    if let Some(var_2293) = &input.pending_cloud_watch_logs_exports {
        let mut object_2294 = object.key("PendingCloudWatchLogsExports").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_rds_pending_cloud_watch_logs_exports(
            &mut object_2294,
            var_2293,
        );
        object_2294.finish();
    }
    if let Some(var_2295) = &input.processor_features {
        let mut array_2296 = object.key("ProcessorFeatures").start_array();
        for item_2297 in var_2295 {
            {
                let mut object_2298 = array_2296.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_rds_db_processor_feature(
                    &mut object_2298,
                    item_2297,
                );
                object_2298.finish();
            }
        }
        array_2296.finish();
    }
}

pub fn serialize_structure_crate_model_aws_rds_db_option_group_membership(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsDbOptionGroupMembership,
) {
    if let Some(var_2299) = &input.option_group_name {
        object.key("OptionGroupName").string(var_2299);
    }
    if let Some(var_2300) = &input.status {
        object.key("Status").string(var_2300);
    }
}

pub fn serialize_structure_crate_model_aws_rds_db_status_info(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsDbStatusInfo,
) {
    if let Some(var_2301) = &input.status_type {
        object.key("StatusType").string(var_2301);
    }
    if input.normal {
        object.key("Normal").boolean(input.normal);
    }
    if let Some(var_2302) = &input.status {
        object.key("Status").string(var_2302);
    }
    if let Some(var_2303) = &input.message {
        object.key("Message").string(var_2303);
    }
}

pub fn serialize_structure_crate_model_aws_rds_db_domain_membership(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsDbDomainMembership,
) {
    if let Some(var_2304) = &input.domain {
        object.key("Domain").string(var_2304);
    }
    if let Some(var_2305) = &input.status {
        object.key("Status").string(var_2305);
    }
    if let Some(var_2306) = &input.fqdn {
        object.key("Fqdn").string(var_2306);
    }
    if let Some(var_2307) = &input.iam_role_name {
        object.key("IamRoleName").string(var_2307);
    }
}

pub fn serialize_structure_crate_model_aws_rds_db_processor_feature(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsDbProcessorFeature,
) {
    if let Some(var_2308) = &input.name {
        object.key("Name").string(var_2308);
    }
    if let Some(var_2309) = &input.value {
        object.key("Value").string(var_2309);
    }
}

pub fn serialize_structure_crate_model_aws_sns_topic_subscription(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsSnsTopicSubscription,
) {
    if let Some(var_2310) = &input.endpoint {
        object.key("Endpoint").string(var_2310);
    }
    if let Some(var_2311) = &input.protocol {
        object.key("Protocol").string(var_2311);
    }
}

pub fn serialize_structure_crate_model_aws_waf_web_acl_rule(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsWafWebAclRule,
) {
    if let Some(var_2312) = &input.action {
        let mut object_2313 = object.key("Action").start_object();
        crate::json_ser::serialize_structure_crate_model_waf_action(&mut object_2313, var_2312);
        object_2313.finish();
    }
    if let Some(var_2314) = &input.excluded_rules {
        let mut array_2315 = object.key("ExcludedRules").start_array();
        for item_2316 in var_2314 {
            {
                let mut object_2317 = array_2315.value().start_object();
                crate::json_ser::serialize_structure_crate_model_waf_excluded_rule(
                    &mut object_2317,
                    item_2316,
                );
                object_2317.finish();
            }
        }
        array_2315.finish();
    }
    if let Some(var_2318) = &input.override_action {
        let mut object_2319 = object.key("OverrideAction").start_object();
        crate::json_ser::serialize_structure_crate_model_waf_override_action(
            &mut object_2319,
            var_2318,
        );
        object_2319.finish();
    }
    if input.priority != 0 {
        object.key("Priority").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.priority).into()),
        );
    }
    if let Some(var_2320) = &input.rule_id {
        object.key("RuleId").string(var_2320);
    }
    if let Some(var_2321) = &input.r#type {
        object.key("Type").string(var_2321);
    }
}

pub fn serialize_structure_crate_model_aws_rds_db_cluster_associated_role(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsDbClusterAssociatedRole,
) {
    if let Some(var_2322) = &input.role_arn {
        object.key("RoleArn").string(var_2322);
    }
    if let Some(var_2323) = &input.status {
        object.key("Status").string(var_2323);
    }
}

pub fn serialize_structure_crate_model_aws_rds_db_cluster_option_group_membership(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsDbClusterOptionGroupMembership,
) {
    if let Some(var_2324) = &input.db_cluster_option_group_name {
        object.key("DbClusterOptionGroupName").string(var_2324);
    }
    if let Some(var_2325) = &input.status {
        object.key("Status").string(var_2325);
    }
}

pub fn serialize_structure_crate_model_aws_rds_db_cluster_member(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsDbClusterMember,
) {
    if input.is_cluster_writer {
        object
            .key("IsClusterWriter")
            .boolean(input.is_cluster_writer);
    }
    if input.promotion_tier != 0 {
        object.key("PromotionTier").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.promotion_tier).into()),
        );
    }
    if let Some(var_2326) = &input.db_instance_identifier {
        object.key("DbInstanceIdentifier").string(var_2326);
    }
    if let Some(var_2327) = &input.db_cluster_parameter_group_status {
        object.key("DbClusterParameterGroupStatus").string(var_2327);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_cluster_cluster_settings_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsClusterClusterSettingsDetails,
) {
    if let Some(var_2328) = &input.name {
        object.key("Name").string(var_2328);
    }
    if let Some(var_2329) = &input.value {
        object.key("Value").string(var_2329);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_cluster_configuration_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsClusterConfigurationDetails,
) {
    if let Some(var_2330) = &input.execute_command_configuration {
        let mut object_2331 = object.key("ExecuteCommandConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_cluster_configuration_execute_command_configuration_details(&mut object_2331, var_2330);
        object_2331.finish();
    }
}

pub fn serialize_structure_crate_model_aws_ecs_cluster_default_capacity_provider_strategy_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsClusterDefaultCapacityProviderStrategyDetails,
) {
    if input.base != 0 {
        object.key("Base").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.base).into()),
        );
    }
    if let Some(var_2332) = &input.capacity_provider {
        object.key("CapacityProvider").string(var_2332);
    }
    if input.weight != 0 {
        object.key("Weight").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.weight).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsDetails,
) {
    if let Some(var_2333) = &input.command {
        let mut array_2334 = object.key("Command").start_array();
        for item_2335 in var_2333 {
            {
                array_2334.value().string(item_2335);
            }
        }
        array_2334.finish();
    }
    if input.cpu != 0 {
        object.key("Cpu").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.cpu).into()),
        );
    }
    if let Some(var_2336) = &input.depends_on {
        let mut array_2337 = object.key("DependsOn").start_array();
        for item_2338 in var_2336 {
            {
                let mut object_2339 = array_2337.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_depends_on_details(&mut object_2339, item_2338);
                object_2339.finish();
            }
        }
        array_2337.finish();
    }
    if input.disable_networking {
        object
            .key("DisableNetworking")
            .boolean(input.disable_networking);
    }
    if let Some(var_2340) = &input.dns_search_domains {
        let mut array_2341 = object.key("DnsSearchDomains").start_array();
        for item_2342 in var_2340 {
            {
                array_2341.value().string(item_2342);
            }
        }
        array_2341.finish();
    }
    if let Some(var_2343) = &input.dns_servers {
        let mut array_2344 = object.key("DnsServers").start_array();
        for item_2345 in var_2343 {
            {
                array_2344.value().string(item_2345);
            }
        }
        array_2344.finish();
    }
    if let Some(var_2346) = &input.docker_labels {
        let mut object_2347 = object.key("DockerLabels").start_object();
        for (key_2348, value_2349) in var_2346 {
            {
                object_2347.key(key_2348).string(value_2349);
            }
        }
        object_2347.finish();
    }
    if let Some(var_2350) = &input.docker_security_options {
        let mut array_2351 = object.key("DockerSecurityOptions").start_array();
        for item_2352 in var_2350 {
            {
                array_2351.value().string(item_2352);
            }
        }
        array_2351.finish();
    }
    if let Some(var_2353) = &input.entry_point {
        let mut array_2354 = object.key("EntryPoint").start_array();
        for item_2355 in var_2353 {
            {
                array_2354.value().string(item_2355);
            }
        }
        array_2354.finish();
    }
    if let Some(var_2356) = &input.environment {
        let mut array_2357 = object.key("Environment").start_array();
        for item_2358 in var_2356 {
            {
                let mut object_2359 = array_2357.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_environment_details(&mut object_2359, item_2358);
                object_2359.finish();
            }
        }
        array_2357.finish();
    }
    if let Some(var_2360) = &input.environment_files {
        let mut array_2361 = object.key("EnvironmentFiles").start_array();
        for item_2362 in var_2360 {
            {
                let mut object_2363 = array_2361.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_environment_files_details(&mut object_2363, item_2362);
                object_2363.finish();
            }
        }
        array_2361.finish();
    }
    if input.essential {
        object.key("Essential").boolean(input.essential);
    }
    if let Some(var_2364) = &input.extra_hosts {
        let mut array_2365 = object.key("ExtraHosts").start_array();
        for item_2366 in var_2364 {
            {
                let mut object_2367 = array_2365.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_extra_hosts_details(&mut object_2367, item_2366);
                object_2367.finish();
            }
        }
        array_2365.finish();
    }
    if let Some(var_2368) = &input.firelens_configuration {
        let mut object_2369 = object.key("FirelensConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_firelens_configuration_details(&mut object_2369, var_2368);
        object_2369.finish();
    }
    if let Some(var_2370) = &input.health_check {
        let mut object_2371 = object.key("HealthCheck").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_health_check_details(&mut object_2371, var_2370);
        object_2371.finish();
    }
    if let Some(var_2372) = &input.hostname {
        object.key("Hostname").string(var_2372);
    }
    if let Some(var_2373) = &input.image {
        object.key("Image").string(var_2373);
    }
    if input.interactive {
        object.key("Interactive").boolean(input.interactive);
    }
    if let Some(var_2374) = &input.links {
        let mut array_2375 = object.key("Links").start_array();
        for item_2376 in var_2374 {
            {
                array_2375.value().string(item_2376);
            }
        }
        array_2375.finish();
    }
    if let Some(var_2377) = &input.linux_parameters {
        let mut object_2378 = object.key("LinuxParameters").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_linux_parameters_details(&mut object_2378, var_2377);
        object_2378.finish();
    }
    if let Some(var_2379) = &input.log_configuration {
        let mut object_2380 = object.key("LogConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_log_configuration_details(&mut object_2380, var_2379);
        object_2380.finish();
    }
    if input.memory != 0 {
        object.key("Memory").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.memory).into()),
        );
    }
    if input.memory_reservation != 0 {
        object.key("MemoryReservation").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.memory_reservation).into()),
        );
    }
    if let Some(var_2381) = &input.mount_points {
        let mut array_2382 = object.key("MountPoints").start_array();
        for item_2383 in var_2381 {
            {
                let mut object_2384 = array_2382.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_mount_points_details(&mut object_2384, item_2383);
                object_2384.finish();
            }
        }
        array_2382.finish();
    }
    if let Some(var_2385) = &input.name {
        object.key("Name").string(var_2385);
    }
    if let Some(var_2386) = &input.port_mappings {
        let mut array_2387 = object.key("PortMappings").start_array();
        for item_2388 in var_2386 {
            {
                let mut object_2389 = array_2387.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_port_mappings_details(&mut object_2389, item_2388);
                object_2389.finish();
            }
        }
        array_2387.finish();
    }
    if input.privileged {
        object.key("Privileged").boolean(input.privileged);
    }
    if input.pseudo_terminal {
        object.key("PseudoTerminal").boolean(input.pseudo_terminal);
    }
    if input.readonly_root_filesystem {
        object
            .key("ReadonlyRootFilesystem")
            .boolean(input.readonly_root_filesystem);
    }
    if let Some(var_2390) = &input.repository_credentials {
        let mut object_2391 = object.key("RepositoryCredentials").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_repository_credentials_details(&mut object_2391, var_2390);
        object_2391.finish();
    }
    if let Some(var_2392) = &input.resource_requirements {
        let mut array_2393 = object.key("ResourceRequirements").start_array();
        for item_2394 in var_2392 {
            {
                let mut object_2395 = array_2393.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_resource_requirements_details(&mut object_2395, item_2394);
                object_2395.finish();
            }
        }
        array_2393.finish();
    }
    if let Some(var_2396) = &input.secrets {
        let mut array_2397 = object.key("Secrets").start_array();
        for item_2398 in var_2396 {
            {
                let mut object_2399 = array_2397.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_secrets_details(&mut object_2399, item_2398);
                object_2399.finish();
            }
        }
        array_2397.finish();
    }
    if input.start_timeout != 0 {
        object.key("StartTimeout").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.start_timeout).into()),
        );
    }
    if input.stop_timeout != 0 {
        object.key("StopTimeout").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.stop_timeout).into()),
        );
    }
    if let Some(var_2400) = &input.system_controls {
        let mut array_2401 = object.key("SystemControls").start_array();
        for item_2402 in var_2400 {
            {
                let mut object_2403 = array_2401.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_system_controls_details(&mut object_2403, item_2402);
                object_2403.finish();
            }
        }
        array_2401.finish();
    }
    if let Some(var_2404) = &input.ulimits {
        let mut array_2405 = object.key("Ulimits").start_array();
        for item_2406 in var_2404 {
            {
                let mut object_2407 = array_2405.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_ulimits_details(&mut object_2407, item_2406);
                object_2407.finish();
            }
        }
        array_2405.finish();
    }
    if let Some(var_2408) = &input.user {
        object.key("User").string(var_2408);
    }
    if let Some(var_2409) = &input.volumes_from {
        let mut array_2410 = object.key("VolumesFrom").start_array();
        for item_2411 in var_2409 {
            {
                let mut object_2412 = array_2410.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_volumes_from_details(&mut object_2412, item_2411);
                object_2412.finish();
            }
        }
        array_2410.finish();
    }
    if let Some(var_2413) = &input.working_directory {
        object.key("WorkingDirectory").string(var_2413);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_inference_accelerators_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionInferenceAcceleratorsDetails,
) {
    if let Some(var_2414) = &input.device_name {
        object.key("DeviceName").string(var_2414);
    }
    if let Some(var_2415) = &input.device_type {
        object.key("DeviceType").string(var_2415);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_placement_constraints_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionPlacementConstraintsDetails,
) {
    if let Some(var_2416) = &input.expression {
        object.key("Expression").string(var_2416);
    }
    if let Some(var_2417) = &input.r#type {
        object.key("Type").string(var_2417);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_proxy_configuration_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionProxyConfigurationDetails,
) {
    if let Some(var_2418) = &input.container_name {
        object.key("ContainerName").string(var_2418);
    }
    if let Some(var_2419) = &input.proxy_configuration_properties {
        let mut array_2420 = object.key("ProxyConfigurationProperties").start_array();
        for item_2421 in var_2419 {
            {
                let mut object_2422 = array_2420.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_proxy_configuration_proxy_configuration_properties_details(&mut object_2422, item_2421);
                object_2422.finish();
            }
        }
        array_2420.finish();
    }
    if let Some(var_2423) = &input.r#type {
        object.key("Type").string(var_2423);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_volumes_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionVolumesDetails,
) {
    if let Some(var_2424) = &input.docker_volume_configuration {
        let mut object_2425 = object.key("DockerVolumeConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_volumes_docker_volume_configuration_details(&mut object_2425, var_2424);
        object_2425.finish();
    }
    if let Some(var_2426) = &input.efs_volume_configuration {
        let mut object_2427 = object.key("EfsVolumeConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_volumes_efs_volume_configuration_details(&mut object_2427, var_2426);
        object_2427.finish();
    }
    if let Some(var_2428) = &input.host {
        let mut object_2429 = object.key("Host").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_volumes_host_details(&mut object_2429, var_2428);
        object_2429.finish();
    }
    if let Some(var_2430) = &input.name {
        object.key("Name").string(var_2430);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_service_capacity_provider_strategy_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsServiceCapacityProviderStrategyDetails,
) {
    if input.base != 0 {
        object.key("Base").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.base).into()),
        );
    }
    if let Some(var_2431) = &input.capacity_provider {
        object.key("CapacityProvider").string(var_2431);
    }
    if input.weight != 0 {
        object.key("Weight").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.weight).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_ecs_service_deployment_configuration_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsServiceDeploymentConfigurationDetails,
) {
    if let Some(var_2432) = &input.deployment_circuit_breaker {
        let mut object_2433 = object.key("DeploymentCircuitBreaker").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_service_deployment_configuration_deployment_circuit_breaker_details(&mut object_2433, var_2432);
        object_2433.finish();
    }
    if input.maximum_percent != 0 {
        object.key("MaximumPercent").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.maximum_percent).into()),
        );
    }
    if input.minimum_healthy_percent != 0 {
        object.key("MinimumHealthyPercent").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.minimum_healthy_percent).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_ecs_service_deployment_controller_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsServiceDeploymentControllerDetails,
) {
    if let Some(var_2434) = &input.r#type {
        object.key("Type").string(var_2434);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_service_load_balancers_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsServiceLoadBalancersDetails,
) {
    if let Some(var_2435) = &input.container_name {
        object.key("ContainerName").string(var_2435);
    }
    if input.container_port != 0 {
        object.key("ContainerPort").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.container_port).into()),
        );
    }
    if let Some(var_2436) = &input.load_balancer_name {
        object.key("LoadBalancerName").string(var_2436);
    }
    if let Some(var_2437) = &input.target_group_arn {
        object.key("TargetGroupArn").string(var_2437);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_service_network_configuration_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsServiceNetworkConfigurationDetails,
) {
    if let Some(var_2438) = &input.aws_vpc_configuration {
        let mut object_2439 = object.key("AwsVpcConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_service_network_configuration_aws_vpc_configuration_details(&mut object_2439, var_2438);
        object_2439.finish();
    }
}

pub fn serialize_structure_crate_model_aws_ecs_service_placement_constraints_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsServicePlacementConstraintsDetails,
) {
    if let Some(var_2440) = &input.expression {
        object.key("Expression").string(var_2440);
    }
    if let Some(var_2441) = &input.r#type {
        object.key("Type").string(var_2441);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_service_placement_strategies_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsServicePlacementStrategiesDetails,
) {
    if let Some(var_2442) = &input.field {
        object.key("Field").string(var_2442);
    }
    if let Some(var_2443) = &input.r#type {
        object.key("Type").string(var_2443);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_service_service_registries_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsServiceServiceRegistriesDetails,
) {
    if let Some(var_2444) = &input.container_name {
        object.key("ContainerName").string(var_2444);
    }
    if input.container_port != 0 {
        object.key("ContainerPort").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.container_port).into()),
        );
    }
    if input.port != 0 {
        object.key("Port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.port).into()),
        );
    }
    if let Some(var_2445) = &input.registry_arn {
        object.key("RegistryArn").string(var_2445);
    }
}

pub fn serialize_structure_crate_model_aws_auto_scaling_launch_configuration_block_device_mappings_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsAutoScalingLaunchConfigurationBlockDeviceMappingsDetails,
) {
    if let Some(var_2446) = &input.device_name {
        object.key("DeviceName").string(var_2446);
    }
    if let Some(var_2447) = &input.ebs {
        let mut object_2448 = object.key("Ebs").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_auto_scaling_launch_configuration_block_device_mappings_ebs_details(&mut object_2448, var_2447);
        object_2448.finish();
    }
    if input.no_device {
        object.key("NoDevice").boolean(input.no_device);
    }
    if let Some(var_2449) = &input.virtual_name {
        object.key("VirtualName").string(var_2449);
    }
}

pub fn serialize_structure_crate_model_aws_auto_scaling_launch_configuration_instance_monitoring_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsAutoScalingLaunchConfigurationInstanceMonitoringDetails,
) {
    if input.enabled {
        object.key("Enabled").boolean(input.enabled);
    }
}

pub fn serialize_structure_crate_model_aws_ec2_vpn_connection_vgw_telemetry_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2VpnConnectionVgwTelemetryDetails,
) {
    if input.accepted_route_count != 0 {
        object.key("AcceptedRouteCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.accepted_route_count).into()),
        );
    }
    if let Some(var_2450) = &input.certificate_arn {
        object.key("CertificateArn").string(var_2450);
    }
    if let Some(var_2451) = &input.last_status_change {
        object.key("LastStatusChange").string(var_2451);
    }
    if let Some(var_2452) = &input.outside_ip_address {
        object.key("OutsideIpAddress").string(var_2452);
    }
    if let Some(var_2453) = &input.status {
        object.key("Status").string(var_2453);
    }
    if let Some(var_2454) = &input.status_message {
        object.key("StatusMessage").string(var_2454);
    }
}

pub fn serialize_structure_crate_model_aws_ec2_vpn_connection_options_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2VpnConnectionOptionsDetails,
) {
    if input.static_routes_only {
        object
            .key("StaticRoutesOnly")
            .boolean(input.static_routes_only);
    }
    if let Some(var_2455) = &input.tunnel_options {
        let mut array_2456 = object.key("TunnelOptions").start_array();
        for item_2457 in var_2455 {
            {
                let mut object_2458 = array_2456.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ec2_vpn_connection_options_tunnel_options_details(&mut object_2458, item_2457);
                object_2458.finish();
            }
        }
        array_2456.finish();
    }
}

pub fn serialize_structure_crate_model_aws_ec2_vpn_connection_routes_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2VpnConnectionRoutesDetails,
) {
    if let Some(var_2459) = &input.destination_cidr_block {
        object.key("DestinationCidrBlock").string(var_2459);
    }
    if let Some(var_2460) = &input.state {
        object.key("State").string(var_2460);
    }
}

pub fn serialize_structure_crate_model_aws_open_search_service_domain_encryption_at_rest_options_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsOpenSearchServiceDomainEncryptionAtRestOptionsDetails,
) {
    if input.enabled {
        object.key("Enabled").boolean(input.enabled);
    }
    if let Some(var_2461) = &input.kms_key_id {
        object.key("KmsKeyId").string(var_2461);
    }
}

pub fn serialize_structure_crate_model_aws_open_search_service_domain_node_to_node_encryption_options_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsOpenSearchServiceDomainNodeToNodeEncryptionOptionsDetails,
) {
    if input.enabled {
        object.key("Enabled").boolean(input.enabled);
    }
}

pub fn serialize_structure_crate_model_aws_open_search_service_domain_service_software_options_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsOpenSearchServiceDomainServiceSoftwareOptionsDetails,
) {
    if let Some(var_2462) = &input.automated_update_date {
        object.key("AutomatedUpdateDate").string(var_2462);
    }
    if input.cancellable {
        object.key("Cancellable").boolean(input.cancellable);
    }
    if let Some(var_2463) = &input.current_version {
        object.key("CurrentVersion").string(var_2463);
    }
    if let Some(var_2464) = &input.description {
        object.key("Description").string(var_2464);
    }
    if let Some(var_2465) = &input.new_version {
        object.key("NewVersion").string(var_2465);
    }
    if input.update_available {
        object
            .key("UpdateAvailable")
            .boolean(input.update_available);
    }
    if let Some(var_2466) = &input.update_status {
        object.key("UpdateStatus").string(var_2466);
    }
    if input.optional_deployment {
        object
            .key("OptionalDeployment")
            .boolean(input.optional_deployment);
    }
}

pub fn serialize_structure_crate_model_aws_open_search_service_domain_cluster_config_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsOpenSearchServiceDomainClusterConfigDetails,
) {
    if input.instance_count != 0 {
        object.key("InstanceCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.instance_count).into()),
        );
    }
    if input.warm_enabled {
        object.key("WarmEnabled").boolean(input.warm_enabled);
    }
    if input.warm_count != 0 {
        object.key("WarmCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.warm_count).into()),
        );
    }
    if input.dedicated_master_enabled {
        object
            .key("DedicatedMasterEnabled")
            .boolean(input.dedicated_master_enabled);
    }
    if let Some(var_2467) = &input.zone_awareness_config {
        let mut object_2468 = object.key("ZoneAwarenessConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_cluster_config_zone_awareness_config_details(&mut object_2468, var_2467);
        object_2468.finish();
    }
    if input.dedicated_master_count != 0 {
        object.key("DedicatedMasterCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.dedicated_master_count).into()),
        );
    }
    if let Some(var_2469) = &input.instance_type {
        object.key("InstanceType").string(var_2469);
    }
    if let Some(var_2470) = &input.warm_type {
        object.key("WarmType").string(var_2470);
    }
    if input.zone_awareness_enabled {
        object
            .key("ZoneAwarenessEnabled")
            .boolean(input.zone_awareness_enabled);
    }
    if let Some(var_2471) = &input.dedicated_master_type {
        object.key("DedicatedMasterType").string(var_2471);
    }
}

pub fn serialize_structure_crate_model_aws_open_search_service_domain_domain_endpoint_options_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsOpenSearchServiceDomainDomainEndpointOptionsDetails,
) {
    if let Some(var_2472) = &input.custom_endpoint_certificate_arn {
        object.key("CustomEndpointCertificateArn").string(var_2472);
    }
    if input.custom_endpoint_enabled {
        object
            .key("CustomEndpointEnabled")
            .boolean(input.custom_endpoint_enabled);
    }
    if input.enforce_https {
        object.key("EnforceHTTPS").boolean(input.enforce_https);
    }
    if let Some(var_2473) = &input.custom_endpoint {
        object.key("CustomEndpoint").string(var_2473);
    }
    if let Some(var_2474) = &input.tls_security_policy {
        object.key("TLSSecurityPolicy").string(var_2474);
    }
}

pub fn serialize_structure_crate_model_aws_open_search_service_domain_vpc_options_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsOpenSearchServiceDomainVpcOptionsDetails,
) {
    if let Some(var_2475) = &input.security_group_ids {
        let mut array_2476 = object.key("SecurityGroupIds").start_array();
        for item_2477 in var_2475 {
            {
                array_2476.value().string(item_2477);
            }
        }
        array_2476.finish();
    }
    if let Some(var_2478) = &input.subnet_ids {
        let mut array_2479 = object.key("SubnetIds").start_array();
        for item_2480 in var_2478 {
            {
                array_2479.value().string(item_2480);
            }
        }
        array_2479.finish();
    }
}

pub fn serialize_structure_crate_model_aws_open_search_service_domain_log_publishing_options_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsOpenSearchServiceDomainLogPublishingOptionsDetails,
) {
    if let Some(var_2481) = &input.index_slow_logs {
        let mut object_2482 = object.key("IndexSlowLogs").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_log_publishing_option(&mut object_2482, var_2481);
        object_2482.finish();
    }
    if let Some(var_2483) = &input.search_slow_logs {
        let mut object_2484 = object.key("SearchSlowLogs").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_log_publishing_option(&mut object_2484, var_2483);
        object_2484.finish();
    }
    if let Some(var_2485) = &input.audit_logs {
        let mut object_2486 = object.key("AuditLogs").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_open_search_service_domain_log_publishing_option(&mut object_2486, var_2485);
        object_2486.finish();
    }
}

pub fn serialize_structure_crate_model_aws_ec2_vpc_endpoint_service_service_type_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2VpcEndpointServiceServiceTypeDetails,
) {
    if let Some(var_2487) = &input.service_type {
        object.key("ServiceType").string(var_2487);
    }
}

pub fn serialize_structure_crate_model_aws_waf_rate_based_rule_match_predicate(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsWafRateBasedRuleMatchPredicate,
) {
    if let Some(var_2488) = &input.data_id {
        object.key("DataId").string(var_2488);
    }
    if input.negated {
        object.key("Negated").boolean(input.negated);
    }
    if let Some(var_2489) = &input.r#type {
        object.key("Type").string(var_2489);
    }
}

pub fn serialize_structure_crate_model_aws_waf_regional_rate_based_rule_match_predicate(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsWafRegionalRateBasedRuleMatchPredicate,
) {
    if let Some(var_2490) = &input.data_id {
        object.key("DataId").string(var_2490);
    }
    if input.negated {
        object.key("Negated").boolean(input.negated);
    }
    if let Some(var_2491) = &input.r#type {
        object.key("Type").string(var_2491);
    }
}

pub fn serialize_structure_crate_model_aws_ecr_repository_image_scanning_configuration_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcrRepositoryImageScanningConfigurationDetails,
) {
    if input.scan_on_push {
        object.key("ScanOnPush").boolean(input.scan_on_push);
    }
}

pub fn serialize_structure_crate_model_aws_ecr_repository_lifecycle_policy_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcrRepositoryLifecyclePolicyDetails,
) {
    if let Some(var_2492) = &input.lifecycle_policy_text {
        object.key("LifecyclePolicyText").string(var_2492);
    }
    if let Some(var_2493) = &input.registry_id {
        object.key("RegistryId").string(var_2493);
    }
}

pub fn serialize_structure_crate_model_aws_eks_cluster_resources_vpc_config_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEksClusterResourcesVpcConfigDetails,
) {
    if let Some(var_2494) = &input.security_group_ids {
        let mut array_2495 = object.key("SecurityGroupIds").start_array();
        for item_2496 in var_2494 {
            {
                array_2495.value().string(item_2496);
            }
        }
        array_2495.finish();
    }
    if let Some(var_2497) = &input.subnet_ids {
        let mut array_2498 = object.key("SubnetIds").start_array();
        for item_2499 in var_2497 {
            {
                array_2498.value().string(item_2499);
            }
        }
        array_2498.finish();
    }
}

pub fn serialize_structure_crate_model_aws_eks_cluster_logging_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEksClusterLoggingDetails,
) {
    if let Some(var_2500) = &input.cluster_logging {
        let mut array_2501 = object.key("ClusterLogging").start_array();
        for item_2502 in var_2500 {
            {
                let mut object_2503 = array_2501.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_eks_cluster_logging_cluster_logging_details(&mut object_2503, item_2502);
                object_2503.finish();
            }
        }
        array_2501.finish();
    }
}

pub fn serialize_structure_crate_model_ip_organization_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::IpOrganizationDetails,
) {
    if input.asn != 0 {
        object.key("Asn").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.asn).into()),
        );
    }
    if let Some(var_2504) = &input.asn_org {
        object.key("AsnOrg").string(var_2504);
    }
    if let Some(var_2505) = &input.isp {
        object.key("Isp").string(var_2505);
    }
    if let Some(var_2506) = &input.org {
        object.key("Org").string(var_2506);
    }
}

pub fn serialize_structure_crate_model_country(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Country,
) {
    if let Some(var_2507) = &input.country_code {
        object.key("CountryCode").string(var_2507);
    }
    if let Some(var_2508) = &input.country_name {
        object.key("CountryName").string(var_2508);
    }
}

pub fn serialize_structure_crate_model_city(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::City,
) {
    if let Some(var_2509) = &input.city_name {
        object.key("CityName").string(var_2509);
    }
}

pub fn serialize_structure_crate_model_geo_location(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GeoLocation,
) {
    if input.lon != 0.0 {
        object.key("Lon").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.lon).into()),
        );
    }
    if input.lat != 0.0 {
        object.key("Lat").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.lat).into()),
        );
    }
}

pub fn serialize_structure_crate_model_action_local_ip_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ActionLocalIpDetails,
) {
    if let Some(var_2510) = &input.ip_address_v4 {
        object.key("IpAddressV4").string(var_2510);
    }
}

pub fn serialize_structure_crate_model_sensitive_data_detections(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SensitiveDataDetections,
) {
    if input.count != 0 {
        object.key("Count").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.count).into()),
        );
    }
    if let Some(var_2511) = &input.r#type {
        object.key("Type").string(var_2511);
    }
    if let Some(var_2512) = &input.occurrences {
        let mut object_2513 = object.key("Occurrences").start_object();
        crate::json_ser::serialize_structure_crate_model_occurrences(&mut object_2513, var_2512);
        object_2513.finish();
    }
}

pub fn serialize_structure_crate_model_custom_data_identifiers_detections(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CustomDataIdentifiersDetections,
) {
    if input.count != 0 {
        object.key("Count").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.count).into()),
        );
    }
    if let Some(var_2514) = &input.arn {
        object.key("Arn").string(var_2514);
    }
    if let Some(var_2515) = &input.name {
        object.key("Name").string(var_2515);
    }
    if let Some(var_2516) = &input.occurrences {
        let mut object_2517 = object.key("Occurrences").start_object();
        crate::json_ser::serialize_structure_crate_model_occurrences(&mut object_2517, var_2516);
        object_2517.finish();
    }
}

pub fn serialize_structure_crate_model_aws_code_build_project_environment_environment_variables_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCodeBuildProjectEnvironmentEnvironmentVariablesDetails,
) {
    if let Some(var_2518) = &input.name {
        object.key("Name").string(var_2518);
    }
    if let Some(var_2519) = &input.r#type {
        object.key("Type").string(var_2519);
    }
    if let Some(var_2520) = &input.value {
        object.key("Value").string(var_2520);
    }
}

pub fn serialize_structure_crate_model_aws_code_build_project_environment_registry_credential(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCodeBuildProjectEnvironmentRegistryCredential,
) {
    if let Some(var_2521) = &input.credential {
        object.key("Credential").string(var_2521);
    }
    if let Some(var_2522) = &input.credential_provider {
        object.key("CredentialProvider").string(var_2522);
    }
}

pub fn serialize_structure_crate_model_aws_code_build_project_logs_config_cloud_watch_logs_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCodeBuildProjectLogsConfigCloudWatchLogsDetails,
) {
    if let Some(var_2523) = &input.group_name {
        object.key("GroupName").string(var_2523);
    }
    if let Some(var_2524) = &input.status {
        object.key("Status").string(var_2524);
    }
    if let Some(var_2525) = &input.stream_name {
        object.key("StreamName").string(var_2525);
    }
}

pub fn serialize_structure_crate_model_aws_code_build_project_logs_config_s3_logs_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCodeBuildProjectLogsConfigS3LogsDetails,
) {
    if input.encryption_disabled {
        object
            .key("EncryptionDisabled")
            .boolean(input.encryption_disabled);
    }
    if let Some(var_2526) = &input.location {
        object.key("Location").string(var_2526);
    }
    if let Some(var_2527) = &input.status {
        object.key("Status").string(var_2527);
    }
}

pub fn serialize_structure_crate_model_aws_cloud_front_distribution_cache_behavior(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCloudFrontDistributionCacheBehavior,
) {
    if let Some(var_2528) = &input.viewer_protocol_policy {
        object.key("ViewerProtocolPolicy").string(var_2528);
    }
}

pub fn serialize_structure_crate_model_aws_cloud_front_distribution_origin_item(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCloudFrontDistributionOriginItem,
) {
    if let Some(var_2529) = &input.domain_name {
        object.key("DomainName").string(var_2529);
    }
    if let Some(var_2530) = &input.id {
        object.key("Id").string(var_2530);
    }
    if let Some(var_2531) = &input.origin_path {
        object.key("OriginPath").string(var_2531);
    }
    if let Some(var_2532) = &input.s3_origin_config {
        let mut object_2533 = object.key("S3OriginConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_origin_s3_origin_config(&mut object_2533, var_2532);
        object_2533.finish();
    }
}

pub fn serialize_structure_crate_model_aws_cloud_front_distribution_origin_group(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCloudFrontDistributionOriginGroup,
) {
    if let Some(var_2534) = &input.failover_criteria {
        let mut object_2535 = object.key("FailoverCriteria").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_origin_group_failover(&mut object_2535, var_2534);
        object_2535.finish();
    }
}

pub fn serialize_structure_crate_model_aws_ec2_security_group_user_id_group_pair(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2SecurityGroupUserIdGroupPair,
) {
    if let Some(var_2536) = &input.group_id {
        object.key("GroupId").string(var_2536);
    }
    if let Some(var_2537) = &input.group_name {
        object.key("GroupName").string(var_2537);
    }
    if let Some(var_2538) = &input.peering_status {
        object.key("PeeringStatus").string(var_2538);
    }
    if let Some(var_2539) = &input.user_id {
        object.key("UserId").string(var_2539);
    }
    if let Some(var_2540) = &input.vpc_id {
        object.key("VpcId").string(var_2540);
    }
    if let Some(var_2541) = &input.vpc_peering_connection_id {
        object.key("VpcPeeringConnectionId").string(var_2541);
    }
}

pub fn serialize_structure_crate_model_aws_ec2_security_group_ip_range(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2SecurityGroupIpRange,
) {
    if let Some(var_2542) = &input.cidr_ip {
        object.key("CidrIp").string(var_2542);
    }
}

pub fn serialize_structure_crate_model_aws_ec2_security_group_ipv6_range(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2SecurityGroupIpv6Range,
) {
    if let Some(var_2543) = &input.cidr_ipv6 {
        object.key("CidrIpv6").string(var_2543);
    }
}

pub fn serialize_structure_crate_model_aws_ec2_security_group_prefix_list_id(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2SecurityGroupPrefixListId,
) {
    if let Some(var_2544) = &input.prefix_list_id {
        object.key("PrefixListId").string(var_2544);
    }
}

pub fn serialize_structure_crate_model_icmp_type_code(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::IcmpTypeCode,
) {
    if input.code != 0 {
        object.key("Code").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.code).into()),
        );
    }
    if input.r#type != 0 {
        object.key("Type").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.r#type).into()),
        );
    }
}

pub fn serialize_structure_crate_model_port_range_from_to(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::PortRangeFromTo,
) {
    if input.from != 0 {
        object.key("From").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.from).into()),
        );
    }
    if input.to != 0 {
        object.key("To").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.to).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_elasticsearch_domain_elasticsearch_cluster_config_zone_awareness_config_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElasticsearchDomainElasticsearchClusterConfigZoneAwarenessConfigDetails,
) {
    if input.availability_zone_count != 0 {
        object.key("AvailabilityZoneCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.availability_zone_count).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_elasticsearch_domain_log_publishing_options_log_config(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElasticsearchDomainLogPublishingOptionsLogConfig,
) {
    if let Some(var_2545) = &input.cloud_watch_logs_log_group_arn {
        object.key("CloudWatchLogsLogGroupArn").string(var_2545);
    }
    if input.enabled {
        object.key("Enabled").boolean(input.enabled);
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_server_side_encryption_rule(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketServerSideEncryptionRule,
) {
    if let Some(var_2546) = &input.apply_server_side_encryption_by_default {
        let mut object_2547 = object
            .key("ApplyServerSideEncryptionByDefault")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_server_side_encryption_by_default(&mut object_2547, var_2546);
        object_2547.finish();
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketBucketLifecycleConfigurationRulesDetails,
) {
    if let Some(var_2548) = &input.abort_incomplete_multipart_upload {
        let mut object_2549 = object.key("AbortIncompleteMultipartUpload").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_abort_incomplete_multipart_upload_details(&mut object_2549, var_2548);
        object_2549.finish();
    }
    if let Some(var_2550) = &input.expiration_date {
        object.key("ExpirationDate").string(var_2550);
    }
    if input.expiration_in_days != 0 {
        object.key("ExpirationInDays").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.expiration_in_days).into()),
        );
    }
    if input.expired_object_delete_marker {
        object
            .key("ExpiredObjectDeleteMarker")
            .boolean(input.expired_object_delete_marker);
    }
    if let Some(var_2551) = &input.filter {
        let mut object_2552 = object.key("Filter").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_details(&mut object_2552, var_2551);
        object_2552.finish();
    }
    if let Some(var_2553) = &input.id {
        object.key("ID").string(var_2553);
    }
    if input.noncurrent_version_expiration_in_days != 0 {
        object.key("NoncurrentVersionExpirationInDays").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.noncurrent_version_expiration_in_days).into()),
        );
    }
    if let Some(var_2554) = &input.noncurrent_version_transitions {
        let mut array_2555 = object.key("NoncurrentVersionTransitions").start_array();
        for item_2556 in var_2554 {
            {
                let mut object_2557 = array_2555.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_noncurrent_version_transitions_details(&mut object_2557, item_2556);
                object_2557.finish();
            }
        }
        array_2555.finish();
    }
    if let Some(var_2558) = &input.prefix {
        object.key("Prefix").string(var_2558);
    }
    if let Some(var_2559) = &input.status {
        object.key("Status").string(var_2559);
    }
    if let Some(var_2560) = &input.transitions {
        let mut array_2561 = object.key("Transitions").start_array();
        for item_2562 in var_2560 {
            {
                let mut object_2563 = array_2561.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_transitions_details(&mut object_2563, item_2562);
                object_2563.finish();
            }
        }
        array_2561.finish();
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_website_configuration_redirect_to(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketWebsiteConfigurationRedirectTo,
) {
    if let Some(var_2564) = &input.hostname {
        object.key("Hostname").string(var_2564);
    }
    if let Some(var_2565) = &input.protocol {
        object.key("Protocol").string(var_2565);
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_website_configuration_routing_rule(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketWebsiteConfigurationRoutingRule,
) {
    if let Some(var_2566) = &input.condition {
        let mut object_2567 = object.key("Condition").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_website_configuration_routing_rule_condition(&mut object_2567, var_2566);
        object_2567.finish();
    }
    if let Some(var_2568) = &input.redirect {
        let mut object_2569 = object.key("Redirect").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_website_configuration_routing_rule_redirect(&mut object_2569, var_2568);
        object_2569.finish();
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_notification_configuration_detail(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketNotificationConfigurationDetail,
) {
    if let Some(var_2570) = &input.events {
        let mut array_2571 = object.key("Events").start_array();
        for item_2572 in var_2570 {
            {
                array_2571.value().string(item_2572);
            }
        }
        array_2571.finish();
    }
    if let Some(var_2573) = &input.filter {
        let mut object_2574 = object.key("Filter").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_notification_configuration_filter(&mut object_2574, var_2573);
        object_2574.finish();
    }
    if let Some(var_2575) = &input.destination {
        object.key("Destination").string(var_2575);
    }
    if let Some(var_2576) = &input.r#type {
        object.key("Type").string(var_2576);
    }
}

pub fn serialize_structure_crate_model_aws_iam_access_key_session_context_attributes(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsIamAccessKeySessionContextAttributes,
) {
    if input.mfa_authenticated {
        object
            .key("MfaAuthenticated")
            .boolean(input.mfa_authenticated);
    }
    if let Some(var_2577) = &input.creation_date {
        object.key("CreationDate").string(var_2577);
    }
}

pub fn serialize_structure_crate_model_aws_iam_access_key_session_context_session_issuer(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsIamAccessKeySessionContextSessionIssuer,
) {
    if let Some(var_2578) = &input.r#type {
        object.key("Type").string(var_2578);
    }
    if let Some(var_2579) = &input.principal_id {
        object.key("PrincipalId").string(var_2579);
    }
    if let Some(var_2580) = &input.arn {
        object.key("Arn").string(var_2580);
    }
    if let Some(var_2581) = &input.account_id {
        object.key("AccountId").string(var_2581);
    }
    if let Some(var_2582) = &input.user_name {
        object.key("UserName").string(var_2582);
    }
}

pub fn serialize_structure_crate_model_aws_dynamo_db_table_projection(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsDynamoDbTableProjection,
) {
    if let Some(var_2583) = &input.non_key_attributes {
        let mut array_2584 = object.key("NonKeyAttributes").start_array();
        for item_2585 in var_2583 {
            {
                array_2584.value().string(item_2585);
            }
        }
        array_2584.finish();
    }
    if let Some(var_2586) = &input.projection_type {
        object.key("ProjectionType").string(var_2586);
    }
}

pub fn serialize_structure_crate_model_aws_dynamo_db_table_replica_global_secondary_index(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsDynamoDbTableReplicaGlobalSecondaryIndex,
) {
    if let Some(var_2587) = &input.index_name {
        object.key("IndexName").string(var_2587);
    }
    if let Some(var_2588) = &input.provisioned_throughput_override {
        let mut object_2589 = object.key("ProvisionedThroughputOverride").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_dynamo_db_table_provisioned_throughput_override(&mut object_2589, var_2588);
        object_2589.finish();
    }
}

pub fn serialize_structure_crate_model_aws_dynamo_db_table_provisioned_throughput_override(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsDynamoDbTableProvisionedThroughputOverride,
) {
    if input.read_capacity_units != 0 {
        object.key("ReadCapacityUnits").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.read_capacity_units).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_ssm_compliance_summary(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsSsmComplianceSummary,
) {
    if let Some(var_2590) = &input.status {
        object.key("Status").string(var_2590);
    }
    if input.compliant_critical_count != 0 {
        object.key("CompliantCriticalCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.compliant_critical_count).into()),
        );
    }
    if input.compliant_high_count != 0 {
        object.key("CompliantHighCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.compliant_high_count).into()),
        );
    }
    if input.compliant_medium_count != 0 {
        object.key("CompliantMediumCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.compliant_medium_count).into()),
        );
    }
    if let Some(var_2591) = &input.execution_type {
        object.key("ExecutionType").string(var_2591);
    }
    if input.non_compliant_critical_count != 0 {
        object.key("NonCompliantCriticalCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.non_compliant_critical_count).into()),
        );
    }
    if input.compliant_informational_count != 0 {
        object.key("CompliantInformationalCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.compliant_informational_count).into()),
        );
    }
    if input.non_compliant_informational_count != 0 {
        object.key("NonCompliantInformationalCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.non_compliant_informational_count).into()),
        );
    }
    if input.compliant_unspecified_count != 0 {
        object.key("CompliantUnspecifiedCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.compliant_unspecified_count).into()),
        );
    }
    if input.non_compliant_low_count != 0 {
        object.key("NonCompliantLowCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.non_compliant_low_count).into()),
        );
    }
    if input.non_compliant_high_count != 0 {
        object.key("NonCompliantHighCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.non_compliant_high_count).into()),
        );
    }
    if input.compliant_low_count != 0 {
        object.key("CompliantLowCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.compliant_low_count).into()),
        );
    }
    if let Some(var_2592) = &input.compliance_type {
        object.key("ComplianceType").string(var_2592);
    }
    if let Some(var_2593) = &input.patch_baseline_id {
        object.key("PatchBaselineId").string(var_2593);
    }
    if let Some(var_2594) = &input.overall_severity {
        object.key("OverallSeverity").string(var_2594);
    }
    if input.non_compliant_medium_count != 0 {
        object.key("NonCompliantMediumCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.non_compliant_medium_count).into()),
        );
    }
    if input.non_compliant_unspecified_count != 0 {
        object.key("NonCompliantUnspecifiedCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.non_compliant_unspecified_count).into()),
        );
    }
    if let Some(var_2595) = &input.patch_group {
        object.key("PatchGroup").string(var_2595);
    }
}

pub fn serialize_structure_crate_model_aws_certificate_manager_certificate_resource_record(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCertificateManagerCertificateResourceRecord,
) {
    if let Some(var_2596) = &input.name {
        object.key("Name").string(var_2596);
    }
    if let Some(var_2597) = &input.r#type {
        object.key("Type").string(var_2597);
    }
    if let Some(var_2598) = &input.value {
        object.key("Value").string(var_2598);
    }
}

pub fn serialize_structure_crate_model_aws_redshift_cluster_cluster_parameter_status(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRedshiftClusterClusterParameterStatus,
) {
    if let Some(var_2599) = &input.parameter_name {
        object.key("ParameterName").string(var_2599);
    }
    if let Some(var_2600) = &input.parameter_apply_status {
        object.key("ParameterApplyStatus").string(var_2600);
    }
    if let Some(var_2601) = &input.parameter_apply_error_description {
        object
            .key("ParameterApplyErrorDescription")
            .string(var_2601);
    }
}

pub fn serialize_structure_crate_model_aws_elb_load_balancer_listener(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElbLoadBalancerListener,
) {
    if input.instance_port != 0 {
        object.key("InstancePort").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.instance_port).into()),
        );
    }
    if let Some(var_2602) = &input.instance_protocol {
        object.key("InstanceProtocol").string(var_2602);
    }
    if input.load_balancer_port != 0 {
        object.key("LoadBalancerPort").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.load_balancer_port).into()),
        );
    }
    if let Some(var_2603) = &input.protocol {
        object.key("Protocol").string(var_2603);
    }
    if let Some(var_2604) = &input.ssl_certificate_id {
        object.key("SslCertificateId").string(var_2604);
    }
}

pub fn serialize_structure_crate_model_aws_elb_load_balancer_access_log(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElbLoadBalancerAccessLog,
) {
    if input.emit_interval != 0 {
        object.key("EmitInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.emit_interval).into()),
        );
    }
    if input.enabled {
        object.key("Enabled").boolean(input.enabled);
    }
    if let Some(var_2605) = &input.s3_bucket_name {
        object.key("S3BucketName").string(var_2605);
    }
    if let Some(var_2606) = &input.s3_bucket_prefix {
        object.key("S3BucketPrefix").string(var_2606);
    }
}

pub fn serialize_structure_crate_model_aws_elb_load_balancer_connection_draining(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElbLoadBalancerConnectionDraining,
) {
    if input.enabled {
        object.key("Enabled").boolean(input.enabled);
    }
    if input.timeout != 0 {
        object.key("Timeout").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.timeout).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_elb_load_balancer_connection_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElbLoadBalancerConnectionSettings,
) {
    if input.idle_timeout != 0 {
        object.key("IdleTimeout").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.idle_timeout).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_elb_load_balancer_cross_zone_load_balancing(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElbLoadBalancerCrossZoneLoadBalancing,
) {
    if input.enabled {
        object.key("Enabled").boolean(input.enabled);
    }
}

pub fn serialize_structure_crate_model_aws_elb_app_cookie_stickiness_policy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElbAppCookieStickinessPolicy,
) {
    if let Some(var_2607) = &input.cookie_name {
        object.key("CookieName").string(var_2607);
    }
    if let Some(var_2608) = &input.policy_name {
        object.key("PolicyName").string(var_2608);
    }
}

pub fn serialize_structure_crate_model_aws_elb_lb_cookie_stickiness_policy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsElbLbCookieStickinessPolicy,
) {
    if input.cookie_expiration_period != 0 {
        object.key("CookieExpirationPeriod").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.cookie_expiration_period).into()),
        );
    }
    if let Some(var_2609) = &input.policy_name {
        object.key("PolicyName").string(var_2609);
    }
}

pub fn serialize_structure_crate_model_aws_iam_instance_profile_role(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsIamInstanceProfileRole,
) {
    if let Some(var_2610) = &input.arn {
        object.key("Arn").string(var_2610);
    }
    if let Some(var_2611) = &input.assume_role_policy_document {
        object.key("AssumeRolePolicyDocument").string(var_2611);
    }
    if let Some(var_2612) = &input.create_date {
        object.key("CreateDate").string(var_2612);
    }
    if let Some(var_2613) = &input.path {
        object.key("Path").string(var_2613);
    }
    if let Some(var_2614) = &input.role_id {
        object.key("RoleId").string(var_2614);
    }
    if let Some(var_2615) = &input.role_name {
        object.key("RoleName").string(var_2615);
    }
}

pub fn serialize_structure_crate_model_aws_lambda_function_environment_error(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsLambdaFunctionEnvironmentError,
) {
    if let Some(var_2616) = &input.error_code {
        object.key("ErrorCode").string(var_2616);
    }
    if let Some(var_2617) = &input.message {
        object.key("Message").string(var_2617);
    }
}

pub fn serialize_structure_crate_model_aws_rds_db_subnet_group_subnet(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsDbSubnetGroupSubnet,
) {
    if let Some(var_2618) = &input.subnet_identifier {
        object.key("SubnetIdentifier").string(var_2618);
    }
    if let Some(var_2619) = &input.subnet_availability_zone {
        let mut object_2620 = object.key("SubnetAvailabilityZone").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_rds_db_subnet_group_subnet_availability_zone(&mut object_2620, var_2619);
        object_2620.finish();
    }
    if let Some(var_2621) = &input.subnet_status {
        object.key("SubnetStatus").string(var_2621);
    }
}

pub fn serialize_structure_crate_model_aws_rds_pending_cloud_watch_logs_exports(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsPendingCloudWatchLogsExports,
) {
    if let Some(var_2622) = &input.log_types_to_enable {
        let mut array_2623 = object.key("LogTypesToEnable").start_array();
        for item_2624 in var_2622 {
            {
                array_2623.value().string(item_2624);
            }
        }
        array_2623.finish();
    }
    if let Some(var_2625) = &input.log_types_to_disable {
        let mut array_2626 = object.key("LogTypesToDisable").start_array();
        for item_2627 in var_2625 {
            {
                array_2626.value().string(item_2627);
            }
        }
        array_2626.finish();
    }
}

pub fn serialize_structure_crate_model_waf_action(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::WafAction,
) {
    if let Some(var_2628) = &input.r#type {
        object.key("Type").string(var_2628);
    }
}

pub fn serialize_structure_crate_model_waf_excluded_rule(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::WafExcludedRule,
) {
    if let Some(var_2629) = &input.rule_id {
        object.key("RuleId").string(var_2629);
    }
}

pub fn serialize_structure_crate_model_waf_override_action(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::WafOverrideAction,
) {
    if let Some(var_2630) = &input.r#type {
        object.key("Type").string(var_2630);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_cluster_configuration_execute_command_configuration_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsClusterConfigurationExecuteCommandConfigurationDetails,
) {
    if let Some(var_2631) = &input.kms_key_id {
        object.key("KmsKeyId").string(var_2631);
    }
    if let Some(var_2632) = &input.log_configuration {
        let mut object_2633 = object.key("LogConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_cluster_configuration_execute_command_configuration_log_configuration_details(&mut object_2633, var_2632);
        object_2633.finish();
    }
    if let Some(var_2634) = &input.logging {
        object.key("Logging").string(var_2634);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_depends_on_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsDependsOnDetails,
) {
    if let Some(var_2635) = &input.condition {
        object.key("Condition").string(var_2635);
    }
    if let Some(var_2636) = &input.container_name {
        object.key("ContainerName").string(var_2636);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_environment_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsEnvironmentDetails,
) {
    if let Some(var_2637) = &input.name {
        object.key("Name").string(var_2637);
    }
    if let Some(var_2638) = &input.value {
        object.key("Value").string(var_2638);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_environment_files_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsEnvironmentFilesDetails,
) {
    if let Some(var_2639) = &input.r#type {
        object.key("Type").string(var_2639);
    }
    if let Some(var_2640) = &input.value {
        object.key("Value").string(var_2640);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_extra_hosts_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsExtraHostsDetails,
) {
    if let Some(var_2641) = &input.hostname {
        object.key("Hostname").string(var_2641);
    }
    if let Some(var_2642) = &input.ip_address {
        object.key("IpAddress").string(var_2642);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_firelens_configuration_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsFirelensConfigurationDetails,
) {
    if let Some(var_2643) = &input.options {
        let mut object_2644 = object.key("Options").start_object();
        for (key_2645, value_2646) in var_2643 {
            {
                object_2644.key(key_2645).string(value_2646);
            }
        }
        object_2644.finish();
    }
    if let Some(var_2647) = &input.r#type {
        object.key("Type").string(var_2647);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_health_check_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsHealthCheckDetails,
) {
    if let Some(var_2648) = &input.command {
        let mut array_2649 = object.key("Command").start_array();
        for item_2650 in var_2648 {
            {
                array_2649.value().string(item_2650);
            }
        }
        array_2649.finish();
    }
    if input.interval != 0 {
        object.key("Interval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.interval).into()),
        );
    }
    if input.retries != 0 {
        object.key("Retries").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.retries).into()),
        );
    }
    if input.start_period != 0 {
        object.key("StartPeriod").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.start_period).into()),
        );
    }
    if input.timeout != 0 {
        object.key("Timeout").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.timeout).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_linux_parameters_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsLinuxParametersDetails,
) {
    if let Some(var_2651) = &input.capabilities {
        let mut object_2652 = object.key("Capabilities").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_linux_parameters_capabilities_details(&mut object_2652, var_2651);
        object_2652.finish();
    }
    if let Some(var_2653) = &input.devices {
        let mut array_2654 = object.key("Devices").start_array();
        for item_2655 in var_2653 {
            {
                let mut object_2656 = array_2654.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_linux_parameters_devices_details(&mut object_2656, item_2655);
                object_2656.finish();
            }
        }
        array_2654.finish();
    }
    if input.init_process_enabled {
        object
            .key("InitProcessEnabled")
            .boolean(input.init_process_enabled);
    }
    if input.max_swap != 0 {
        object.key("MaxSwap").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_swap).into()),
        );
    }
    if input.shared_memory_size != 0 {
        object.key("SharedMemorySize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.shared_memory_size).into()),
        );
    }
    if input.swappiness != 0 {
        object.key("Swappiness").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.swappiness).into()),
        );
    }
    if let Some(var_2657) = &input.tmpfs {
        let mut array_2658 = object.key("Tmpfs").start_array();
        for item_2659 in var_2657 {
            {
                let mut object_2660 = array_2658.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_linux_parameters_tmpfs_details(&mut object_2660, item_2659);
                object_2660.finish();
            }
        }
        array_2658.finish();
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_log_configuration_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsLogConfigurationDetails,
) {
    if let Some(var_2661) = &input.log_driver {
        object.key("LogDriver").string(var_2661);
    }
    if let Some(var_2662) = &input.options {
        let mut object_2663 = object.key("Options").start_object();
        for (key_2664, value_2665) in var_2662 {
            {
                object_2663.key(key_2664).string(value_2665);
            }
        }
        object_2663.finish();
    }
    if let Some(var_2666) = &input.secret_options {
        let mut array_2667 = object.key("SecretOptions").start_array();
        for item_2668 in var_2666 {
            {
                let mut object_2669 = array_2667.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_log_configuration_secret_options_details(&mut object_2669, item_2668);
                object_2669.finish();
            }
        }
        array_2667.finish();
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_mount_points_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsMountPointsDetails,
) {
    if let Some(var_2670) = &input.container_path {
        object.key("ContainerPath").string(var_2670);
    }
    if input.read_only {
        object.key("ReadOnly").boolean(input.read_only);
    }
    if let Some(var_2671) = &input.source_volume {
        object.key("SourceVolume").string(var_2671);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_port_mappings_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsPortMappingsDetails,
) {
    if input.container_port != 0 {
        object.key("ContainerPort").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.container_port).into()),
        );
    }
    if input.host_port != 0 {
        object.key("HostPort").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.host_port).into()),
        );
    }
    if let Some(var_2672) = &input.protocol {
        object.key("Protocol").string(var_2672);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_repository_credentials_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsRepositoryCredentialsDetails,
) {
    if let Some(var_2673) = &input.credentials_parameter {
        object.key("CredentialsParameter").string(var_2673);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_resource_requirements_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsResourceRequirementsDetails,
) {
    if let Some(var_2674) = &input.r#type {
        object.key("Type").string(var_2674);
    }
    if let Some(var_2675) = &input.value {
        object.key("Value").string(var_2675);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_secrets_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsSecretsDetails,
) {
    if let Some(var_2676) = &input.name {
        object.key("Name").string(var_2676);
    }
    if let Some(var_2677) = &input.value_from {
        object.key("ValueFrom").string(var_2677);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_system_controls_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsSystemControlsDetails,
) {
    if let Some(var_2678) = &input.namespace {
        object.key("Namespace").string(var_2678);
    }
    if let Some(var_2679) = &input.value {
        object.key("Value").string(var_2679);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_ulimits_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsUlimitsDetails,
) {
    if input.hard_limit != 0 {
        object.key("HardLimit").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.hard_limit).into()),
        );
    }
    if let Some(var_2680) = &input.name {
        object.key("Name").string(var_2680);
    }
    if input.soft_limit != 0 {
        object.key("SoftLimit").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.soft_limit).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_volumes_from_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsVolumesFromDetails,
) {
    if input.read_only {
        object.key("ReadOnly").boolean(input.read_only);
    }
    if let Some(var_2681) = &input.source_container {
        object.key("SourceContainer").string(var_2681);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_proxy_configuration_proxy_configuration_properties_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionProxyConfigurationProxyConfigurationPropertiesDetails,
) {
    if let Some(var_2682) = &input.name {
        object.key("Name").string(var_2682);
    }
    if let Some(var_2683) = &input.value {
        object.key("Value").string(var_2683);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_volumes_docker_volume_configuration_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionVolumesDockerVolumeConfigurationDetails,
) {
    if input.autoprovision {
        object.key("Autoprovision").boolean(input.autoprovision);
    }
    if let Some(var_2684) = &input.driver {
        object.key("Driver").string(var_2684);
    }
    if let Some(var_2685) = &input.driver_opts {
        let mut object_2686 = object.key("DriverOpts").start_object();
        for (key_2687, value_2688) in var_2685 {
            {
                object_2686.key(key_2687).string(value_2688);
            }
        }
        object_2686.finish();
    }
    if let Some(var_2689) = &input.labels {
        let mut object_2690 = object.key("Labels").start_object();
        for (key_2691, value_2692) in var_2689 {
            {
                object_2690.key(key_2691).string(value_2692);
            }
        }
        object_2690.finish();
    }
    if let Some(var_2693) = &input.scope {
        object.key("Scope").string(var_2693);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_volumes_efs_volume_configuration_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionVolumesEfsVolumeConfigurationDetails,
) {
    if let Some(var_2694) = &input.authorization_config {
        let mut object_2695 = object.key("AuthorizationConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_ecs_task_definition_volumes_efs_volume_configuration_authorization_config_details(&mut object_2695, var_2694);
        object_2695.finish();
    }
    if let Some(var_2696) = &input.filesystem_id {
        object.key("FilesystemId").string(var_2696);
    }
    if let Some(var_2697) = &input.root_directory {
        object.key("RootDirectory").string(var_2697);
    }
    if let Some(var_2698) = &input.transit_encryption {
        object.key("TransitEncryption").string(var_2698);
    }
    if input.transit_encryption_port != 0 {
        object.key("TransitEncryptionPort").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.transit_encryption_port).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_volumes_host_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionVolumesHostDetails,
) {
    if let Some(var_2699) = &input.source_path {
        object.key("SourcePath").string(var_2699);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_service_deployment_configuration_deployment_circuit_breaker_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsServiceDeploymentConfigurationDeploymentCircuitBreakerDetails,
) {
    if input.enable {
        object.key("Enable").boolean(input.enable);
    }
    if input.rollback {
        object.key("Rollback").boolean(input.rollback);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_service_network_configuration_aws_vpc_configuration_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsServiceNetworkConfigurationAwsVpcConfigurationDetails,
) {
    if let Some(var_2700) = &input.assign_public_ip {
        object.key("AssignPublicIp").string(var_2700);
    }
    if let Some(var_2701) = &input.security_groups {
        let mut array_2702 = object.key("SecurityGroups").start_array();
        for item_2703 in var_2701 {
            {
                array_2702.value().string(item_2703);
            }
        }
        array_2702.finish();
    }
    if let Some(var_2704) = &input.subnets {
        let mut array_2705 = object.key("Subnets").start_array();
        for item_2706 in var_2704 {
            {
                array_2705.value().string(item_2706);
            }
        }
        array_2705.finish();
    }
}

pub fn serialize_structure_crate_model_aws_auto_scaling_launch_configuration_block_device_mappings_ebs_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsAutoScalingLaunchConfigurationBlockDeviceMappingsEbsDetails,
) {
    if input.delete_on_termination {
        object
            .key("DeleteOnTermination")
            .boolean(input.delete_on_termination);
    }
    if input.encrypted {
        object.key("Encrypted").boolean(input.encrypted);
    }
    if input.iops != 0 {
        object.key("Iops").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.iops).into()),
        );
    }
    if let Some(var_2707) = &input.snapshot_id {
        object.key("SnapshotId").string(var_2707);
    }
    if input.volume_size != 0 {
        object.key("VolumeSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.volume_size).into()),
        );
    }
    if let Some(var_2708) = &input.volume_type {
        object.key("VolumeType").string(var_2708);
    }
}

pub fn serialize_structure_crate_model_aws_ec2_vpn_connection_options_tunnel_options_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEc2VpnConnectionOptionsTunnelOptionsDetails,
) {
    if input.dpd_timeout_seconds != 0 {
        object.key("DpdTimeoutSeconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.dpd_timeout_seconds).into()),
        );
    }
    if let Some(var_2709) = &input.ike_versions {
        let mut array_2710 = object.key("IkeVersions").start_array();
        for item_2711 in var_2709 {
            {
                array_2710.value().string(item_2711);
            }
        }
        array_2710.finish();
    }
    if let Some(var_2712) = &input.outside_ip_address {
        object.key("OutsideIpAddress").string(var_2712);
    }
    if let Some(var_2713) = &input.phase1_dh_group_numbers {
        let mut array_2714 = object.key("Phase1DhGroupNumbers").start_array();
        for item_2715 in var_2713 {
            {
                array_2714.value().number(
                    #[allow(clippy::useless_conversion)]
                    aws_smithy_types::Number::NegInt((*item_2715).into()),
                );
            }
        }
        array_2714.finish();
    }
    if let Some(var_2716) = &input.phase1_encryption_algorithms {
        let mut array_2717 = object.key("Phase1EncryptionAlgorithms").start_array();
        for item_2718 in var_2716 {
            {
                array_2717.value().string(item_2718);
            }
        }
        array_2717.finish();
    }
    if let Some(var_2719) = &input.phase1_integrity_algorithms {
        let mut array_2720 = object.key("Phase1IntegrityAlgorithms").start_array();
        for item_2721 in var_2719 {
            {
                array_2720.value().string(item_2721);
            }
        }
        array_2720.finish();
    }
    if input.phase1_lifetime_seconds != 0 {
        object.key("Phase1LifetimeSeconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.phase1_lifetime_seconds).into()),
        );
    }
    if let Some(var_2722) = &input.phase2_dh_group_numbers {
        let mut array_2723 = object.key("Phase2DhGroupNumbers").start_array();
        for item_2724 in var_2722 {
            {
                array_2723.value().number(
                    #[allow(clippy::useless_conversion)]
                    aws_smithy_types::Number::NegInt((*item_2724).into()),
                );
            }
        }
        array_2723.finish();
    }
    if let Some(var_2725) = &input.phase2_encryption_algorithms {
        let mut array_2726 = object.key("Phase2EncryptionAlgorithms").start_array();
        for item_2727 in var_2725 {
            {
                array_2726.value().string(item_2727);
            }
        }
        array_2726.finish();
    }
    if let Some(var_2728) = &input.phase2_integrity_algorithms {
        let mut array_2729 = object.key("Phase2IntegrityAlgorithms").start_array();
        for item_2730 in var_2728 {
            {
                array_2729.value().string(item_2730);
            }
        }
        array_2729.finish();
    }
    if input.phase2_lifetime_seconds != 0 {
        object.key("Phase2LifetimeSeconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.phase2_lifetime_seconds).into()),
        );
    }
    if let Some(var_2731) = &input.pre_shared_key {
        object.key("PreSharedKey").string(var_2731);
    }
    if input.rekey_fuzz_percentage != 0 {
        object.key("RekeyFuzzPercentage").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.rekey_fuzz_percentage).into()),
        );
    }
    if input.rekey_margin_time_seconds != 0 {
        object.key("RekeyMarginTimeSeconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.rekey_margin_time_seconds).into()),
        );
    }
    if input.replay_window_size != 0 {
        object.key("ReplayWindowSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.replay_window_size).into()),
        );
    }
    if let Some(var_2732) = &input.tunnel_inside_cidr {
        object.key("TunnelInsideCidr").string(var_2732);
    }
}

pub fn serialize_structure_crate_model_aws_open_search_service_domain_cluster_config_zone_awareness_config_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsOpenSearchServiceDomainClusterConfigZoneAwarenessConfigDetails,
) {
    if input.availability_zone_count != 0 {
        object.key("AvailabilityZoneCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.availability_zone_count).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_open_search_service_domain_log_publishing_option(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsOpenSearchServiceDomainLogPublishingOption,
) {
    if let Some(var_2733) = &input.cloud_watch_logs_log_group_arn {
        object.key("CloudWatchLogsLogGroupArn").string(var_2733);
    }
    if input.enabled {
        object.key("Enabled").boolean(input.enabled);
    }
}

pub fn serialize_structure_crate_model_aws_eks_cluster_logging_cluster_logging_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEksClusterLoggingClusterLoggingDetails,
) {
    if input.enabled {
        object.key("Enabled").boolean(input.enabled);
    }
    if let Some(var_2734) = &input.types {
        let mut array_2735 = object.key("Types").start_array();
        for item_2736 in var_2734 {
            {
                array_2735.value().string(item_2736);
            }
        }
        array_2735.finish();
    }
}

pub fn serialize_structure_crate_model_occurrences(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Occurrences,
) {
    if let Some(var_2737) = &input.line_ranges {
        let mut array_2738 = object.key("LineRanges").start_array();
        for item_2739 in var_2737 {
            {
                let mut object_2740 = array_2738.value().start_object();
                crate::json_ser::serialize_structure_crate_model_range(&mut object_2740, item_2739);
                object_2740.finish();
            }
        }
        array_2738.finish();
    }
    if let Some(var_2741) = &input.offset_ranges {
        let mut array_2742 = object.key("OffsetRanges").start_array();
        for item_2743 in var_2741 {
            {
                let mut object_2744 = array_2742.value().start_object();
                crate::json_ser::serialize_structure_crate_model_range(&mut object_2744, item_2743);
                object_2744.finish();
            }
        }
        array_2742.finish();
    }
    if let Some(var_2745) = &input.pages {
        let mut array_2746 = object.key("Pages").start_array();
        for item_2747 in var_2745 {
            {
                let mut object_2748 = array_2746.value().start_object();
                crate::json_ser::serialize_structure_crate_model_page(&mut object_2748, item_2747);
                object_2748.finish();
            }
        }
        array_2746.finish();
    }
    if let Some(var_2749) = &input.records {
        let mut array_2750 = object.key("Records").start_array();
        for item_2751 in var_2749 {
            {
                let mut object_2752 = array_2750.value().start_object();
                crate::json_ser::serialize_structure_crate_model_record(
                    &mut object_2752,
                    item_2751,
                );
                object_2752.finish();
            }
        }
        array_2750.finish();
    }
    if let Some(var_2753) = &input.cells {
        let mut array_2754 = object.key("Cells").start_array();
        for item_2755 in var_2753 {
            {
                let mut object_2756 = array_2754.value().start_object();
                crate::json_ser::serialize_structure_crate_model_cell(&mut object_2756, item_2755);
                object_2756.finish();
            }
        }
        array_2754.finish();
    }
}

pub fn serialize_structure_crate_model_aws_cloud_front_distribution_origin_s3_origin_config(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCloudFrontDistributionOriginS3OriginConfig,
) {
    if let Some(var_2757) = &input.origin_access_identity {
        object.key("OriginAccessIdentity").string(var_2757);
    }
}

pub fn serialize_structure_crate_model_aws_cloud_front_distribution_origin_group_failover(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCloudFrontDistributionOriginGroupFailover,
) {
    if let Some(var_2758) = &input.status_codes {
        let mut object_2759 = object.key("StatusCodes").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_cloud_front_distribution_origin_group_failover_status_codes(&mut object_2759, var_2758);
        object_2759.finish();
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_server_side_encryption_by_default(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketServerSideEncryptionByDefault,
) {
    if let Some(var_2760) = &input.sse_algorithm {
        object.key("SSEAlgorithm").string(var_2760);
    }
    if let Some(var_2761) = &input.kms_master_key_id {
        object.key("KMSMasterKeyID").string(var_2761);
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_abort_incomplete_multipart_upload_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketBucketLifecycleConfigurationRulesAbortIncompleteMultipartUploadDetails,
) {
    if input.days_after_initiation != 0 {
        object.key("DaysAfterInitiation").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.days_after_initiation).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketBucketLifecycleConfigurationRulesFilterDetails,
) {
    if let Some(var_2762) = &input.predicate {
        let mut object_2763 = object.key("Predicate").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_predicate_details(&mut object_2763, var_2762);
        object_2763.finish();
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_noncurrent_version_transitions_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketBucketLifecycleConfigurationRulesNoncurrentVersionTransitionsDetails,
) {
    if input.days != 0 {
        object.key("Days").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.days).into()),
        );
    }
    if let Some(var_2764) = &input.storage_class {
        object.key("StorageClass").string(var_2764);
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_transitions_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketBucketLifecycleConfigurationRulesTransitionsDetails,
) {
    if let Some(var_2765) = &input.date {
        object.key("Date").string(var_2765);
    }
    if input.days != 0 {
        object.key("Days").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.days).into()),
        );
    }
    if let Some(var_2766) = &input.storage_class {
        object.key("StorageClass").string(var_2766);
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_website_configuration_routing_rule_condition(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketWebsiteConfigurationRoutingRuleCondition,
) {
    if let Some(var_2767) = &input.http_error_code_returned_equals {
        object.key("HttpErrorCodeReturnedEquals").string(var_2767);
    }
    if let Some(var_2768) = &input.key_prefix_equals {
        object.key("KeyPrefixEquals").string(var_2768);
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_website_configuration_routing_rule_redirect(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketWebsiteConfigurationRoutingRuleRedirect,
) {
    if let Some(var_2769) = &input.hostname {
        object.key("Hostname").string(var_2769);
    }
    if let Some(var_2770) = &input.http_redirect_code {
        object.key("HttpRedirectCode").string(var_2770);
    }
    if let Some(var_2771) = &input.protocol {
        object.key("Protocol").string(var_2771);
    }
    if let Some(var_2772) = &input.replace_key_prefix_with {
        object.key("ReplaceKeyPrefixWith").string(var_2772);
    }
    if let Some(var_2773) = &input.replace_key_with {
        object.key("ReplaceKeyWith").string(var_2773);
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_notification_configuration_filter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketNotificationConfigurationFilter,
) {
    if let Some(var_2774) = &input.s3_key_filter {
        let mut object_2775 = object.key("S3KeyFilter").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_notification_configuration_s3_key_filter(&mut object_2775, var_2774);
        object_2775.finish();
    }
}

pub fn serialize_structure_crate_model_aws_rds_db_subnet_group_subnet_availability_zone(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsRdsDbSubnetGroupSubnetAvailabilityZone,
) {
    if let Some(var_2776) = &input.name {
        object.key("Name").string(var_2776);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_cluster_configuration_execute_command_configuration_log_configuration_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsClusterConfigurationExecuteCommandConfigurationLogConfigurationDetails,
) {
    if input.cloud_watch_encryption_enabled {
        object
            .key("CloudWatchEncryptionEnabled")
            .boolean(input.cloud_watch_encryption_enabled);
    }
    if let Some(var_2777) = &input.cloud_watch_log_group_name {
        object.key("CloudWatchLogGroupName").string(var_2777);
    }
    if let Some(var_2778) = &input.s3_bucket_name {
        object.key("S3BucketName").string(var_2778);
    }
    if input.s3_encryption_enabled {
        object
            .key("S3EncryptionEnabled")
            .boolean(input.s3_encryption_enabled);
    }
    if let Some(var_2779) = &input.s3_key_prefix {
        object.key("S3KeyPrefix").string(var_2779);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_linux_parameters_capabilities_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsLinuxParametersCapabilitiesDetails,
) {
    if let Some(var_2780) = &input.add {
        let mut array_2781 = object.key("Add").start_array();
        for item_2782 in var_2780 {
            {
                array_2781.value().string(item_2782);
            }
        }
        array_2781.finish();
    }
    if let Some(var_2783) = &input.drop {
        let mut array_2784 = object.key("Drop").start_array();
        for item_2785 in var_2783 {
            {
                array_2784.value().string(item_2785);
            }
        }
        array_2784.finish();
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_linux_parameters_devices_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsLinuxParametersDevicesDetails,
) {
    if let Some(var_2786) = &input.container_path {
        object.key("ContainerPath").string(var_2786);
    }
    if let Some(var_2787) = &input.host_path {
        object.key("HostPath").string(var_2787);
    }
    if let Some(var_2788) = &input.permissions {
        let mut array_2789 = object.key("Permissions").start_array();
        for item_2790 in var_2788 {
            {
                array_2789.value().string(item_2790);
            }
        }
        array_2789.finish();
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_linux_parameters_tmpfs_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsLinuxParametersTmpfsDetails,
) {
    if let Some(var_2791) = &input.container_path {
        object.key("ContainerPath").string(var_2791);
    }
    if let Some(var_2792) = &input.mount_options {
        let mut array_2793 = object.key("MountOptions").start_array();
        for item_2794 in var_2792 {
            {
                array_2793.value().string(item_2794);
            }
        }
        array_2793.finish();
    }
    if input.size != 0 {
        object.key("Size").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.size).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_container_definitions_log_configuration_secret_options_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionContainerDefinitionsLogConfigurationSecretOptionsDetails,
) {
    if let Some(var_2795) = &input.name {
        object.key("Name").string(var_2795);
    }
    if let Some(var_2796) = &input.value_from {
        object.key("ValueFrom").string(var_2796);
    }
}

pub fn serialize_structure_crate_model_aws_ecs_task_definition_volumes_efs_volume_configuration_authorization_config_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsEcsTaskDefinitionVolumesEfsVolumeConfigurationAuthorizationConfigDetails,
) {
    if let Some(var_2797) = &input.access_point_id {
        object.key("AccessPointId").string(var_2797);
    }
    if let Some(var_2798) = &input.iam {
        object.key("Iam").string(var_2798);
    }
}

pub fn serialize_structure_crate_model_range(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Range,
) {
    if input.start != 0 {
        object.key("Start").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.start).into()),
        );
    }
    if input.end != 0 {
        object.key("End").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.end).into()),
        );
    }
    if input.start_column != 0 {
        object.key("StartColumn").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.start_column).into()),
        );
    }
}

pub fn serialize_structure_crate_model_page(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Page,
) {
    if input.page_number != 0 {
        object.key("PageNumber").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.page_number).into()),
        );
    }
    if let Some(var_2799) = &input.line_range {
        let mut object_2800 = object.key("LineRange").start_object();
        crate::json_ser::serialize_structure_crate_model_range(&mut object_2800, var_2799);
        object_2800.finish();
    }
    if let Some(var_2801) = &input.offset_range {
        let mut object_2802 = object.key("OffsetRange").start_object();
        crate::json_ser::serialize_structure_crate_model_range(&mut object_2802, var_2801);
        object_2802.finish();
    }
}

pub fn serialize_structure_crate_model_record(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Record,
) {
    if let Some(var_2803) = &input.json_path {
        object.key("JsonPath").string(var_2803);
    }
    if input.record_index != 0 {
        object.key("RecordIndex").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.record_index).into()),
        );
    }
}

pub fn serialize_structure_crate_model_cell(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Cell,
) {
    if input.column != 0 {
        object.key("Column").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.column).into()),
        );
    }
    if input.row != 0 {
        object.key("Row").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.row).into()),
        );
    }
    if let Some(var_2804) = &input.column_name {
        object.key("ColumnName").string(var_2804);
    }
    if let Some(var_2805) = &input.cell_reference {
        object.key("CellReference").string(var_2805);
    }
}

pub fn serialize_structure_crate_model_aws_cloud_front_distribution_origin_group_failover_status_codes(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCloudFrontDistributionOriginGroupFailoverStatusCodes,
) {
    if let Some(var_2806) = &input.items {
        let mut array_2807 = object.key("Items").start_array();
        for item_2808 in var_2806 {
            {
                array_2807.value().number(
                    #[allow(clippy::useless_conversion)]
                    aws_smithy_types::Number::NegInt((*item_2808).into()),
                );
            }
        }
        array_2807.finish();
    }
    if input.quantity != 0 {
        object.key("Quantity").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.quantity).into()),
        );
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_predicate_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateDetails,
) {
    if let Some(var_2809) = &input.operands {
        let mut array_2810 = object.key("Operands").start_array();
        for item_2811 in var_2809 {
            {
                let mut object_2812 = array_2810.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_predicate_operands_details(&mut object_2812, item_2811);
                object_2812.finish();
            }
        }
        array_2810.finish();
    }
    if let Some(var_2813) = &input.prefix {
        object.key("Prefix").string(var_2813);
    }
    if let Some(var_2814) = &input.tag {
        let mut object_2815 = object.key("Tag").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_predicate_tag_details(&mut object_2815, var_2814);
        object_2815.finish();
    }
    if let Some(var_2816) = &input.r#type {
        object.key("Type").string(var_2816);
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_notification_configuration_s3_key_filter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketNotificationConfigurationS3KeyFilter,
) {
    if let Some(var_2817) = &input.filter_rules {
        let mut array_2818 = object.key("FilterRules").start_array();
        for item_2819 in var_2817 {
            {
                let mut object_2820 = array_2818.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_notification_configuration_s3_key_filter_rule(&mut object_2820, item_2819);
                object_2820.finish();
            }
        }
        array_2818.finish();
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_predicate_operands_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateOperandsDetails,
) {
    if let Some(var_2821) = &input.prefix {
        object.key("Prefix").string(var_2821);
    }
    if let Some(var_2822) = &input.tag {
        let mut object_2823 = object.key("Tag").start_object();
        crate::json_ser::serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_predicate_operands_tag_details(&mut object_2823, var_2822);
        object_2823.finish();
    }
    if let Some(var_2824) = &input.r#type {
        object.key("Type").string(var_2824);
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_predicate_tag_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateTagDetails,
) {
    if let Some(var_2825) = &input.key {
        object.key("Key").string(var_2825);
    }
    if let Some(var_2826) = &input.value {
        object.key("Value").string(var_2826);
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_notification_configuration_s3_key_filter_rule(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketNotificationConfigurationS3KeyFilterRule,
) {
    if let Some(var_2827) = &input.name {
        object.key("Name").string(var_2827.as_str());
    }
    if let Some(var_2828) = &input.value {
        object.key("Value").string(var_2828);
    }
}

pub fn serialize_structure_crate_model_aws_s3_bucket_bucket_lifecycle_configuration_rules_filter_predicate_operands_tag_details(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateOperandsTagDetails,
) {
    if let Some(var_2829) = &input.key {
        object.key("Key").string(var_2829);
    }
    if let Some(var_2830) = &input.value {
        object.key("Value").string(var_2830);
    }
}