// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub fn serialize_structure_crate_input_accept_invitation_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::AcceptInvitationInput,
) {
    if let Some(var_1) = &input.invitation_id {
        object.key("invitationId").string(var_1);
    }
    if let Some(var_2) = &input.master_id {
        object.key("masterId").string(var_2);
    }
}

pub fn serialize_structure_crate_input_archive_findings_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ArchiveFindingsInput,
) {
    if let Some(var_3) = &input.finding_ids {
        let mut array_4 = object.key("findingIds").start_array();
        for item_5 in var_3 {
            {
                array_4.value().string(item_5);
            }
        }
        array_4.finish();
    }
}

pub fn serialize_structure_crate_input_create_detector_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateDetectorInput,
) {
    if let Some(var_6) = &input.client_token {
        object.key("clientToken").string(var_6);
    }
    if let Some(var_7) = &input.data_sources {
        let mut object_8 = object.key("dataSources").start_object();
        crate::json_ser::serialize_structure_crate_model_data_source_configurations(
            &mut object_8,
            var_7,
        );
        object_8.finish();
    }
    {
        object.key("enable").boolean(input.enable);
    }
    if let Some(var_9) = &input.finding_publishing_frequency {
        object
            .key("findingPublishingFrequency")
            .string(var_9.as_str());
    }
    if let Some(var_10) = &input.tags {
        let mut object_11 = object.key("tags").start_object();
        for (key_12, value_13) in var_10 {
            {
                object_11.key(key_12).string(value_13);
            }
        }
        object_11.finish();
    }
}

pub fn serialize_structure_crate_input_create_filter_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateFilterInput,
) {
    if let Some(var_14) = &input.action {
        object.key("action").string(var_14.as_str());
    }
    if let Some(var_15) = &input.client_token {
        object.key("clientToken").string(var_15);
    }
    if let Some(var_16) = &input.description {
        object.key("description").string(var_16);
    }
    if let Some(var_17) = &input.finding_criteria {
        let mut object_18 = object.key("findingCriteria").start_object();
        crate::json_ser::serialize_structure_crate_model_finding_criteria(&mut object_18, var_17);
        object_18.finish();
    }
    if let Some(var_19) = &input.name {
        object.key("name").string(var_19);
    }
    if input.rank != 0 {
        object.key("rank").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((input.rank).into()),
        );
    }
    if let Some(var_20) = &input.tags {
        let mut object_21 = object.key("tags").start_object();
        for (key_22, value_23) in var_20 {
            {
                object_21.key(key_22).string(value_23);
            }
        }
        object_21.finish();
    }
}

pub fn serialize_structure_crate_input_create_ip_set_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateIpSetInput,
) {
    {
        object.key("activate").boolean(input.activate);
    }
    if let Some(var_24) = &input.client_token {
        object.key("clientToken").string(var_24);
    }
    if let Some(var_25) = &input.format {
        object.key("format").string(var_25.as_str());
    }
    if let Some(var_26) = &input.location {
        object.key("location").string(var_26);
    }
    if let Some(var_27) = &input.name {
        object.key("name").string(var_27);
    }
    if let Some(var_28) = &input.tags {
        let mut object_29 = object.key("tags").start_object();
        for (key_30, value_31) in var_28 {
            {
                object_29.key(key_30).string(value_31);
            }
        }
        object_29.finish();
    }
}

pub fn serialize_structure_crate_input_create_members_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateMembersInput,
) {
    if let Some(var_32) = &input.account_details {
        let mut array_33 = object.key("accountDetails").start_array();
        for item_34 in var_32 {
            {
                let mut object_35 = array_33.value().start_object();
                crate::json_ser::serialize_structure_crate_model_account_detail(
                    &mut object_35,
                    item_34,
                );
                object_35.finish();
            }
        }
        array_33.finish();
    }
}

pub fn serialize_structure_crate_input_create_publishing_destination_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreatePublishingDestinationInput,
) {
    if let Some(var_36) = &input.client_token {
        object.key("clientToken").string(var_36);
    }
    if let Some(var_37) = &input.destination_properties {
        let mut object_38 = object.key("destinationProperties").start_object();
        crate::json_ser::serialize_structure_crate_model_destination_properties(
            &mut object_38,
            var_37,
        );
        object_38.finish();
    }
    if let Some(var_39) = &input.destination_type {
        object.key("destinationType").string(var_39.as_str());
    }
}

pub fn serialize_structure_crate_input_create_sample_findings_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateSampleFindingsInput,
) {
    if let Some(var_40) = &input.finding_types {
        let mut array_41 = object.key("findingTypes").start_array();
        for item_42 in var_40 {
            {
                array_41.value().string(item_42);
            }
        }
        array_41.finish();
    }
}

pub fn serialize_structure_crate_input_create_threat_intel_set_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateThreatIntelSetInput,
) {
    {
        object.key("activate").boolean(input.activate);
    }
    if let Some(var_43) = &input.client_token {
        object.key("clientToken").string(var_43);
    }
    if let Some(var_44) = &input.format {
        object.key("format").string(var_44.as_str());
    }
    if let Some(var_45) = &input.location {
        object.key("location").string(var_45);
    }
    if let Some(var_46) = &input.name {
        object.key("name").string(var_46);
    }
    if let Some(var_47) = &input.tags {
        let mut object_48 = object.key("tags").start_object();
        for (key_49, value_50) in var_47 {
            {
                object_48.key(key_49).string(value_50);
            }
        }
        object_48.finish();
    }
}

pub fn serialize_structure_crate_input_decline_invitations_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeclineInvitationsInput,
) {
    if let Some(var_51) = &input.account_ids {
        let mut array_52 = object.key("accountIds").start_array();
        for item_53 in var_51 {
            {
                array_52.value().string(item_53);
            }
        }
        array_52.finish();
    }
}

pub fn serialize_structure_crate_input_delete_invitations_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteInvitationsInput,
) {
    if let Some(var_54) = &input.account_ids {
        let mut array_55 = object.key("accountIds").start_array();
        for item_56 in var_54 {
            {
                array_55.value().string(item_56);
            }
        }
        array_55.finish();
    }
}

pub fn serialize_structure_crate_input_delete_members_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteMembersInput,
) {
    if let Some(var_57) = &input.account_ids {
        let mut array_58 = object.key("accountIds").start_array();
        for item_59 in var_57 {
            {
                array_58.value().string(item_59);
            }
        }
        array_58.finish();
    }
}

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

pub fn serialize_structure_crate_input_disassociate_members_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DisassociateMembersInput,
) {
    if let Some(var_61) = &input.account_ids {
        let mut array_62 = object.key("accountIds").start_array();
        for item_63 in var_61 {
            {
                array_62.value().string(item_63);
            }
        }
        array_62.finish();
    }
}

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

pub fn serialize_structure_crate_input_get_findings_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetFindingsInput,
) {
    if let Some(var_65) = &input.finding_ids {
        let mut array_66 = object.key("findingIds").start_array();
        for item_67 in var_65 {
            {
                array_66.value().string(item_67);
            }
        }
        array_66.finish();
    }
    if let Some(var_68) = &input.sort_criteria {
        let mut object_69 = object.key("sortCriteria").start_object();
        crate::json_ser::serialize_structure_crate_model_sort_criteria(&mut object_69, var_68);
        object_69.finish();
    }
}

pub fn serialize_structure_crate_input_get_findings_statistics_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetFindingsStatisticsInput,
) {
    if let Some(var_70) = &input.finding_criteria {
        let mut object_71 = object.key("findingCriteria").start_object();
        crate::json_ser::serialize_structure_crate_model_finding_criteria(&mut object_71, var_70);
        object_71.finish();
    }
    if let Some(var_72) = &input.finding_statistic_types {
        let mut array_73 = object.key("findingStatisticTypes").start_array();
        for item_74 in var_72 {
            {
                array_73.value().string(item_74.as_str());
            }
        }
        array_73.finish();
    }
}

pub fn serialize_structure_crate_input_get_member_detectors_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetMemberDetectorsInput,
) {
    if let Some(var_75) = &input.account_ids {
        let mut array_76 = object.key("accountIds").start_array();
        for item_77 in var_75 {
            {
                array_76.value().string(item_77);
            }
        }
        array_76.finish();
    }
}

pub fn serialize_structure_crate_input_get_members_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetMembersInput,
) {
    if let Some(var_78) = &input.account_ids {
        let mut array_79 = object.key("accountIds").start_array();
        for item_80 in var_78 {
            {
                array_79.value().string(item_80);
            }
        }
        array_79.finish();
    }
}

pub fn serialize_structure_crate_input_get_usage_statistics_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetUsageStatisticsInput,
) {
    if input.max_results != 0 {
        object.key("maxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((input.max_results).into()),
        );
    }
    if let Some(var_81) = &input.next_token {
        object.key("nextToken").string(var_81);
    }
    if let Some(var_82) = &input.unit {
        object.key("unit").string(var_82);
    }
    if let Some(var_83) = &input.usage_criteria {
        let mut object_84 = object.key("usageCriteria").start_object();
        crate::json_ser::serialize_structure_crate_model_usage_criteria(&mut object_84, var_83);
        object_84.finish();
    }
    if let Some(var_85) = &input.usage_statistic_type {
        object.key("usageStatisticsType").string(var_85.as_str());
    }
}

pub fn serialize_structure_crate_input_invite_members_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::InviteMembersInput,
) {
    if let Some(var_86) = &input.account_ids {
        let mut array_87 = object.key("accountIds").start_array();
        for item_88 in var_86 {
            {
                array_87.value().string(item_88);
            }
        }
        array_87.finish();
    }
    if input.disable_email_notification {
        object
            .key("disableEmailNotification")
            .boolean(input.disable_email_notification);
    }
    if let Some(var_89) = &input.message {
        object.key("message").string(var_89);
    }
}

pub fn serialize_structure_crate_input_list_findings_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListFindingsInput,
) {
    if let Some(var_90) = &input.finding_criteria {
        let mut object_91 = object.key("findingCriteria").start_object();
        crate::json_ser::serialize_structure_crate_model_finding_criteria(&mut object_91, var_90);
        object_91.finish();
    }
    if input.max_results != 0 {
        object.key("maxResults").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((input.max_results).into()),
        );
    }
    if let Some(var_92) = &input.next_token {
        object.key("nextToken").string(var_92);
    }
    if let Some(var_93) = &input.sort_criteria {
        let mut object_94 = object.key("sortCriteria").start_object();
        crate::json_ser::serialize_structure_crate_model_sort_criteria(&mut object_94, var_93);
        object_94.finish();
    }
}

pub fn serialize_structure_crate_input_start_monitoring_members_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartMonitoringMembersInput,
) {
    if let Some(var_95) = &input.account_ids {
        let mut array_96 = object.key("accountIds").start_array();
        for item_97 in var_95 {
            {
                array_96.value().string(item_97);
            }
        }
        array_96.finish();
    }
}

pub fn serialize_structure_crate_input_stop_monitoring_members_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StopMonitoringMembersInput,
) {
    if let Some(var_98) = &input.account_ids {
        let mut array_99 = object.key("accountIds").start_array();
        for item_100 in var_98 {
            {
                array_99.value().string(item_100);
            }
        }
        array_99.finish();
    }
}

pub fn serialize_structure_crate_input_tag_resource_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::TagResourceInput,
) {
    if let Some(var_101) = &input.tags {
        let mut object_102 = object.key("tags").start_object();
        for (key_103, value_104) in var_101 {
            {
                object_102.key(key_103).string(value_104);
            }
        }
        object_102.finish();
    }
}

pub fn serialize_structure_crate_input_unarchive_findings_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UnarchiveFindingsInput,
) {
    if let Some(var_105) = &input.finding_ids {
        let mut array_106 = object.key("findingIds").start_array();
        for item_107 in var_105 {
            {
                array_106.value().string(item_107);
            }
        }
        array_106.finish();
    }
}

pub fn serialize_structure_crate_input_update_detector_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateDetectorInput,
) {
    if let Some(var_108) = &input.data_sources {
        let mut object_109 = object.key("dataSources").start_object();
        crate::json_ser::serialize_structure_crate_model_data_source_configurations(
            &mut object_109,
            var_108,
        );
        object_109.finish();
    }
    if input.enable {
        object.key("enable").boolean(input.enable);
    }
    if let Some(var_110) = &input.finding_publishing_frequency {
        object
            .key("findingPublishingFrequency")
            .string(var_110.as_str());
    }
}

pub fn serialize_structure_crate_input_update_filter_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateFilterInput,
) {
    if let Some(var_111) = &input.action {
        object.key("action").string(var_111.as_str());
    }
    if let Some(var_112) = &input.description {
        object.key("description").string(var_112);
    }
    if let Some(var_113) = &input.finding_criteria {
        let mut object_114 = object.key("findingCriteria").start_object();
        crate::json_ser::serialize_structure_crate_model_finding_criteria(&mut object_114, var_113);
        object_114.finish();
    }
    if input.rank != 0 {
        object.key("rank").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((input.rank).into()),
        );
    }
}

pub fn serialize_structure_crate_input_update_findings_feedback_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateFindingsFeedbackInput,
) {
    if let Some(var_115) = &input.comments {
        object.key("comments").string(var_115);
    }
    if let Some(var_116) = &input.feedback {
        object.key("feedback").string(var_116.as_str());
    }
    if let Some(var_117) = &input.finding_ids {
        let mut array_118 = object.key("findingIds").start_array();
        for item_119 in var_117 {
            {
                array_118.value().string(item_119);
            }
        }
        array_118.finish();
    }
}

pub fn serialize_structure_crate_input_update_ip_set_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateIpSetInput,
) {
    if input.activate {
        object.key("activate").boolean(input.activate);
    }
    if let Some(var_120) = &input.location {
        object.key("location").string(var_120);
    }
    if let Some(var_121) = &input.name {
        object.key("name").string(var_121);
    }
}

pub fn serialize_structure_crate_input_update_member_detectors_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateMemberDetectorsInput,
) {
    if let Some(var_122) = &input.account_ids {
        let mut array_123 = object.key("accountIds").start_array();
        for item_124 in var_122 {
            {
                array_123.value().string(item_124);
            }
        }
        array_123.finish();
    }
    if let Some(var_125) = &input.data_sources {
        let mut object_126 = object.key("dataSources").start_object();
        crate::json_ser::serialize_structure_crate_model_data_source_configurations(
            &mut object_126,
            var_125,
        );
        object_126.finish();
    }
}

pub fn serialize_structure_crate_input_update_organization_configuration_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateOrganizationConfigurationInput,
) {
    {
        object.key("autoEnable").boolean(input.auto_enable);
    }
    if let Some(var_127) = &input.data_sources {
        let mut object_128 = object.key("dataSources").start_object();
        crate::json_ser::serialize_structure_crate_model_organization_data_source_configurations(
            &mut object_128,
            var_127,
        );
        object_128.finish();
    }
}

pub fn serialize_structure_crate_input_update_publishing_destination_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdatePublishingDestinationInput,
) {
    if let Some(var_129) = &input.destination_properties {
        let mut object_130 = object.key("destinationProperties").start_object();
        crate::json_ser::serialize_structure_crate_model_destination_properties(
            &mut object_130,
            var_129,
        );
        object_130.finish();
    }
}

pub fn serialize_structure_crate_input_update_threat_intel_set_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateThreatIntelSetInput,
) {
    if input.activate {
        object.key("activate").boolean(input.activate);
    }
    if let Some(var_131) = &input.location {
        object.key("location").string(var_131);
    }
    if let Some(var_132) = &input.name {
        object.key("name").string(var_132);
    }
}

pub fn serialize_structure_crate_model_data_source_configurations(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DataSourceConfigurations,
) {
    if let Some(var_133) = &input.s3_logs {
        let mut object_134 = object.key("s3Logs").start_object();
        crate::json_ser::serialize_structure_crate_model_s3_logs_configuration(
            &mut object_134,
            var_133,
        );
        object_134.finish();
    }
}

pub fn serialize_structure_crate_model_finding_criteria(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FindingCriteria,
) {
    if let Some(var_135) = &input.criterion {
        let mut object_136 = object.key("criterion").start_object();
        for (key_137, value_138) in var_135 {
            {
                let mut object_139 = object_136.key(key_137).start_object();
                crate::json_ser::serialize_structure_crate_model_condition(
                    &mut object_139,
                    value_138,
                );
                object_139.finish();
            }
        }
        object_136.finish();
    }
}

pub fn serialize_structure_crate_model_account_detail(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AccountDetail,
) {
    if let Some(var_140) = &input.account_id {
        object.key("accountId").string(var_140);
    }
    if let Some(var_141) = &input.email {
        object.key("email").string(var_141);
    }
}

pub fn serialize_structure_crate_model_destination_properties(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DestinationProperties,
) {
    if let Some(var_142) = &input.destination_arn {
        object.key("destinationArn").string(var_142);
    }
    if let Some(var_143) = &input.kms_key_arn {
        object.key("kmsKeyArn").string(var_143);
    }
}

pub fn serialize_structure_crate_model_sort_criteria(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SortCriteria,
) {
    if let Some(var_144) = &input.attribute_name {
        object.key("attributeName").string(var_144);
    }
    if let Some(var_145) = &input.order_by {
        object.key("orderBy").string(var_145.as_str());
    }
}

pub fn serialize_structure_crate_model_usage_criteria(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::UsageCriteria,
) {
    if let Some(var_146) = &input.account_ids {
        let mut array_147 = object.key("accountIds").start_array();
        for item_148 in var_146 {
            {
                array_147.value().string(item_148);
            }
        }
        array_147.finish();
    }
    if let Some(var_149) = &input.data_sources {
        let mut array_150 = object.key("dataSources").start_array();
        for item_151 in var_149 {
            {
                array_150.value().string(item_151.as_str());
            }
        }
        array_150.finish();
    }
    if let Some(var_152) = &input.resources {
        let mut array_153 = object.key("resources").start_array();
        for item_154 in var_152 {
            {
                array_153.value().string(item_154);
            }
        }
        array_153.finish();
    }
}

pub fn serialize_structure_crate_model_organization_data_source_configurations(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::OrganizationDataSourceConfigurations,
) {
    if let Some(var_155) = &input.s3_logs {
        let mut object_156 = object.key("s3Logs").start_object();
        crate::json_ser::serialize_structure_crate_model_organization_s3_logs_configuration(
            &mut object_156,
            var_155,
        );
        object_156.finish();
    }
}

pub fn serialize_structure_crate_model_s3_logs_configuration(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::S3LogsConfiguration,
) {
    {
        object.key("enable").boolean(input.enable);
    }
}

pub fn serialize_structure_crate_model_condition(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Condition,
) {
    if let Some(var_157) = &input.eq {
        let mut array_158 = object.key("eq").start_array();
        for item_159 in var_157 {
            {
                array_158.value().string(item_159);
            }
        }
        array_158.finish();
    }
    if let Some(var_160) = &input.neq {
        let mut array_161 = object.key("neq").start_array();
        for item_162 in var_160 {
            {
                array_161.value().string(item_162);
            }
        }
        array_161.finish();
    }
    if input.gt != 0 {
        object.key("gt").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((input.gt).into()),
        );
    }
    if input.gte != 0 {
        object.key("gte").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((input.gte).into()),
        );
    }
    if input.lt != 0 {
        object.key("lt").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((input.lt).into()),
        );
    }
    if input.lte != 0 {
        object.key("lte").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((input.lte).into()),
        );
    }
    if let Some(var_163) = &input.equals {
        let mut array_164 = object.key("equals").start_array();
        for item_165 in var_163 {
            {
                array_164.value().string(item_165);
            }
        }
        array_164.finish();
    }
    if let Some(var_166) = &input.not_equals {
        let mut array_167 = object.key("notEquals").start_array();
        for item_168 in var_166 {
            {
                array_167.value().string(item_168);
            }
        }
        array_167.finish();
    }
    if input.greater_than != 0 {
        object.key("greaterThan").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((input.greater_than).into()),
        );
    }
    if input.greater_than_or_equal != 0 {
        object.key("greaterThanOrEqual").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((input.greater_than_or_equal).into()),
        );
    }
    if input.less_than != 0 {
        object.key("lessThan").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((input.less_than).into()),
        );
    }
    if input.less_than_or_equal != 0 {
        object.key("lessThanOrEqual").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((input.less_than_or_equal).into()),
        );
    }
}

pub fn serialize_structure_crate_model_organization_s3_logs_configuration(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::OrganizationS3LogsConfiguration,
) {
    {
        object.key("autoEnable").boolean(input.auto_enable);
    }
}
