// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub fn serialize_structure_crate_input_cancel_job_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CancelJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_1) = &input.job_id {
        object.key("jobId").string(var_1.as_str());
    }
    if let Some(var_2) = &input.reason {
        object.key("reason").string(var_2.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_compute_environment_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateComputeEnvironmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_3) = &input.compute_environment_name {
        object.key("computeEnvironmentName").string(var_3.as_str());
    }
    if let Some(var_4) = &input.compute_resources {
        #[allow(unused_mut)]
        let mut object_5 = object.key("computeResources").start_object();
        crate::json_ser::serialize_structure_crate_model_compute_resource(&mut object_5, var_4)?;
        object_5.finish();
    }
    if let Some(var_6) = &input.service_role {
        object.key("serviceRole").string(var_6.as_str());
    }
    if let Some(var_7) = &input.state {
        object.key("state").string(var_7.as_str());
    }
    if let Some(var_8) = &input.tags {
        #[allow(unused_mut)]
        let mut object_9 = object.key("tags").start_object();
        for (key_10, value_11) in var_8 {
            {
                object_9.key(key_10.as_str()).string(value_11.as_str());
            }
        }
        object_9.finish();
    }
    if let Some(var_12) = &input.r#type {
        object.key("type").string(var_12.as_str());
    }
    if let Some(var_13) = &input.unmanagedv_cpus {
        object.key("unmanagedvCpus").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_13).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_job_queue_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateJobQueueInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_14) = &input.compute_environment_order {
        let mut array_15 = object.key("computeEnvironmentOrder").start_array();
        for item_16 in var_14 {
            {
                #[allow(unused_mut)]
                let mut object_17 = array_15.value().start_object();
                crate::json_ser::serialize_structure_crate_model_compute_environment_order(
                    &mut object_17,
                    item_16,
                )?;
                object_17.finish();
            }
        }
        array_15.finish();
    }
    if let Some(var_18) = &input.job_queue_name {
        object.key("jobQueueName").string(var_18.as_str());
    }
    if let Some(var_19) = &input.priority {
        object.key("priority").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_19).into()),
        );
    }
    if let Some(var_20) = &input.scheduling_policy_arn {
        object.key("schedulingPolicyArn").string(var_20.as_str());
    }
    if let Some(var_21) = &input.state {
        object.key("state").string(var_21.as_str());
    }
    if let Some(var_22) = &input.tags {
        #[allow(unused_mut)]
        let mut object_23 = object.key("tags").start_object();
        for (key_24, value_25) in var_22 {
            {
                object_23.key(key_24.as_str()).string(value_25.as_str());
            }
        }
        object_23.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_scheduling_policy_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateSchedulingPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_26) = &input.fairshare_policy {
        #[allow(unused_mut)]
        let mut object_27 = object.key("fairsharePolicy").start_object();
        crate::json_ser::serialize_structure_crate_model_fairshare_policy(&mut object_27, var_26)?;
        object_27.finish();
    }
    if let Some(var_28) = &input.name {
        object.key("name").string(var_28.as_str());
    }
    if let Some(var_29) = &input.tags {
        #[allow(unused_mut)]
        let mut object_30 = object.key("tags").start_object();
        for (key_31, value_32) in var_29 {
            {
                object_30.key(key_31.as_str()).string(value_32.as_str());
            }
        }
        object_30.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_compute_environment_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteComputeEnvironmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_33) = &input.compute_environment {
        object.key("computeEnvironment").string(var_33.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_job_queue_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteJobQueueInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_34) = &input.job_queue {
        object.key("jobQueue").string(var_34.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_scheduling_policy_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteSchedulingPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_35) = &input.arn {
        object.key("arn").string(var_35.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_deregister_job_definition_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeregisterJobDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_36) = &input.job_definition {
        object.key("jobDefinition").string(var_36.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_compute_environments_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeComputeEnvironmentsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_37) = &input.compute_environments {
        let mut array_38 = object.key("computeEnvironments").start_array();
        for item_39 in var_37 {
            {
                array_38.value().string(item_39.as_str());
            }
        }
        array_38.finish();
    }
    if let Some(var_40) = &input.max_results {
        object.key("maxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_40).into()),
        );
    }
    if let Some(var_41) = &input.next_token {
        object.key("nextToken").string(var_41.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_job_definitions_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeJobDefinitionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_42) = &input.job_definition_name {
        object.key("jobDefinitionName").string(var_42.as_str());
    }
    if let Some(var_43) = &input.job_definitions {
        let mut array_44 = object.key("jobDefinitions").start_array();
        for item_45 in var_43 {
            {
                array_44.value().string(item_45.as_str());
            }
        }
        array_44.finish();
    }
    if let Some(var_46) = &input.max_results {
        object.key("maxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_46).into()),
        );
    }
    if let Some(var_47) = &input.next_token {
        object.key("nextToken").string(var_47.as_str());
    }
    if let Some(var_48) = &input.status {
        object.key("status").string(var_48.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_job_queues_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeJobQueuesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_49) = &input.job_queues {
        let mut array_50 = object.key("jobQueues").start_array();
        for item_51 in var_49 {
            {
                array_50.value().string(item_51.as_str());
            }
        }
        array_50.finish();
    }
    if let Some(var_52) = &input.max_results {
        object.key("maxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_52).into()),
        );
    }
    if let Some(var_53) = &input.next_token {
        object.key("nextToken").string(var_53.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_jobs_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_54) = &input.jobs {
        let mut array_55 = object.key("jobs").start_array();
        for item_56 in var_54 {
            {
                array_55.value().string(item_56.as_str());
            }
        }
        array_55.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_scheduling_policies_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeSchedulingPoliciesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_57) = &input.arns {
        let mut array_58 = object.key("arns").start_array();
        for item_59 in var_57 {
            {
                array_58.value().string(item_59.as_str());
            }
        }
        array_58.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_jobs_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_60) = &input.array_job_id {
        object.key("arrayJobId").string(var_60.as_str());
    }
    if let Some(var_61) = &input.filters {
        let mut array_62 = object.key("filters").start_array();
        for item_63 in var_61 {
            {
                #[allow(unused_mut)]
                let mut object_64 = array_62.value().start_object();
                crate::json_ser::serialize_structure_crate_model_key_values_pair(
                    &mut object_64,
                    item_63,
                )?;
                object_64.finish();
            }
        }
        array_62.finish();
    }
    if let Some(var_65) = &input.job_queue {
        object.key("jobQueue").string(var_65.as_str());
    }
    if let Some(var_66) = &input.job_status {
        object.key("jobStatus").string(var_66.as_str());
    }
    if let Some(var_67) = &input.max_results {
        object.key("maxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_67).into()),
        );
    }
    if let Some(var_68) = &input.multi_node_job_id {
        object.key("multiNodeJobId").string(var_68.as_str());
    }
    if let Some(var_69) = &input.next_token {
        object.key("nextToken").string(var_69.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_scheduling_policies_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListSchedulingPoliciesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_70) = &input.max_results {
        object.key("maxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_70).into()),
        );
    }
    if let Some(var_71) = &input.next_token {
        object.key("nextToken").string(var_71.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_register_job_definition_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RegisterJobDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_72) = &input.container_properties {
        #[allow(unused_mut)]
        let mut object_73 = object.key("containerProperties").start_object();
        crate::json_ser::serialize_structure_crate_model_container_properties(
            &mut object_73,
            var_72,
        )?;
        object_73.finish();
    }
    if let Some(var_74) = &input.job_definition_name {
        object.key("jobDefinitionName").string(var_74.as_str());
    }
    if let Some(var_75) = &input.node_properties {
        #[allow(unused_mut)]
        let mut object_76 = object.key("nodeProperties").start_object();
        crate::json_ser::serialize_structure_crate_model_node_properties(&mut object_76, var_75)?;
        object_76.finish();
    }
    if let Some(var_77) = &input.parameters {
        #[allow(unused_mut)]
        let mut object_78 = object.key("parameters").start_object();
        for (key_79, value_80) in var_77 {
            {
                object_78.key(key_79.as_str()).string(value_80.as_str());
            }
        }
        object_78.finish();
    }
    if let Some(var_81) = &input.platform_capabilities {
        let mut array_82 = object.key("platformCapabilities").start_array();
        for item_83 in var_81 {
            {
                array_82.value().string(item_83.as_str());
            }
        }
        array_82.finish();
    }
    if let Some(var_84) = &input.propagate_tags {
        object.key("propagateTags").boolean(*var_84);
    }
    if let Some(var_85) = &input.retry_strategy {
        #[allow(unused_mut)]
        let mut object_86 = object.key("retryStrategy").start_object();
        crate::json_ser::serialize_structure_crate_model_retry_strategy(&mut object_86, var_85)?;
        object_86.finish();
    }
    if let Some(var_87) = &input.scheduling_priority {
        object.key("schedulingPriority").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_87).into()),
        );
    }
    if let Some(var_88) = &input.tags {
        #[allow(unused_mut)]
        let mut object_89 = object.key("tags").start_object();
        for (key_90, value_91) in var_88 {
            {
                object_89.key(key_90.as_str()).string(value_91.as_str());
            }
        }
        object_89.finish();
    }
    if let Some(var_92) = &input.timeout {
        #[allow(unused_mut)]
        let mut object_93 = object.key("timeout").start_object();
        crate::json_ser::serialize_structure_crate_model_job_timeout(&mut object_93, var_92)?;
        object_93.finish();
    }
    if let Some(var_94) = &input.r#type {
        object.key("type").string(var_94.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_submit_job_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::SubmitJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_95) = &input.array_properties {
        #[allow(unused_mut)]
        let mut object_96 = object.key("arrayProperties").start_object();
        crate::json_ser::serialize_structure_crate_model_array_properties(&mut object_96, var_95)?;
        object_96.finish();
    }
    if let Some(var_97) = &input.container_overrides {
        #[allow(unused_mut)]
        let mut object_98 = object.key("containerOverrides").start_object();
        crate::json_ser::serialize_structure_crate_model_container_overrides(
            &mut object_98,
            var_97,
        )?;
        object_98.finish();
    }
    if let Some(var_99) = &input.depends_on {
        let mut array_100 = object.key("dependsOn").start_array();
        for item_101 in var_99 {
            {
                #[allow(unused_mut)]
                let mut object_102 = array_100.value().start_object();
                crate::json_ser::serialize_structure_crate_model_job_dependency(
                    &mut object_102,
                    item_101,
                )?;
                object_102.finish();
            }
        }
        array_100.finish();
    }
    if let Some(var_103) = &input.job_definition {
        object.key("jobDefinition").string(var_103.as_str());
    }
    if let Some(var_104) = &input.job_name {
        object.key("jobName").string(var_104.as_str());
    }
    if let Some(var_105) = &input.job_queue {
        object.key("jobQueue").string(var_105.as_str());
    }
    if let Some(var_106) = &input.node_overrides {
        #[allow(unused_mut)]
        let mut object_107 = object.key("nodeOverrides").start_object();
        crate::json_ser::serialize_structure_crate_model_node_overrides(&mut object_107, var_106)?;
        object_107.finish();
    }
    if let Some(var_108) = &input.parameters {
        #[allow(unused_mut)]
        let mut object_109 = object.key("parameters").start_object();
        for (key_110, value_111) in var_108 {
            {
                object_109.key(key_110.as_str()).string(value_111.as_str());
            }
        }
        object_109.finish();
    }
    if let Some(var_112) = &input.propagate_tags {
        object.key("propagateTags").boolean(*var_112);
    }
    if let Some(var_113) = &input.retry_strategy {
        #[allow(unused_mut)]
        let mut object_114 = object.key("retryStrategy").start_object();
        crate::json_ser::serialize_structure_crate_model_retry_strategy(&mut object_114, var_113)?;
        object_114.finish();
    }
    if let Some(var_115) = &input.scheduling_priority_override {
        object.key("schedulingPriorityOverride").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_115).into()),
        );
    }
    if let Some(var_116) = &input.share_identifier {
        object.key("shareIdentifier").string(var_116.as_str());
    }
    if let Some(var_117) = &input.tags {
        #[allow(unused_mut)]
        let mut object_118 = object.key("tags").start_object();
        for (key_119, value_120) in var_117 {
            {
                object_118.key(key_119.as_str()).string(value_120.as_str());
            }
        }
        object_118.finish();
    }
    if let Some(var_121) = &input.timeout {
        #[allow(unused_mut)]
        let mut object_122 = object.key("timeout").start_object();
        crate::json_ser::serialize_structure_crate_model_job_timeout(&mut object_122, var_121)?;
        object_122.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_tag_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_123) = &input.tags {
        #[allow(unused_mut)]
        let mut object_124 = object.key("tags").start_object();
        for (key_125, value_126) in var_123 {
            {
                object_124.key(key_125.as_str()).string(value_126.as_str());
            }
        }
        object_124.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_terminate_job_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::TerminateJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_127) = &input.job_id {
        object.key("jobId").string(var_127.as_str());
    }
    if let Some(var_128) = &input.reason {
        object.key("reason").string(var_128.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_compute_environment_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateComputeEnvironmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_129) = &input.compute_environment {
        object.key("computeEnvironment").string(var_129.as_str());
    }
    if let Some(var_130) = &input.compute_resources {
        #[allow(unused_mut)]
        let mut object_131 = object.key("computeResources").start_object();
        crate::json_ser::serialize_structure_crate_model_compute_resource_update(
            &mut object_131,
            var_130,
        )?;
        object_131.finish();
    }
    if let Some(var_132) = &input.service_role {
        object.key("serviceRole").string(var_132.as_str());
    }
    if let Some(var_133) = &input.state {
        object.key("state").string(var_133.as_str());
    }
    if let Some(var_134) = &input.unmanagedv_cpus {
        object.key("unmanagedvCpus").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_134).into()),
        );
    }
    if let Some(var_135) = &input.update_policy {
        #[allow(unused_mut)]
        let mut object_136 = object.key("updatePolicy").start_object();
        crate::json_ser::serialize_structure_crate_model_update_policy(&mut object_136, var_135)?;
        object_136.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_job_queue_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateJobQueueInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_137) = &input.compute_environment_order {
        let mut array_138 = object.key("computeEnvironmentOrder").start_array();
        for item_139 in var_137 {
            {
                #[allow(unused_mut)]
                let mut object_140 = array_138.value().start_object();
                crate::json_ser::serialize_structure_crate_model_compute_environment_order(
                    &mut object_140,
                    item_139,
                )?;
                object_140.finish();
            }
        }
        array_138.finish();
    }
    if let Some(var_141) = &input.job_queue {
        object.key("jobQueue").string(var_141.as_str());
    }
    if let Some(var_142) = &input.priority {
        object.key("priority").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_142).into()),
        );
    }
    if let Some(var_143) = &input.scheduling_policy_arn {
        object.key("schedulingPolicyArn").string(var_143.as_str());
    }
    if let Some(var_144) = &input.state {
        object.key("state").string(var_144.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_scheduling_policy_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateSchedulingPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_145) = &input.arn {
        object.key("arn").string(var_145.as_str());
    }
    if let Some(var_146) = &input.fairshare_policy {
        #[allow(unused_mut)]
        let mut object_147 = object.key("fairsharePolicy").start_object();
        crate::json_ser::serialize_structure_crate_model_fairshare_policy(
            &mut object_147,
            var_146,
        )?;
        object_147.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_compute_resource(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ComputeResource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_148) = &input.r#type {
        object.key("type").string(var_148.as_str());
    }
    if let Some(var_149) = &input.allocation_strategy {
        object.key("allocationStrategy").string(var_149.as_str());
    }
    if let Some(var_150) = &input.minv_cpus {
        object.key("minvCpus").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_150).into()),
        );
    }
    if let Some(var_151) = &input.maxv_cpus {
        object.key("maxvCpus").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_151).into()),
        );
    }
    if let Some(var_152) = &input.desiredv_cpus {
        object.key("desiredvCpus").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_152).into()),
        );
    }
    if let Some(var_153) = &input.instance_types {
        let mut array_154 = object.key("instanceTypes").start_array();
        for item_155 in var_153 {
            {
                array_154.value().string(item_155.as_str());
            }
        }
        array_154.finish();
    }
    if let Some(var_156) = &input.image_id {
        object.key("imageId").string(var_156.as_str());
    }
    if let Some(var_157) = &input.subnets {
        let mut array_158 = object.key("subnets").start_array();
        for item_159 in var_157 {
            {
                array_158.value().string(item_159.as_str());
            }
        }
        array_158.finish();
    }
    if let Some(var_160) = &input.security_group_ids {
        let mut array_161 = object.key("securityGroupIds").start_array();
        for item_162 in var_160 {
            {
                array_161.value().string(item_162.as_str());
            }
        }
        array_161.finish();
    }
    if let Some(var_163) = &input.ec2_key_pair {
        object.key("ec2KeyPair").string(var_163.as_str());
    }
    if let Some(var_164) = &input.instance_role {
        object.key("instanceRole").string(var_164.as_str());
    }
    if let Some(var_165) = &input.tags {
        #[allow(unused_mut)]
        let mut object_166 = object.key("tags").start_object();
        for (key_167, value_168) in var_165 {
            {
                object_166.key(key_167.as_str()).string(value_168.as_str());
            }
        }
        object_166.finish();
    }
    if let Some(var_169) = &input.placement_group {
        object.key("placementGroup").string(var_169.as_str());
    }
    if let Some(var_170) = &input.bid_percentage {
        object.key("bidPercentage").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_170).into()),
        );
    }
    if let Some(var_171) = &input.spot_iam_fleet_role {
        object.key("spotIamFleetRole").string(var_171.as_str());
    }
    if let Some(var_172) = &input.launch_template {
        #[allow(unused_mut)]
        let mut object_173 = object.key("launchTemplate").start_object();
        crate::json_ser::serialize_structure_crate_model_launch_template_specification(
            &mut object_173,
            var_172,
        )?;
        object_173.finish();
    }
    if let Some(var_174) = &input.ec2_configuration {
        let mut array_175 = object.key("ec2Configuration").start_array();
        for item_176 in var_174 {
            {
                #[allow(unused_mut)]
                let mut object_177 = array_175.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ec2_configuration(
                    &mut object_177,
                    item_176,
                )?;
                object_177.finish();
            }
        }
        array_175.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_compute_environment_order(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ComputeEnvironmentOrder,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_178) = &input.order {
        object.key("order").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_178).into()),
        );
    }
    if let Some(var_179) = &input.compute_environment {
        object.key("computeEnvironment").string(var_179.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_fairshare_policy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FairsharePolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_180) = &input.share_decay_seconds {
        object.key("shareDecaySeconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_180).into()),
        );
    }
    if let Some(var_181) = &input.compute_reservation {
        object.key("computeReservation").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_181).into()),
        );
    }
    if let Some(var_182) = &input.share_distribution {
        let mut array_183 = object.key("shareDistribution").start_array();
        for item_184 in var_182 {
            {
                #[allow(unused_mut)]
                let mut object_185 = array_183.value().start_object();
                crate::json_ser::serialize_structure_crate_model_share_attributes(
                    &mut object_185,
                    item_184,
                )?;
                object_185.finish();
            }
        }
        array_183.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_key_values_pair(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::KeyValuesPair,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_186) = &input.name {
        object.key("name").string(var_186.as_str());
    }
    if let Some(var_187) = &input.values {
        let mut array_188 = object.key("values").start_array();
        for item_189 in var_187 {
            {
                array_188.value().string(item_189.as_str());
            }
        }
        array_188.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_container_properties(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ContainerProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_190) = &input.image {
        object.key("image").string(var_190.as_str());
    }
    if let Some(var_191) = &input.vcpus {
        object.key("vcpus").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_191).into()),
        );
    }
    if let Some(var_192) = &input.memory {
        object.key("memory").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_192).into()),
        );
    }
    if let Some(var_193) = &input.command {
        let mut array_194 = object.key("command").start_array();
        for item_195 in var_193 {
            {
                array_194.value().string(item_195.as_str());
            }
        }
        array_194.finish();
    }
    if let Some(var_196) = &input.job_role_arn {
        object.key("jobRoleArn").string(var_196.as_str());
    }
    if let Some(var_197) = &input.execution_role_arn {
        object.key("executionRoleArn").string(var_197.as_str());
    }
    if let Some(var_198) = &input.volumes {
        let mut array_199 = object.key("volumes").start_array();
        for item_200 in var_198 {
            {
                #[allow(unused_mut)]
                let mut object_201 = array_199.value().start_object();
                crate::json_ser::serialize_structure_crate_model_volume(&mut object_201, item_200)?;
                object_201.finish();
            }
        }
        array_199.finish();
    }
    if let Some(var_202) = &input.environment {
        let mut array_203 = object.key("environment").start_array();
        for item_204 in var_202 {
            {
                #[allow(unused_mut)]
                let mut object_205 = array_203.value().start_object();
                crate::json_ser::serialize_structure_crate_model_key_value_pair(
                    &mut object_205,
                    item_204,
                )?;
                object_205.finish();
            }
        }
        array_203.finish();
    }
    if let Some(var_206) = &input.mount_points {
        let mut array_207 = object.key("mountPoints").start_array();
        for item_208 in var_206 {
            {
                #[allow(unused_mut)]
                let mut object_209 = array_207.value().start_object();
                crate::json_ser::serialize_structure_crate_model_mount_point(
                    &mut object_209,
                    item_208,
                )?;
                object_209.finish();
            }
        }
        array_207.finish();
    }
    if let Some(var_210) = &input.readonly_root_filesystem {
        object.key("readonlyRootFilesystem").boolean(*var_210);
    }
    if let Some(var_211) = &input.privileged {
        object.key("privileged").boolean(*var_211);
    }
    if let Some(var_212) = &input.ulimits {
        let mut array_213 = object.key("ulimits").start_array();
        for item_214 in var_212 {
            {
                #[allow(unused_mut)]
                let mut object_215 = array_213.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ulimit(&mut object_215, item_214)?;
                object_215.finish();
            }
        }
        array_213.finish();
    }
    if let Some(var_216) = &input.user {
        object.key("user").string(var_216.as_str());
    }
    if let Some(var_217) = &input.instance_type {
        object.key("instanceType").string(var_217.as_str());
    }
    if let Some(var_218) = &input.resource_requirements {
        let mut array_219 = object.key("resourceRequirements").start_array();
        for item_220 in var_218 {
            {
                #[allow(unused_mut)]
                let mut object_221 = array_219.value().start_object();
                crate::json_ser::serialize_structure_crate_model_resource_requirement(
                    &mut object_221,
                    item_220,
                )?;
                object_221.finish();
            }
        }
        array_219.finish();
    }
    if let Some(var_222) = &input.linux_parameters {
        #[allow(unused_mut)]
        let mut object_223 = object.key("linuxParameters").start_object();
        crate::json_ser::serialize_structure_crate_model_linux_parameters(
            &mut object_223,
            var_222,
        )?;
        object_223.finish();
    }
    if let Some(var_224) = &input.log_configuration {
        #[allow(unused_mut)]
        let mut object_225 = object.key("logConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_log_configuration(
            &mut object_225,
            var_224,
        )?;
        object_225.finish();
    }
    if let Some(var_226) = &input.secrets {
        let mut array_227 = object.key("secrets").start_array();
        for item_228 in var_226 {
            {
                #[allow(unused_mut)]
                let mut object_229 = array_227.value().start_object();
                crate::json_ser::serialize_structure_crate_model_secret(&mut object_229, item_228)?;
                object_229.finish();
            }
        }
        array_227.finish();
    }
    if let Some(var_230) = &input.network_configuration {
        #[allow(unused_mut)]
        let mut object_231 = object.key("networkConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_network_configuration(
            &mut object_231,
            var_230,
        )?;
        object_231.finish();
    }
    if let Some(var_232) = &input.fargate_platform_configuration {
        #[allow(unused_mut)]
        let mut object_233 = object.key("fargatePlatformConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_fargate_platform_configuration(
            &mut object_233,
            var_232,
        )?;
        object_233.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_node_properties(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NodeProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_234) = &input.num_nodes {
        object.key("numNodes").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_234).into()),
        );
    }
    if let Some(var_235) = &input.main_node {
        object.key("mainNode").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_235).into()),
        );
    }
    if let Some(var_236) = &input.node_range_properties {
        let mut array_237 = object.key("nodeRangeProperties").start_array();
        for item_238 in var_236 {
            {
                #[allow(unused_mut)]
                let mut object_239 = array_237.value().start_object();
                crate::json_ser::serialize_structure_crate_model_node_range_property(
                    &mut object_239,
                    item_238,
                )?;
                object_239.finish();
            }
        }
        array_237.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_retry_strategy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::RetryStrategy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_240) = &input.attempts {
        object.key("attempts").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_240).into()),
        );
    }
    if let Some(var_241) = &input.evaluate_on_exit {
        let mut array_242 = object.key("evaluateOnExit").start_array();
        for item_243 in var_241 {
            {
                #[allow(unused_mut)]
                let mut object_244 = array_242.value().start_object();
                crate::json_ser::serialize_structure_crate_model_evaluate_on_exit(
                    &mut object_244,
                    item_243,
                )?;
                object_244.finish();
            }
        }
        array_242.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_job_timeout(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::JobTimeout,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_245) = &input.attempt_duration_seconds {
        object.key("attemptDurationSeconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_245).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_array_properties(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ArrayProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_246) = &input.size {
        object.key("size").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_246).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_container_overrides(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ContainerOverrides,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_247) = &input.vcpus {
        object.key("vcpus").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_247).into()),
        );
    }
    if let Some(var_248) = &input.memory {
        object.key("memory").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_248).into()),
        );
    }
    if let Some(var_249) = &input.command {
        let mut array_250 = object.key("command").start_array();
        for item_251 in var_249 {
            {
                array_250.value().string(item_251.as_str());
            }
        }
        array_250.finish();
    }
    if let Some(var_252) = &input.instance_type {
        object.key("instanceType").string(var_252.as_str());
    }
    if let Some(var_253) = &input.environment {
        let mut array_254 = object.key("environment").start_array();
        for item_255 in var_253 {
            {
                #[allow(unused_mut)]
                let mut object_256 = array_254.value().start_object();
                crate::json_ser::serialize_structure_crate_model_key_value_pair(
                    &mut object_256,
                    item_255,
                )?;
                object_256.finish();
            }
        }
        array_254.finish();
    }
    if let Some(var_257) = &input.resource_requirements {
        let mut array_258 = object.key("resourceRequirements").start_array();
        for item_259 in var_257 {
            {
                #[allow(unused_mut)]
                let mut object_260 = array_258.value().start_object();
                crate::json_ser::serialize_structure_crate_model_resource_requirement(
                    &mut object_260,
                    item_259,
                )?;
                object_260.finish();
            }
        }
        array_258.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_job_dependency(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::JobDependency,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_261) = &input.job_id {
        object.key("jobId").string(var_261.as_str());
    }
    if let Some(var_262) = &input.r#type {
        object.key("type").string(var_262.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_node_overrides(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NodeOverrides,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_263) = &input.num_nodes {
        object.key("numNodes").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_263).into()),
        );
    }
    if let Some(var_264) = &input.node_property_overrides {
        let mut array_265 = object.key("nodePropertyOverrides").start_array();
        for item_266 in var_264 {
            {
                #[allow(unused_mut)]
                let mut object_267 = array_265.value().start_object();
                crate::json_ser::serialize_structure_crate_model_node_property_override(
                    &mut object_267,
                    item_266,
                )?;
                object_267.finish();
            }
        }
        array_265.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_compute_resource_update(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ComputeResourceUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_268) = &input.minv_cpus {
        object.key("minvCpus").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_268).into()),
        );
    }
    if let Some(var_269) = &input.maxv_cpus {
        object.key("maxvCpus").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_269).into()),
        );
    }
    if let Some(var_270) = &input.desiredv_cpus {
        object.key("desiredvCpus").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_270).into()),
        );
    }
    if let Some(var_271) = &input.subnets {
        let mut array_272 = object.key("subnets").start_array();
        for item_273 in var_271 {
            {
                array_272.value().string(item_273.as_str());
            }
        }
        array_272.finish();
    }
    if let Some(var_274) = &input.security_group_ids {
        let mut array_275 = object.key("securityGroupIds").start_array();
        for item_276 in var_274 {
            {
                array_275.value().string(item_276.as_str());
            }
        }
        array_275.finish();
    }
    if let Some(var_277) = &input.allocation_strategy {
        object.key("allocationStrategy").string(var_277.as_str());
    }
    if let Some(var_278) = &input.instance_types {
        let mut array_279 = object.key("instanceTypes").start_array();
        for item_280 in var_278 {
            {
                array_279.value().string(item_280.as_str());
            }
        }
        array_279.finish();
    }
    if let Some(var_281) = &input.ec2_key_pair {
        object.key("ec2KeyPair").string(var_281.as_str());
    }
    if let Some(var_282) = &input.instance_role {
        object.key("instanceRole").string(var_282.as_str());
    }
    if let Some(var_283) = &input.tags {
        #[allow(unused_mut)]
        let mut object_284 = object.key("tags").start_object();
        for (key_285, value_286) in var_283 {
            {
                object_284.key(key_285.as_str()).string(value_286.as_str());
            }
        }
        object_284.finish();
    }
    if let Some(var_287) = &input.placement_group {
        object.key("placementGroup").string(var_287.as_str());
    }
    if let Some(var_288) = &input.bid_percentage {
        object.key("bidPercentage").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_288).into()),
        );
    }
    if let Some(var_289) = &input.launch_template {
        #[allow(unused_mut)]
        let mut object_290 = object.key("launchTemplate").start_object();
        crate::json_ser::serialize_structure_crate_model_launch_template_specification(
            &mut object_290,
            var_289,
        )?;
        object_290.finish();
    }
    if let Some(var_291) = &input.ec2_configuration {
        let mut array_292 = object.key("ec2Configuration").start_array();
        for item_293 in var_291 {
            {
                #[allow(unused_mut)]
                let mut object_294 = array_292.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ec2_configuration(
                    &mut object_294,
                    item_293,
                )?;
                object_294.finish();
            }
        }
        array_292.finish();
    }
    if let Some(var_295) = &input.update_to_latest_image_version {
        object.key("updateToLatestImageVersion").boolean(*var_295);
    }
    if let Some(var_296) = &input.r#type {
        object.key("type").string(var_296.as_str());
    }
    if let Some(var_297) = &input.image_id {
        object.key("imageId").string(var_297.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_update_policy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::UpdatePolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_298) = &input.terminate_jobs_on_update {
        object.key("terminateJobsOnUpdate").boolean(*var_298);
    }
    if input.job_execution_timeout_minutes != 0 {
        object.key("jobExecutionTimeoutMinutes").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.job_execution_timeout_minutes).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_launch_template_specification(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::LaunchTemplateSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_299) = &input.launch_template_id {
        object.key("launchTemplateId").string(var_299.as_str());
    }
    if let Some(var_300) = &input.launch_template_name {
        object.key("launchTemplateName").string(var_300.as_str());
    }
    if let Some(var_301) = &input.version {
        object.key("version").string(var_301.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_ec2_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Ec2Configuration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_302) = &input.image_type {
        object.key("imageType").string(var_302.as_str());
    }
    if let Some(var_303) = &input.image_id_override {
        object.key("imageIdOverride").string(var_303.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_share_attributes(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ShareAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_304) = &input.share_identifier {
        object.key("shareIdentifier").string(var_304.as_str());
    }
    if let Some(var_305) = &input.weight_factor {
        object.key("weightFactor").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((*var_305).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_volume(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Volume,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_306) = &input.host {
        #[allow(unused_mut)]
        let mut object_307 = object.key("host").start_object();
        crate::json_ser::serialize_structure_crate_model_host(&mut object_307, var_306)?;
        object_307.finish();
    }
    if let Some(var_308) = &input.name {
        object.key("name").string(var_308.as_str());
    }
    if let Some(var_309) = &input.efs_volume_configuration {
        #[allow(unused_mut)]
        let mut object_310 = object.key("efsVolumeConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_efs_volume_configuration(
            &mut object_310,
            var_309,
        )?;
        object_310.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_key_value_pair(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::KeyValuePair,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_311) = &input.name {
        object.key("name").string(var_311.as_str());
    }
    if let Some(var_312) = &input.value {
        object.key("value").string(var_312.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_mount_point(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MountPoint,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_313) = &input.container_path {
        object.key("containerPath").string(var_313.as_str());
    }
    if let Some(var_314) = &input.read_only {
        object.key("readOnly").boolean(*var_314);
    }
    if let Some(var_315) = &input.source_volume {
        object.key("sourceVolume").string(var_315.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_ulimit(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Ulimit,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_316) = &input.hard_limit {
        object.key("hardLimit").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_316).into()),
        );
    }
    if let Some(var_317) = &input.name {
        object.key("name").string(var_317.as_str());
    }
    if let Some(var_318) = &input.soft_limit {
        object.key("softLimit").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_318).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_resource_requirement(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ResourceRequirement,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_319) = &input.value {
        object.key("value").string(var_319.as_str());
    }
    if let Some(var_320) = &input.r#type {
        object.key("type").string(var_320.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_linux_parameters(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::LinuxParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_321) = &input.devices {
        let mut array_322 = object.key("devices").start_array();
        for item_323 in var_321 {
            {
                #[allow(unused_mut)]
                let mut object_324 = array_322.value().start_object();
                crate::json_ser::serialize_structure_crate_model_device(&mut object_324, item_323)?;
                object_324.finish();
            }
        }
        array_322.finish();
    }
    if let Some(var_325) = &input.init_process_enabled {
        object.key("initProcessEnabled").boolean(*var_325);
    }
    if let Some(var_326) = &input.shared_memory_size {
        object.key("sharedMemorySize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_326).into()),
        );
    }
    if let Some(var_327) = &input.tmpfs {
        let mut array_328 = object.key("tmpfs").start_array();
        for item_329 in var_327 {
            {
                #[allow(unused_mut)]
                let mut object_330 = array_328.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tmpfs(&mut object_330, item_329)?;
                object_330.finish();
            }
        }
        array_328.finish();
    }
    if let Some(var_331) = &input.max_swap {
        object.key("maxSwap").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_331).into()),
        );
    }
    if let Some(var_332) = &input.swappiness {
        object.key("swappiness").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_332).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_log_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::LogConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_333) = &input.log_driver {
        object.key("logDriver").string(var_333.as_str());
    }
    if let Some(var_334) = &input.options {
        #[allow(unused_mut)]
        let mut object_335 = object.key("options").start_object();
        for (key_336, value_337) in var_334 {
            {
                object_335.key(key_336.as_str()).string(value_337.as_str());
            }
        }
        object_335.finish();
    }
    if let Some(var_338) = &input.secret_options {
        let mut array_339 = object.key("secretOptions").start_array();
        for item_340 in var_338 {
            {
                #[allow(unused_mut)]
                let mut object_341 = array_339.value().start_object();
                crate::json_ser::serialize_structure_crate_model_secret(&mut object_341, item_340)?;
                object_341.finish();
            }
        }
        array_339.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_secret(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Secret,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_342) = &input.name {
        object.key("name").string(var_342.as_str());
    }
    if let Some(var_343) = &input.value_from {
        object.key("valueFrom").string(var_343.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_network_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NetworkConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_344) = &input.assign_public_ip {
        object.key("assignPublicIp").string(var_344.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_fargate_platform_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FargatePlatformConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_345) = &input.platform_version {
        object.key("platformVersion").string(var_345.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_node_range_property(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NodeRangeProperty,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_346) = &input.target_nodes {
        object.key("targetNodes").string(var_346.as_str());
    }
    if let Some(var_347) = &input.container {
        #[allow(unused_mut)]
        let mut object_348 = object.key("container").start_object();
        crate::json_ser::serialize_structure_crate_model_container_properties(
            &mut object_348,
            var_347,
        )?;
        object_348.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_evaluate_on_exit(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::EvaluateOnExit,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_349) = &input.on_status_reason {
        object.key("onStatusReason").string(var_349.as_str());
    }
    if let Some(var_350) = &input.on_reason {
        object.key("onReason").string(var_350.as_str());
    }
    if let Some(var_351) = &input.on_exit_code {
        object.key("onExitCode").string(var_351.as_str());
    }
    if let Some(var_352) = &input.action {
        object.key("action").string(var_352.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_node_property_override(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NodePropertyOverride,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_353) = &input.target_nodes {
        object.key("targetNodes").string(var_353.as_str());
    }
    if let Some(var_354) = &input.container_overrides {
        #[allow(unused_mut)]
        let mut object_355 = object.key("containerOverrides").start_object();
        crate::json_ser::serialize_structure_crate_model_container_overrides(
            &mut object_355,
            var_354,
        )?;
        object_355.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_host(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Host,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_356) = &input.source_path {
        object.key("sourcePath").string(var_356.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_efs_volume_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::EfsVolumeConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_357) = &input.file_system_id {
        object.key("fileSystemId").string(var_357.as_str());
    }
    if let Some(var_358) = &input.root_directory {
        object.key("rootDirectory").string(var_358.as_str());
    }
    if let Some(var_359) = &input.transit_encryption {
        object.key("transitEncryption").string(var_359.as_str());
    }
    if let Some(var_360) = &input.transit_encryption_port {
        object.key("transitEncryptionPort").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_360).into()),
        );
    }
    if let Some(var_361) = &input.authorization_config {
        #[allow(unused_mut)]
        let mut object_362 = object.key("authorizationConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_efs_authorization_config(
            &mut object_362,
            var_361,
        )?;
        object_362.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_device(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Device,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_363) = &input.host_path {
        object.key("hostPath").string(var_363.as_str());
    }
    if let Some(var_364) = &input.container_path {
        object.key("containerPath").string(var_364.as_str());
    }
    if let Some(var_365) = &input.permissions {
        let mut array_366 = object.key("permissions").start_array();
        for item_367 in var_365 {
            {
                array_366.value().string(item_367.as_str());
            }
        }
        array_366.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_tmpfs(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Tmpfs,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_368) = &input.container_path {
        object.key("containerPath").string(var_368.as_str());
    }
    if let Some(var_369) = &input.size {
        object.key("size").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_369).into()),
        );
    }
    if let Some(var_370) = &input.mount_options {
        let mut array_371 = object.key("mountOptions").start_array();
        for item_372 in var_370 {
            {
                array_371.value().string(item_372.as_str());
            }
        }
        array_371.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_efs_authorization_config(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::EfsAuthorizationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_373) = &input.access_point_id {
        object.key("accessPointId").string(var_373.as_str());
    }
    if let Some(var_374) = &input.iam {
        object.key("iam").string(var_374.as_str());
    }
    Ok(())
}