aws-sdk-mediaconvert 0.5.0

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

pub fn serialize_structure_crate_input_create_job_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateJobInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_2) = &input.acceleration_settings {
        let mut object_3 = object.key("accelerationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_acceleration_settings(
            &mut object_3,
            var_2,
        )?;
        object_3.finish();
    }
    if let Some(var_4) = &input.billing_tags_source {
        object.key("billingTagsSource").string(var_4.as_str());
    }
    if let Some(var_5) = &input.client_request_token {
        object.key("clientRequestToken").string(var_5);
    }
    if let Some(var_6) = &input.hop_destinations {
        let mut array_7 = object.key("hopDestinations").start_array();
        for item_8 in var_6 {
            {
                let mut object_9 = array_7.value().start_object();
                crate::json_ser::serialize_structure_crate_model_hop_destination(
                    &mut object_9,
                    item_8,
                )?;
                object_9.finish();
            }
        }
        array_7.finish();
    }
    if let Some(var_10) = &input.job_template {
        object.key("jobTemplate").string(var_10);
    }
    if input.priority != 0 {
        object.key("priority").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.priority).into()),
        );
    }
    if let Some(var_11) = &input.queue {
        object.key("queue").string(var_11);
    }
    if let Some(var_12) = &input.role {
        object.key("role").string(var_12);
    }
    if let Some(var_13) = &input.settings {
        let mut object_14 = object.key("settings").start_object();
        crate::json_ser::serialize_structure_crate_model_job_settings(&mut object_14, var_13)?;
        object_14.finish();
    }
    if let Some(var_15) = &input.simulate_reserved_queue {
        object.key("simulateReservedQueue").string(var_15.as_str());
    }
    if let Some(var_16) = &input.status_update_interval {
        object.key("statusUpdateInterval").string(var_16.as_str());
    }
    if let Some(var_17) = &input.tags {
        let mut object_18 = object.key("tags").start_object();
        for (key_19, value_20) in var_17 {
            {
                object_18.key(key_19).string(value_20);
            }
        }
        object_18.finish();
    }
    if let Some(var_21) = &input.user_metadata {
        let mut object_22 = object.key("userMetadata").start_object();
        for (key_23, value_24) in var_21 {
            {
                object_22.key(key_23).string(value_24);
            }
        }
        object_22.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_job_template_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateJobTemplateInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_25) = &input.acceleration_settings {
        let mut object_26 = object.key("accelerationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_acceleration_settings(
            &mut object_26,
            var_25,
        )?;
        object_26.finish();
    }
    if let Some(var_27) = &input.category {
        object.key("category").string(var_27);
    }
    if let Some(var_28) = &input.description {
        object.key("description").string(var_28);
    }
    if let Some(var_29) = &input.hop_destinations {
        let mut array_30 = object.key("hopDestinations").start_array();
        for item_31 in var_29 {
            {
                let mut object_32 = array_30.value().start_object();
                crate::json_ser::serialize_structure_crate_model_hop_destination(
                    &mut object_32,
                    item_31,
                )?;
                object_32.finish();
            }
        }
        array_30.finish();
    }
    if let Some(var_33) = &input.name {
        object.key("name").string(var_33);
    }
    if input.priority != 0 {
        object.key("priority").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.priority).into()),
        );
    }
    if let Some(var_34) = &input.queue {
        object.key("queue").string(var_34);
    }
    if let Some(var_35) = &input.settings {
        let mut object_36 = object.key("settings").start_object();
        crate::json_ser::serialize_structure_crate_model_job_template_settings(
            &mut object_36,
            var_35,
        )?;
        object_36.finish();
    }
    if let Some(var_37) = &input.status_update_interval {
        object.key("statusUpdateInterval").string(var_37.as_str());
    }
    if let Some(var_38) = &input.tags {
        let mut object_39 = object.key("tags").start_object();
        for (key_40, value_41) in var_38 {
            {
                object_39.key(key_40).string(value_41);
            }
        }
        object_39.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_preset_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreatePresetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_42) = &input.category {
        object.key("category").string(var_42);
    }
    if let Some(var_43) = &input.description {
        object.key("description").string(var_43);
    }
    if let Some(var_44) = &input.name {
        object.key("name").string(var_44);
    }
    if let Some(var_45) = &input.settings {
        let mut object_46 = object.key("settings").start_object();
        crate::json_ser::serialize_structure_crate_model_preset_settings(&mut object_46, var_45)?;
        object_46.finish();
    }
    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();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_queue_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateQueueInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_51) = &input.description {
        object.key("description").string(var_51);
    }
    if let Some(var_52) = &input.name {
        object.key("name").string(var_52);
    }
    if let Some(var_53) = &input.pricing_plan {
        object.key("pricingPlan").string(var_53.as_str());
    }
    if let Some(var_54) = &input.reservation_plan_settings {
        let mut object_55 = object.key("reservationPlanSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_reservation_plan_settings(
            &mut object_55,
            var_54,
        )?;
        object_55.finish();
    }
    if let Some(var_56) = &input.status {
        object.key("status").string(var_56.as_str());
    }
    if let Some(var_57) = &input.tags {
        let mut object_58 = object.key("tags").start_object();
        for (key_59, value_60) in var_57 {
            {
                object_58.key(key_59).string(value_60);
            }
        }
        object_58.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_endpoints_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeEndpointsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    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.mode {
        object.key("mode").string(var_61.as_str());
    }
    if let Some(var_62) = &input.next_token {
        object.key("nextToken").string(var_62);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_policy_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutPolicyInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_63) = &input.policy {
        let mut object_64 = object.key("policy").start_object();
        crate::json_ser::serialize_structure_crate_model_policy(&mut object_64, var_63)?;
        object_64.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::SerializationError> {
    if let Some(var_65) = &input.arn {
        object.key("arn").string(var_65);
    }
    if let Some(var_66) = &input.tags {
        let mut object_67 = object.key("tags").start_object();
        for (key_68, value_69) in var_66 {
            {
                object_67.key(key_68).string(value_69);
            }
        }
        object_67.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_untag_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_70) = &input.tag_keys {
        let mut array_71 = object.key("tagKeys").start_array();
        for item_72 in var_70 {
            {
                array_71.value().string(item_72);
            }
        }
        array_71.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_job_template_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateJobTemplateInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_73) = &input.acceleration_settings {
        let mut object_74 = object.key("accelerationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_acceleration_settings(
            &mut object_74,
            var_73,
        )?;
        object_74.finish();
    }
    if let Some(var_75) = &input.category {
        object.key("category").string(var_75);
    }
    if let Some(var_76) = &input.description {
        object.key("description").string(var_76);
    }
    if let Some(var_77) = &input.hop_destinations {
        let mut array_78 = object.key("hopDestinations").start_array();
        for item_79 in var_77 {
            {
                let mut object_80 = array_78.value().start_object();
                crate::json_ser::serialize_structure_crate_model_hop_destination(
                    &mut object_80,
                    item_79,
                )?;
                object_80.finish();
            }
        }
        array_78.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_81) = &input.queue {
        object.key("queue").string(var_81);
    }
    if let Some(var_82) = &input.settings {
        let mut object_83 = object.key("settings").start_object();
        crate::json_ser::serialize_structure_crate_model_job_template_settings(
            &mut object_83,
            var_82,
        )?;
        object_83.finish();
    }
    if let Some(var_84) = &input.status_update_interval {
        object.key("statusUpdateInterval").string(var_84.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_preset_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdatePresetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_85) = &input.category {
        object.key("category").string(var_85);
    }
    if let Some(var_86) = &input.description {
        object.key("description").string(var_86);
    }
    if let Some(var_87) = &input.settings {
        let mut object_88 = object.key("settings").start_object();
        crate::json_ser::serialize_structure_crate_model_preset_settings(&mut object_88, var_87)?;
        object_88.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_queue_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateQueueInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_89) = &input.description {
        object.key("description").string(var_89);
    }
    if let Some(var_90) = &input.reservation_plan_settings {
        let mut object_91 = object.key("reservationPlanSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_reservation_plan_settings(
            &mut object_91,
            var_90,
        )?;
        object_91.finish();
    }
    if let Some(var_92) = &input.status {
        object.key("status").string(var_92.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_acceleration_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AccelerationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_93) = &input.mode {
        object.key("mode").string(var_93.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_hop_destination(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HopDestination,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.priority != 0 {
        object.key("priority").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.priority).into()),
        );
    }
    if let Some(var_94) = &input.queue {
        object.key("queue").string(var_94);
    }
    if input.wait_minutes != 0 {
        object.key("waitMinutes").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.wait_minutes).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_job_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::JobSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.ad_avail_offset != 0 {
        object.key("adAvailOffset").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.ad_avail_offset).into()),
        );
    }
    if let Some(var_95) = &input.avail_blanking {
        let mut object_96 = object.key("availBlanking").start_object();
        crate::json_ser::serialize_structure_crate_model_avail_blanking(&mut object_96, var_95)?;
        object_96.finish();
    }
    if let Some(var_97) = &input.esam {
        let mut object_98 = object.key("esam").start_object();
        crate::json_ser::serialize_structure_crate_model_esam_settings(&mut object_98, var_97)?;
        object_98.finish();
    }
    if let Some(var_99) = &input.extended_data_services {
        let mut object_100 = object.key("extendedDataServices").start_object();
        crate::json_ser::serialize_structure_crate_model_extended_data_services(
            &mut object_100,
            var_99,
        )?;
        object_100.finish();
    }
    if let Some(var_101) = &input.inputs {
        let mut array_102 = object.key("inputs").start_array();
        for item_103 in var_101 {
            {
                let mut object_104 = array_102.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input(&mut object_104, item_103)?;
                object_104.finish();
            }
        }
        array_102.finish();
    }
    if let Some(var_105) = &input.kantar_watermark {
        let mut object_106 = object.key("kantarWatermark").start_object();
        crate::json_ser::serialize_structure_crate_model_kantar_watermark_settings(
            &mut object_106,
            var_105,
        )?;
        object_106.finish();
    }
    if let Some(var_107) = &input.motion_image_inserter {
        let mut object_108 = object.key("motionImageInserter").start_object();
        crate::json_ser::serialize_structure_crate_model_motion_image_inserter(
            &mut object_108,
            var_107,
        )?;
        object_108.finish();
    }
    if let Some(var_109) = &input.nielsen_configuration {
        let mut object_110 = object.key("nielsenConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_nielsen_configuration(
            &mut object_110,
            var_109,
        )?;
        object_110.finish();
    }
    if let Some(var_111) = &input.nielsen_non_linear_watermark {
        let mut object_112 = object.key("nielsenNonLinearWatermark").start_object();
        crate::json_ser::serialize_structure_crate_model_nielsen_non_linear_watermark_settings(
            &mut object_112,
            var_111,
        )?;
        object_112.finish();
    }
    if let Some(var_113) = &input.output_groups {
        let mut array_114 = object.key("outputGroups").start_array();
        for item_115 in var_113 {
            {
                let mut object_116 = array_114.value().start_object();
                crate::json_ser::serialize_structure_crate_model_output_group(
                    &mut object_116,
                    item_115,
                )?;
                object_116.finish();
            }
        }
        array_114.finish();
    }
    if let Some(var_117) = &input.timecode_config {
        let mut object_118 = object.key("timecodeConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_timecode_config(&mut object_118, var_117)?;
        object_118.finish();
    }
    if let Some(var_119) = &input.timed_metadata_insertion {
        let mut object_120 = object.key("timedMetadataInsertion").start_object();
        crate::json_ser::serialize_structure_crate_model_timed_metadata_insertion(
            &mut object_120,
            var_119,
        )?;
        object_120.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_job_template_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::JobTemplateSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.ad_avail_offset != 0 {
        object.key("adAvailOffset").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.ad_avail_offset).into()),
        );
    }
    if let Some(var_121) = &input.avail_blanking {
        let mut object_122 = object.key("availBlanking").start_object();
        crate::json_ser::serialize_structure_crate_model_avail_blanking(&mut object_122, var_121)?;
        object_122.finish();
    }
    if let Some(var_123) = &input.esam {
        let mut object_124 = object.key("esam").start_object();
        crate::json_ser::serialize_structure_crate_model_esam_settings(&mut object_124, var_123)?;
        object_124.finish();
    }
    if let Some(var_125) = &input.extended_data_services {
        let mut object_126 = object.key("extendedDataServices").start_object();
        crate::json_ser::serialize_structure_crate_model_extended_data_services(
            &mut object_126,
            var_125,
        )?;
        object_126.finish();
    }
    if let Some(var_127) = &input.inputs {
        let mut array_128 = object.key("inputs").start_array();
        for item_129 in var_127 {
            {
                let mut object_130 = array_128.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_template(
                    &mut object_130,
                    item_129,
                )?;
                object_130.finish();
            }
        }
        array_128.finish();
    }
    if let Some(var_131) = &input.kantar_watermark {
        let mut object_132 = object.key("kantarWatermark").start_object();
        crate::json_ser::serialize_structure_crate_model_kantar_watermark_settings(
            &mut object_132,
            var_131,
        )?;
        object_132.finish();
    }
    if let Some(var_133) = &input.motion_image_inserter {
        let mut object_134 = object.key("motionImageInserter").start_object();
        crate::json_ser::serialize_structure_crate_model_motion_image_inserter(
            &mut object_134,
            var_133,
        )?;
        object_134.finish();
    }
    if let Some(var_135) = &input.nielsen_configuration {
        let mut object_136 = object.key("nielsenConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_nielsen_configuration(
            &mut object_136,
            var_135,
        )?;
        object_136.finish();
    }
    if let Some(var_137) = &input.nielsen_non_linear_watermark {
        let mut object_138 = object.key("nielsenNonLinearWatermark").start_object();
        crate::json_ser::serialize_structure_crate_model_nielsen_non_linear_watermark_settings(
            &mut object_138,
            var_137,
        )?;
        object_138.finish();
    }
    if let Some(var_139) = &input.output_groups {
        let mut array_140 = object.key("outputGroups").start_array();
        for item_141 in var_139 {
            {
                let mut object_142 = array_140.value().start_object();
                crate::json_ser::serialize_structure_crate_model_output_group(
                    &mut object_142,
                    item_141,
                )?;
                object_142.finish();
            }
        }
        array_140.finish();
    }
    if let Some(var_143) = &input.timecode_config {
        let mut object_144 = object.key("timecodeConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_timecode_config(&mut object_144, var_143)?;
        object_144.finish();
    }
    if let Some(var_145) = &input.timed_metadata_insertion {
        let mut object_146 = object.key("timedMetadataInsertion").start_object();
        crate::json_ser::serialize_structure_crate_model_timed_metadata_insertion(
            &mut object_146,
            var_145,
        )?;
        object_146.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_preset_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::PresetSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_147) = &input.audio_descriptions {
        let mut array_148 = object.key("audioDescriptions").start_array();
        for item_149 in var_147 {
            {
                let mut object_150 = array_148.value().start_object();
                crate::json_ser::serialize_structure_crate_model_audio_description(
                    &mut object_150,
                    item_149,
                )?;
                object_150.finish();
            }
        }
        array_148.finish();
    }
    if let Some(var_151) = &input.caption_descriptions {
        let mut array_152 = object.key("captionDescriptions").start_array();
        for item_153 in var_151 {
            {
                let mut object_154 = array_152.value().start_object();
                crate::json_ser::serialize_structure_crate_model_caption_description_preset(
                    &mut object_154,
                    item_153,
                )?;
                object_154.finish();
            }
        }
        array_152.finish();
    }
    if let Some(var_155) = &input.container_settings {
        let mut object_156 = object.key("containerSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_container_settings(
            &mut object_156,
            var_155,
        )?;
        object_156.finish();
    }
    if let Some(var_157) = &input.video_description {
        let mut object_158 = object.key("videoDescription").start_object();
        crate::json_ser::serialize_structure_crate_model_video_description(
            &mut object_158,
            var_157,
        )?;
        object_158.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_reservation_plan_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ReservationPlanSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_159) = &input.commitment {
        object.key("commitment").string(var_159.as_str());
    }
    if let Some(var_160) = &input.renewal_type {
        object.key("renewalType").string(var_160.as_str());
    }
    {
        object.key("reservedSlots").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.reserved_slots).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_policy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Policy,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_161) = &input.http_inputs {
        object.key("httpInputs").string(var_161.as_str());
    }
    if let Some(var_162) = &input.https_inputs {
        object.key("httpsInputs").string(var_162.as_str());
    }
    if let Some(var_163) = &input.s3_inputs {
        object.key("s3Inputs").string(var_163.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_avail_blanking(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AvailBlanking,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_164) = &input.avail_blanking_image {
        object.key("availBlankingImage").string(var_164);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_esam_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::EsamSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_165) = &input.manifest_confirm_condition_notification {
        let mut object_166 = object
            .key("manifestConfirmConditionNotification")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_esam_manifest_confirm_condition_notification(&mut object_166, var_165)?;
        object_166.finish();
    }
    if input.response_signal_preroll != 0 {
        object.key("responseSignalPreroll").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.response_signal_preroll).into()),
        );
    }
    if let Some(var_167) = &input.signal_processing_notification {
        let mut object_168 = object.key("signalProcessingNotification").start_object();
        crate::json_ser::serialize_structure_crate_model_esam_signal_processing_notification(
            &mut object_168,
            var_167,
        )?;
        object_168.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_extended_data_services(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ExtendedDataServices,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_169) = &input.copy_protection_action {
        object.key("copyProtectionAction").string(var_169.as_str());
    }
    if let Some(var_170) = &input.vchip_action {
        object.key("vchipAction").string(var_170.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Input,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_171) = &input.audio_selector_groups {
        let mut object_172 = object.key("audioSelectorGroups").start_object();
        for (key_173, value_174) in var_171 {
            {
                let mut object_175 = object_172.key(key_173).start_object();
                crate::json_ser::serialize_structure_crate_model_audio_selector_group(
                    &mut object_175,
                    value_174,
                )?;
                object_175.finish();
            }
        }
        object_172.finish();
    }
    if let Some(var_176) = &input.audio_selectors {
        let mut object_177 = object.key("audioSelectors").start_object();
        for (key_178, value_179) in var_176 {
            {
                let mut object_180 = object_177.key(key_178).start_object();
                crate::json_ser::serialize_structure_crate_model_audio_selector(
                    &mut object_180,
                    value_179,
                )?;
                object_180.finish();
            }
        }
        object_177.finish();
    }
    if let Some(var_181) = &input.caption_selectors {
        let mut object_182 = object.key("captionSelectors").start_object();
        for (key_183, value_184) in var_181 {
            {
                let mut object_185 = object_182.key(key_183).start_object();
                crate::json_ser::serialize_structure_crate_model_caption_selector(
                    &mut object_185,
                    value_184,
                )?;
                object_185.finish();
            }
        }
        object_182.finish();
    }
    if let Some(var_186) = &input.crop {
        let mut object_187 = object.key("crop").start_object();
        crate::json_ser::serialize_structure_crate_model_rectangle(&mut object_187, var_186)?;
        object_187.finish();
    }
    if let Some(var_188) = &input.deblock_filter {
        object.key("deblockFilter").string(var_188.as_str());
    }
    if let Some(var_189) = &input.decryption_settings {
        let mut object_190 = object.key("decryptionSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_input_decryption_settings(
            &mut object_190,
            var_189,
        )?;
        object_190.finish();
    }
    if let Some(var_191) = &input.denoise_filter {
        object.key("denoiseFilter").string(var_191.as_str());
    }
    if let Some(var_192) = &input.file_input {
        object.key("fileInput").string(var_192);
    }
    if let Some(var_193) = &input.filter_enable {
        object.key("filterEnable").string(var_193.as_str());
    }
    if input.filter_strength != 0 {
        object.key("filterStrength").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.filter_strength).into()),
        );
    }
    if let Some(var_194) = &input.image_inserter {
        let mut object_195 = object.key("imageInserter").start_object();
        crate::json_ser::serialize_structure_crate_model_image_inserter(&mut object_195, var_194)?;
        object_195.finish();
    }
    if let Some(var_196) = &input.input_clippings {
        let mut array_197 = object.key("inputClippings").start_array();
        for item_198 in var_196 {
            {
                let mut object_199 = array_197.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_clipping(
                    &mut object_199,
                    item_198,
                )?;
                object_199.finish();
            }
        }
        array_197.finish();
    }
    if let Some(var_200) = &input.input_scan_type {
        object.key("inputScanType").string(var_200.as_str());
    }
    if let Some(var_201) = &input.position {
        let mut object_202 = object.key("position").start_object();
        crate::json_ser::serialize_structure_crate_model_rectangle(&mut object_202, var_201)?;
        object_202.finish();
    }
    if input.program_number != 0 {
        object.key("programNumber").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.program_number).into()),
        );
    }
    if let Some(var_203) = &input.psi_control {
        object.key("psiControl").string(var_203.as_str());
    }
    if let Some(var_204) = &input.supplemental_imps {
        let mut array_205 = object.key("supplementalImps").start_array();
        for item_206 in var_204 {
            {
                array_205.value().string(item_206);
            }
        }
        array_205.finish();
    }
    if let Some(var_207) = &input.timecode_source {
        object.key("timecodeSource").string(var_207.as_str());
    }
    if let Some(var_208) = &input.timecode_start {
        object.key("timecodeStart").string(var_208);
    }
    if let Some(var_209) = &input.video_selector {
        let mut object_210 = object.key("videoSelector").start_object();
        crate::json_ser::serialize_structure_crate_model_video_selector(&mut object_210, var_209)?;
        object_210.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_kantar_watermark_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::KantarWatermarkSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_211) = &input.channel_name {
        object.key("channelName").string(var_211);
    }
    if let Some(var_212) = &input.content_reference {
        object.key("contentReference").string(var_212);
    }
    if let Some(var_213) = &input.credentials_secret_name {
        object.key("credentialsSecretName").string(var_213);
    }
    if input.file_offset != 0.0 {
        object.key("fileOffset").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.file_offset).into()),
        );
    }
    if input.kantar_license_id != 0 {
        object.key("kantarLicenseId").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.kantar_license_id).into()),
        );
    }
    if let Some(var_214) = &input.kantar_server_url {
        object.key("kantarServerUrl").string(var_214);
    }
    if let Some(var_215) = &input.log_destination {
        object.key("logDestination").string(var_215);
    }
    if let Some(var_216) = &input.metadata3 {
        object.key("metadata3").string(var_216);
    }
    if let Some(var_217) = &input.metadata4 {
        object.key("metadata4").string(var_217);
    }
    if let Some(var_218) = &input.metadata5 {
        object.key("metadata5").string(var_218);
    }
    if let Some(var_219) = &input.metadata6 {
        object.key("metadata6").string(var_219);
    }
    if let Some(var_220) = &input.metadata7 {
        object.key("metadata7").string(var_220);
    }
    if let Some(var_221) = &input.metadata8 {
        object.key("metadata8").string(var_221);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_motion_image_inserter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MotionImageInserter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_222) = &input.framerate {
        let mut object_223 = object.key("framerate").start_object();
        crate::json_ser::serialize_structure_crate_model_motion_image_insertion_framerate(
            &mut object_223,
            var_222,
        )?;
        object_223.finish();
    }
    if let Some(var_224) = &input.input {
        object.key("input").string(var_224);
    }
    if let Some(var_225) = &input.insertion_mode {
        object.key("insertionMode").string(var_225.as_str());
    }
    if let Some(var_226) = &input.offset {
        let mut object_227 = object.key("offset").start_object();
        crate::json_ser::serialize_structure_crate_model_motion_image_insertion_offset(
            &mut object_227,
            var_226,
        )?;
        object_227.finish();
    }
    if let Some(var_228) = &input.playback {
        object.key("playback").string(var_228.as_str());
    }
    if let Some(var_229) = &input.start_time {
        object.key("startTime").string(var_229);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_nielsen_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NielsenConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.breakout_code != 0 {
        object.key("breakoutCode").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.breakout_code).into()),
        );
    }
    if let Some(var_230) = &input.distributor_id {
        object.key("distributorId").string(var_230);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_nielsen_non_linear_watermark_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NielsenNonLinearWatermarkSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_231) = &input.active_watermark_process {
        object
            .key("activeWatermarkProcess")
            .string(var_231.as_str());
    }
    if let Some(var_232) = &input.adi_filename {
        object.key("adiFilename").string(var_232);
    }
    if let Some(var_233) = &input.asset_id {
        object.key("assetId").string(var_233);
    }
    if let Some(var_234) = &input.asset_name {
        object.key("assetName").string(var_234);
    }
    if let Some(var_235) = &input.cbet_source_id {
        object.key("cbetSourceId").string(var_235);
    }
    if let Some(var_236) = &input.episode_id {
        object.key("episodeId").string(var_236);
    }
    if let Some(var_237) = &input.metadata_destination {
        object.key("metadataDestination").string(var_237);
    }
    if input.source_id != 0 {
        object.key("sourceId").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.source_id).into()),
        );
    }
    if let Some(var_238) = &input.source_watermark_status {
        object.key("sourceWatermarkStatus").string(var_238.as_str());
    }
    if let Some(var_239) = &input.tic_server_url {
        object.key("ticServerUrl").string(var_239);
    }
    if let Some(var_240) = &input.unique_tic_per_audio_track {
        object
            .key("uniqueTicPerAudioTrack")
            .string(var_240.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_output_group(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::OutputGroup,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_241) = &input.automated_encoding_settings {
        let mut object_242 = object.key("automatedEncodingSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_automated_encoding_settings(
            &mut object_242,
            var_241,
        )?;
        object_242.finish();
    }
    if let Some(var_243) = &input.custom_name {
        object.key("customName").string(var_243);
    }
    if let Some(var_244) = &input.name {
        object.key("name").string(var_244);
    }
    if let Some(var_245) = &input.output_group_settings {
        let mut object_246 = object.key("outputGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_output_group_settings(
            &mut object_246,
            var_245,
        )?;
        object_246.finish();
    }
    if let Some(var_247) = &input.outputs {
        let mut array_248 = object.key("outputs").start_array();
        for item_249 in var_247 {
            {
                let mut object_250 = array_248.value().start_object();
                crate::json_ser::serialize_structure_crate_model_output(&mut object_250, item_249)?;
                object_250.finish();
            }
        }
        array_248.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_timecode_config(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TimecodeConfig,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_251) = &input.anchor {
        object.key("anchor").string(var_251);
    }
    if let Some(var_252) = &input.source {
        object.key("source").string(var_252.as_str());
    }
    if let Some(var_253) = &input.start {
        object.key("start").string(var_253);
    }
    if let Some(var_254) = &input.timestamp_offset {
        object.key("timestampOffset").string(var_254);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_timed_metadata_insertion(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TimedMetadataInsertion,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_255) = &input.id3_insertions {
        let mut array_256 = object.key("id3Insertions").start_array();
        for item_257 in var_255 {
            {
                let mut object_258 = array_256.value().start_object();
                crate::json_ser::serialize_structure_crate_model_id3_insertion(
                    &mut object_258,
                    item_257,
                )?;
                object_258.finish();
            }
        }
        array_256.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_input_template(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::InputTemplate,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_259) = &input.audio_selector_groups {
        let mut object_260 = object.key("audioSelectorGroups").start_object();
        for (key_261, value_262) in var_259 {
            {
                let mut object_263 = object_260.key(key_261).start_object();
                crate::json_ser::serialize_structure_crate_model_audio_selector_group(
                    &mut object_263,
                    value_262,
                )?;
                object_263.finish();
            }
        }
        object_260.finish();
    }
    if let Some(var_264) = &input.audio_selectors {
        let mut object_265 = object.key("audioSelectors").start_object();
        for (key_266, value_267) in var_264 {
            {
                let mut object_268 = object_265.key(key_266).start_object();
                crate::json_ser::serialize_structure_crate_model_audio_selector(
                    &mut object_268,
                    value_267,
                )?;
                object_268.finish();
            }
        }
        object_265.finish();
    }
    if let Some(var_269) = &input.caption_selectors {
        let mut object_270 = object.key("captionSelectors").start_object();
        for (key_271, value_272) in var_269 {
            {
                let mut object_273 = object_270.key(key_271).start_object();
                crate::json_ser::serialize_structure_crate_model_caption_selector(
                    &mut object_273,
                    value_272,
                )?;
                object_273.finish();
            }
        }
        object_270.finish();
    }
    if let Some(var_274) = &input.crop {
        let mut object_275 = object.key("crop").start_object();
        crate::json_ser::serialize_structure_crate_model_rectangle(&mut object_275, var_274)?;
        object_275.finish();
    }
    if let Some(var_276) = &input.deblock_filter {
        object.key("deblockFilter").string(var_276.as_str());
    }
    if let Some(var_277) = &input.denoise_filter {
        object.key("denoiseFilter").string(var_277.as_str());
    }
    if let Some(var_278) = &input.filter_enable {
        object.key("filterEnable").string(var_278.as_str());
    }
    if input.filter_strength != 0 {
        object.key("filterStrength").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.filter_strength).into()),
        );
    }
    if let Some(var_279) = &input.image_inserter {
        let mut object_280 = object.key("imageInserter").start_object();
        crate::json_ser::serialize_structure_crate_model_image_inserter(&mut object_280, var_279)?;
        object_280.finish();
    }
    if let Some(var_281) = &input.input_clippings {
        let mut array_282 = object.key("inputClippings").start_array();
        for item_283 in var_281 {
            {
                let mut object_284 = array_282.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_clipping(
                    &mut object_284,
                    item_283,
                )?;
                object_284.finish();
            }
        }
        array_282.finish();
    }
    if let Some(var_285) = &input.input_scan_type {
        object.key("inputScanType").string(var_285.as_str());
    }
    if let Some(var_286) = &input.position {
        let mut object_287 = object.key("position").start_object();
        crate::json_ser::serialize_structure_crate_model_rectangle(&mut object_287, var_286)?;
        object_287.finish();
    }
    if input.program_number != 0 {
        object.key("programNumber").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.program_number).into()),
        );
    }
    if let Some(var_288) = &input.psi_control {
        object.key("psiControl").string(var_288.as_str());
    }
    if let Some(var_289) = &input.timecode_source {
        object.key("timecodeSource").string(var_289.as_str());
    }
    if let Some(var_290) = &input.timecode_start {
        object.key("timecodeStart").string(var_290);
    }
    if let Some(var_291) = &input.video_selector {
        let mut object_292 = object.key("videoSelector").start_object();
        crate::json_ser::serialize_structure_crate_model_video_selector(&mut object_292, var_291)?;
        object_292.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_audio_description(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AudioDescription,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_293) = &input.audio_channel_tagging_settings {
        let mut object_294 = object.key("audioChannelTaggingSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_channel_tagging_settings(
            &mut object_294,
            var_293,
        )?;
        object_294.finish();
    }
    if let Some(var_295) = &input.audio_normalization_settings {
        let mut object_296 = object.key("audioNormalizationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_normalization_settings(
            &mut object_296,
            var_295,
        )?;
        object_296.finish();
    }
    if let Some(var_297) = &input.audio_source_name {
        object.key("audioSourceName").string(var_297);
    }
    if input.audio_type != 0 {
        object.key("audioType").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.audio_type).into()),
        );
    }
    if let Some(var_298) = &input.audio_type_control {
        object.key("audioTypeControl").string(var_298.as_str());
    }
    if let Some(var_299) = &input.codec_settings {
        let mut object_300 = object.key("codecSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_codec_settings(
            &mut object_300,
            var_299,
        )?;
        object_300.finish();
    }
    if let Some(var_301) = &input.custom_language_code {
        object.key("customLanguageCode").string(var_301);
    }
    if let Some(var_302) = &input.language_code {
        object.key("languageCode").string(var_302.as_str());
    }
    if let Some(var_303) = &input.language_code_control {
        object.key("languageCodeControl").string(var_303.as_str());
    }
    if let Some(var_304) = &input.remix_settings {
        let mut object_305 = object.key("remixSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_remix_settings(&mut object_305, var_304)?;
        object_305.finish();
    }
    if let Some(var_306) = &input.stream_name {
        object.key("streamName").string(var_306);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_caption_description_preset(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CaptionDescriptionPreset,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_307) = &input.custom_language_code {
        object.key("customLanguageCode").string(var_307);
    }
    if let Some(var_308) = &input.destination_settings {
        let mut object_309 = object.key("destinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_caption_destination_settings(
            &mut object_309,
            var_308,
        )?;
        object_309.finish();
    }
    if let Some(var_310) = &input.language_code {
        object.key("languageCode").string(var_310.as_str());
    }
    if let Some(var_311) = &input.language_description {
        object.key("languageDescription").string(var_311);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_container_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ContainerSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_312) = &input.cmfc_settings {
        let mut object_313 = object.key("cmfcSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_cmfc_settings(&mut object_313, var_312)?;
        object_313.finish();
    }
    if let Some(var_314) = &input.container {
        object.key("container").string(var_314.as_str());
    }
    if let Some(var_315) = &input.f4v_settings {
        let mut object_316 = object.key("f4vSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_f4v_settings(&mut object_316, var_315)?;
        object_316.finish();
    }
    if let Some(var_317) = &input.m2ts_settings {
        let mut object_318 = object.key("m2tsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_m2ts_settings(&mut object_318, var_317)?;
        object_318.finish();
    }
    if let Some(var_319) = &input.m3u8_settings {
        let mut object_320 = object.key("m3u8Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_m3u8_settings(&mut object_320, var_319)?;
        object_320.finish();
    }
    if let Some(var_321) = &input.mov_settings {
        let mut object_322 = object.key("movSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_mov_settings(&mut object_322, var_321)?;
        object_322.finish();
    }
    if let Some(var_323) = &input.mp4_settings {
        let mut object_324 = object.key("mp4Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_mp4_settings(&mut object_324, var_323)?;
        object_324.finish();
    }
    if let Some(var_325) = &input.mpd_settings {
        let mut object_326 = object.key("mpdSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_mpd_settings(&mut object_326, var_325)?;
        object_326.finish();
    }
    if let Some(var_327) = &input.mxf_settings {
        let mut object_328 = object.key("mxfSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_mxf_settings(&mut object_328, var_327)?;
        object_328.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_video_description(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VideoDescription,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_329) = &input.afd_signaling {
        object.key("afdSignaling").string(var_329.as_str());
    }
    if let Some(var_330) = &input.anti_alias {
        object.key("antiAlias").string(var_330.as_str());
    }
    if let Some(var_331) = &input.codec_settings {
        let mut object_332 = object.key("codecSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_video_codec_settings(
            &mut object_332,
            var_331,
        )?;
        object_332.finish();
    }
    if let Some(var_333) = &input.color_metadata {
        object.key("colorMetadata").string(var_333.as_str());
    }
    if let Some(var_334) = &input.crop {
        let mut object_335 = object.key("crop").start_object();
        crate::json_ser::serialize_structure_crate_model_rectangle(&mut object_335, var_334)?;
        object_335.finish();
    }
    if let Some(var_336) = &input.drop_frame_timecode {
        object.key("dropFrameTimecode").string(var_336.as_str());
    }
    if input.fixed_afd != 0 {
        object.key("fixedAfd").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.fixed_afd).into()),
        );
    }
    if input.height != 0 {
        object.key("height").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.height).into()),
        );
    }
    if let Some(var_337) = &input.position {
        let mut object_338 = object.key("position").start_object();
        crate::json_ser::serialize_structure_crate_model_rectangle(&mut object_338, var_337)?;
        object_338.finish();
    }
    if let Some(var_339) = &input.respond_to_afd {
        object.key("respondToAfd").string(var_339.as_str());
    }
    if let Some(var_340) = &input.scaling_behavior {
        object.key("scalingBehavior").string(var_340.as_str());
    }
    if input.sharpness != 0 {
        object.key("sharpness").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.sharpness).into()),
        );
    }
    if let Some(var_341) = &input.timecode_insertion {
        object.key("timecodeInsertion").string(var_341.as_str());
    }
    if let Some(var_342) = &input.video_preprocessors {
        let mut object_343 = object.key("videoPreprocessors").start_object();
        crate::json_ser::serialize_structure_crate_model_video_preprocessor(
            &mut object_343,
            var_342,
        )?;
        object_343.finish();
    }
    if input.width != 0 {
        object.key("width").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.width).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_esam_manifest_confirm_condition_notification(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::EsamManifestConfirmConditionNotification,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_344) = &input.mcc_xml {
        object.key("mccXml").string(var_344);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_esam_signal_processing_notification(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::EsamSignalProcessingNotification,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_345) = &input.scc_xml {
        object.key("sccXml").string(var_345);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_audio_selector_group(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AudioSelectorGroup,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_346) = &input.audio_selector_names {
        let mut array_347 = object.key("audioSelectorNames").start_array();
        for item_348 in var_346 {
            {
                array_347.value().string(item_348);
            }
        }
        array_347.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_audio_selector(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AudioSelector,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_349) = &input.custom_language_code {
        object.key("customLanguageCode").string(var_349);
    }
    if let Some(var_350) = &input.default_selection {
        object.key("defaultSelection").string(var_350.as_str());
    }
    if let Some(var_351) = &input.external_audio_file_input {
        object.key("externalAudioFileInput").string(var_351);
    }
    if let Some(var_352) = &input.hls_rendition_group_settings {
        let mut object_353 = object.key("hlsRenditionGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_rendition_group_settings(
            &mut object_353,
            var_352,
        )?;
        object_353.finish();
    }
    if let Some(var_354) = &input.language_code {
        object.key("languageCode").string(var_354.as_str());
    }
    if input.offset != 0 {
        object.key("offset").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.offset).into()),
        );
    }
    if let Some(var_355) = &input.pids {
        let mut array_356 = object.key("pids").start_array();
        for item_357 in var_355 {
            {
                array_356.value().number(
                    #[allow(clippy::useless_conversion)]
                    aws_smithy_types::Number::NegInt((*item_357).into()),
                );
            }
        }
        array_356.finish();
    }
    if input.program_selection != 0 {
        object.key("programSelection").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.program_selection).into()),
        );
    }
    if let Some(var_358) = &input.remix_settings {
        let mut object_359 = object.key("remixSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_remix_settings(&mut object_359, var_358)?;
        object_359.finish();
    }
    if let Some(var_360) = &input.selector_type {
        object.key("selectorType").string(var_360.as_str());
    }
    if let Some(var_361) = &input.tracks {
        let mut array_362 = object.key("tracks").start_array();
        for item_363 in var_361 {
            {
                array_362.value().number(
                    #[allow(clippy::useless_conversion)]
                    aws_smithy_types::Number::NegInt((*item_363).into()),
                );
            }
        }
        array_362.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_caption_selector(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CaptionSelector,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_364) = &input.custom_language_code {
        object.key("customLanguageCode").string(var_364);
    }
    if let Some(var_365) = &input.language_code {
        object.key("languageCode").string(var_365.as_str());
    }
    if let Some(var_366) = &input.source_settings {
        let mut object_367 = object.key("sourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_caption_source_settings(
            &mut object_367,
            var_366,
        )?;
        object_367.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_rectangle(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Rectangle,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.height != 0 {
        object.key("height").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.height).into()),
        );
    }
    if input.width != 0 {
        object.key("width").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.width).into()),
        );
    }
    if input.x != 0 {
        object.key("x").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.x).into()),
        );
    }
    if input.y != 0 {
        object.key("y").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.y).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_input_decryption_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::InputDecryptionSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_368) = &input.decryption_mode {
        object.key("decryptionMode").string(var_368.as_str());
    }
    if let Some(var_369) = &input.encrypted_decryption_key {
        object.key("encryptedDecryptionKey").string(var_369);
    }
    if let Some(var_370) = &input.initialization_vector {
        object.key("initializationVector").string(var_370);
    }
    if let Some(var_371) = &input.kms_key_region {
        object.key("kmsKeyRegion").string(var_371);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_image_inserter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ImageInserter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_372) = &input.insertable_images {
        let mut array_373 = object.key("insertableImages").start_array();
        for item_374 in var_372 {
            {
                let mut object_375 = array_373.value().start_object();
                crate::json_ser::serialize_structure_crate_model_insertable_image(
                    &mut object_375,
                    item_374,
                )?;
                object_375.finish();
            }
        }
        array_373.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_input_clipping(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::InputClipping,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_376) = &input.end_timecode {
        object.key("endTimecode").string(var_376);
    }
    if let Some(var_377) = &input.start_timecode {
        object.key("startTimecode").string(var_377);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_video_selector(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VideoSelector,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_378) = &input.alpha_behavior {
        object.key("alphaBehavior").string(var_378.as_str());
    }
    if let Some(var_379) = &input.color_space {
        object.key("colorSpace").string(var_379.as_str());
    }
    if let Some(var_380) = &input.color_space_usage {
        object.key("colorSpaceUsage").string(var_380.as_str());
    }
    if let Some(var_381) = &input.hdr10_metadata {
        let mut object_382 = object.key("hdr10Metadata").start_object();
        crate::json_ser::serialize_structure_crate_model_hdr10_metadata(&mut object_382, var_381)?;
        object_382.finish();
    }
    if input.pid != 0 {
        object.key("pid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.pid).into()),
        );
    }
    if input.program_number != 0 {
        object.key("programNumber").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.program_number).into()),
        );
    }
    if let Some(var_383) = &input.rotate {
        object.key("rotate").string(var_383.as_str());
    }
    if let Some(var_384) = &input.sample_range {
        object.key("sampleRange").string(var_384.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_motion_image_insertion_framerate(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MotionImageInsertionFramerate,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.framerate_denominator != 0 {
        object.key("framerateDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_denominator).into()),
        );
    }
    if input.framerate_numerator != 0 {
        object.key("framerateNumerator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_numerator).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_motion_image_insertion_offset(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MotionImageInsertionOffset,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.image_x != 0 {
        object.key("imageX").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.image_x).into()),
        );
    }
    if input.image_y != 0 {
        object.key("imageY").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.image_y).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_automated_encoding_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AutomatedEncodingSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_385) = &input.abr_settings {
        let mut object_386 = object.key("abrSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_automated_abr_settings(
            &mut object_386,
            var_385,
        )?;
        object_386.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_output_group_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::OutputGroupSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_387) = &input.cmaf_group_settings {
        let mut object_388 = object.key("cmafGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_cmaf_group_settings(
            &mut object_388,
            var_387,
        )?;
        object_388.finish();
    }
    if let Some(var_389) = &input.dash_iso_group_settings {
        let mut object_390 = object.key("dashIsoGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_dash_iso_group_settings(
            &mut object_390,
            var_389,
        )?;
        object_390.finish();
    }
    if let Some(var_391) = &input.file_group_settings {
        let mut object_392 = object.key("fileGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_file_group_settings(
            &mut object_392,
            var_391,
        )?;
        object_392.finish();
    }
    if let Some(var_393) = &input.hls_group_settings {
        let mut object_394 = object.key("hlsGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_group_settings(
            &mut object_394,
            var_393,
        )?;
        object_394.finish();
    }
    if let Some(var_395) = &input.ms_smooth_group_settings {
        let mut object_396 = object.key("msSmoothGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_ms_smooth_group_settings(
            &mut object_396,
            var_395,
        )?;
        object_396.finish();
    }
    if let Some(var_397) = &input.r#type {
        object.key("type").string(var_397.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_output(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Output,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_398) = &input.audio_descriptions {
        let mut array_399 = object.key("audioDescriptions").start_array();
        for item_400 in var_398 {
            {
                let mut object_401 = array_399.value().start_object();
                crate::json_ser::serialize_structure_crate_model_audio_description(
                    &mut object_401,
                    item_400,
                )?;
                object_401.finish();
            }
        }
        array_399.finish();
    }
    if let Some(var_402) = &input.caption_descriptions {
        let mut array_403 = object.key("captionDescriptions").start_array();
        for item_404 in var_402 {
            {
                let mut object_405 = array_403.value().start_object();
                crate::json_ser::serialize_structure_crate_model_caption_description(
                    &mut object_405,
                    item_404,
                )?;
                object_405.finish();
            }
        }
        array_403.finish();
    }
    if let Some(var_406) = &input.container_settings {
        let mut object_407 = object.key("containerSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_container_settings(
            &mut object_407,
            var_406,
        )?;
        object_407.finish();
    }
    if let Some(var_408) = &input.extension {
        object.key("extension").string(var_408);
    }
    if let Some(var_409) = &input.name_modifier {
        object.key("nameModifier").string(var_409);
    }
    if let Some(var_410) = &input.output_settings {
        let mut object_411 = object.key("outputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_output_settings(&mut object_411, var_410)?;
        object_411.finish();
    }
    if let Some(var_412) = &input.preset {
        object.key("preset").string(var_412);
    }
    if let Some(var_413) = &input.video_description {
        let mut object_414 = object.key("videoDescription").start_object();
        crate::json_ser::serialize_structure_crate_model_video_description(
            &mut object_414,
            var_413,
        )?;
        object_414.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_id3_insertion(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Id3Insertion,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_415) = &input.id3 {
        object.key("id3").string(var_415);
    }
    if let Some(var_416) = &input.timecode {
        object.key("timecode").string(var_416);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_audio_channel_tagging_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AudioChannelTaggingSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_417) = &input.channel_tag {
        object.key("channelTag").string(var_417.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_audio_normalization_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AudioNormalizationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_418) = &input.algorithm {
        object.key("algorithm").string(var_418.as_str());
    }
    if let Some(var_419) = &input.algorithm_control {
        object.key("algorithmControl").string(var_419.as_str());
    }
    if input.correction_gate_level != 0 {
        object.key("correctionGateLevel").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.correction_gate_level).into()),
        );
    }
    if let Some(var_420) = &input.loudness_logging {
        object.key("loudnessLogging").string(var_420.as_str());
    }
    if let Some(var_421) = &input.peak_calculation {
        object.key("peakCalculation").string(var_421.as_str());
    }
    if input.target_lkfs != 0.0 {
        object.key("targetLkfs").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.target_lkfs).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_audio_codec_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AudioCodecSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_422) = &input.aac_settings {
        let mut object_423 = object.key("aacSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_aac_settings(&mut object_423, var_422)?;
        object_423.finish();
    }
    if let Some(var_424) = &input.ac3_settings {
        let mut object_425 = object.key("ac3Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_ac3_settings(&mut object_425, var_424)?;
        object_425.finish();
    }
    if let Some(var_426) = &input.aiff_settings {
        let mut object_427 = object.key("aiffSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_aiff_settings(&mut object_427, var_426)?;
        object_427.finish();
    }
    if let Some(var_428) = &input.codec {
        object.key("codec").string(var_428.as_str());
    }
    if let Some(var_429) = &input.eac3_atmos_settings {
        let mut object_430 = object.key("eac3AtmosSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_eac3_atmos_settings(
            &mut object_430,
            var_429,
        )?;
        object_430.finish();
    }
    if let Some(var_431) = &input.eac3_settings {
        let mut object_432 = object.key("eac3Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_eac3_settings(&mut object_432, var_431)?;
        object_432.finish();
    }
    if let Some(var_433) = &input.mp2_settings {
        let mut object_434 = object.key("mp2Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_mp2_settings(&mut object_434, var_433)?;
        object_434.finish();
    }
    if let Some(var_435) = &input.mp3_settings {
        let mut object_436 = object.key("mp3Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_mp3_settings(&mut object_436, var_435)?;
        object_436.finish();
    }
    if let Some(var_437) = &input.opus_settings {
        let mut object_438 = object.key("opusSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_opus_settings(&mut object_438, var_437)?;
        object_438.finish();
    }
    if let Some(var_439) = &input.vorbis_settings {
        let mut object_440 = object.key("vorbisSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_vorbis_settings(&mut object_440, var_439)?;
        object_440.finish();
    }
    if let Some(var_441) = &input.wav_settings {
        let mut object_442 = object.key("wavSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_wav_settings(&mut object_442, var_441)?;
        object_442.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_remix_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::RemixSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_443) = &input.channel_mapping {
        let mut object_444 = object.key("channelMapping").start_object();
        crate::json_ser::serialize_structure_crate_model_channel_mapping(&mut object_444, var_443)?;
        object_444.finish();
    }
    if input.channels_in != 0 {
        object.key("channelsIn").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.channels_in).into()),
        );
    }
    if input.channels_out != 0 {
        object.key("channelsOut").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.channels_out).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_caption_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CaptionDestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_445) = &input.burnin_destination_settings {
        let mut object_446 = object.key("burninDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_burnin_destination_settings(
            &mut object_446,
            var_445,
        )?;
        object_446.finish();
    }
    if let Some(var_447) = &input.destination_type {
        object.key("destinationType").string(var_447.as_str());
    }
    if let Some(var_448) = &input.dvb_sub_destination_settings {
        let mut object_449 = object.key("dvbSubDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_dvb_sub_destination_settings(
            &mut object_449,
            var_448,
        )?;
        object_449.finish();
    }
    if let Some(var_450) = &input.embedded_destination_settings {
        let mut object_451 = object.key("embeddedDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_embedded_destination_settings(
            &mut object_451,
            var_450,
        )?;
        object_451.finish();
    }
    if let Some(var_452) = &input.imsc_destination_settings {
        let mut object_453 = object.key("imscDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_imsc_destination_settings(
            &mut object_453,
            var_452,
        )?;
        object_453.finish();
    }
    if let Some(var_454) = &input.scc_destination_settings {
        let mut object_455 = object.key("sccDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_scc_destination_settings(
            &mut object_455,
            var_454,
        )?;
        object_455.finish();
    }
    if let Some(var_456) = &input.srt_destination_settings {
        let mut object_457 = object.key("srtDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_srt_destination_settings(
            &mut object_457,
            var_456,
        )?;
        object_457.finish();
    }
    if let Some(var_458) = &input.teletext_destination_settings {
        let mut object_459 = object.key("teletextDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_teletext_destination_settings(
            &mut object_459,
            var_458,
        )?;
        object_459.finish();
    }
    if let Some(var_460) = &input.ttml_destination_settings {
        let mut object_461 = object.key("ttmlDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_ttml_destination_settings(
            &mut object_461,
            var_460,
        )?;
        object_461.finish();
    }
    if let Some(var_462) = &input.webvtt_destination_settings {
        let mut object_463 = object.key("webvttDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_webvtt_destination_settings(
            &mut object_463,
            var_462,
        )?;
        object_463.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_cmfc_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CmfcSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_464) = &input.audio_duration {
        object.key("audioDuration").string(var_464.as_str());
    }
    if let Some(var_465) = &input.audio_group_id {
        object.key("audioGroupId").string(var_465);
    }
    if let Some(var_466) = &input.audio_rendition_sets {
        object.key("audioRenditionSets").string(var_466);
    }
    if let Some(var_467) = &input.audio_track_type {
        object.key("audioTrackType").string(var_467.as_str());
    }
    if let Some(var_468) = &input.descriptive_video_service_flag {
        object
            .key("descriptiveVideoServiceFlag")
            .string(var_468.as_str());
    }
    if let Some(var_469) = &input.i_frame_only_manifest {
        object.key("iFrameOnlyManifest").string(var_469.as_str());
    }
    if let Some(var_470) = &input.scte35_esam {
        object.key("scte35Esam").string(var_470.as_str());
    }
    if let Some(var_471) = &input.scte35_source {
        object.key("scte35Source").string(var_471.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_f4v_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::F4vSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_472) = &input.moov_placement {
        object.key("moovPlacement").string(var_472.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_m2ts_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::M2tsSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_473) = &input.audio_buffer_model {
        object.key("audioBufferModel").string(var_473.as_str());
    }
    if let Some(var_474) = &input.audio_duration {
        object.key("audioDuration").string(var_474.as_str());
    }
    if input.audio_frames_per_pes != 0 {
        object.key("audioFramesPerPes").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.audio_frames_per_pes).into()),
        );
    }
    if let Some(var_475) = &input.audio_pids {
        let mut array_476 = object.key("audioPids").start_array();
        for item_477 in var_475 {
            {
                array_476.value().number(
                    #[allow(clippy::useless_conversion)]
                    aws_smithy_types::Number::NegInt((*item_477).into()),
                );
            }
        }
        array_476.finish();
    }
    if input.bitrate != 0 {
        object.key("bitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.bitrate).into()),
        );
    }
    if let Some(var_478) = &input.buffer_model {
        object.key("bufferModel").string(var_478.as_str());
    }
    if let Some(var_479) = &input.data_pts_control {
        object.key("dataPTSControl").string(var_479.as_str());
    }
    if let Some(var_480) = &input.dvb_nit_settings {
        let mut object_481 = object.key("dvbNitSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_dvb_nit_settings(
            &mut object_481,
            var_480,
        )?;
        object_481.finish();
    }
    if let Some(var_482) = &input.dvb_sdt_settings {
        let mut object_483 = object.key("dvbSdtSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_dvb_sdt_settings(
            &mut object_483,
            var_482,
        )?;
        object_483.finish();
    }
    if let Some(var_484) = &input.dvb_sub_pids {
        let mut array_485 = object.key("dvbSubPids").start_array();
        for item_486 in var_484 {
            {
                array_485.value().number(
                    #[allow(clippy::useless_conversion)]
                    aws_smithy_types::Number::NegInt((*item_486).into()),
                );
            }
        }
        array_485.finish();
    }
    if let Some(var_487) = &input.dvb_tdt_settings {
        let mut object_488 = object.key("dvbTdtSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_dvb_tdt_settings(
            &mut object_488,
            var_487,
        )?;
        object_488.finish();
    }
    if input.dvb_teletext_pid != 0 {
        object.key("dvbTeletextPid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.dvb_teletext_pid).into()),
        );
    }
    if let Some(var_489) = &input.ebp_audio_interval {
        object.key("ebpAudioInterval").string(var_489.as_str());
    }
    if let Some(var_490) = &input.ebp_placement {
        object.key("ebpPlacement").string(var_490.as_str());
    }
    if let Some(var_491) = &input.es_rate_in_pes {
        object.key("esRateInPes").string(var_491.as_str());
    }
    if let Some(var_492) = &input.force_ts_video_ebp_order {
        object.key("forceTsVideoEbpOrder").string(var_492.as_str());
    }
    if input.fragment_time != 0.0 {
        object.key("fragmentTime").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.fragment_time).into()),
        );
    }
    if input.max_pcr_interval != 0 {
        object.key("maxPcrInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_pcr_interval).into()),
        );
    }
    if input.min_ebp_interval != 0 {
        object.key("minEbpInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.min_ebp_interval).into()),
        );
    }
    if let Some(var_493) = &input.nielsen_id3 {
        object.key("nielsenId3").string(var_493.as_str());
    }
    if input.null_packet_bitrate != 0.0 {
        object.key("nullPacketBitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.null_packet_bitrate).into()),
        );
    }
    if input.pat_interval != 0 {
        object.key("patInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.pat_interval).into()),
        );
    }
    if let Some(var_494) = &input.pcr_control {
        object.key("pcrControl").string(var_494.as_str());
    }
    if input.pcr_pid != 0 {
        object.key("pcrPid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.pcr_pid).into()),
        );
    }
    if input.pmt_interval != 0 {
        object.key("pmtInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.pmt_interval).into()),
        );
    }
    if input.pmt_pid != 0 {
        object.key("pmtPid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.pmt_pid).into()),
        );
    }
    if input.private_metadata_pid != 0 {
        object.key("privateMetadataPid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.private_metadata_pid).into()),
        );
    }
    if input.program_number != 0 {
        object.key("programNumber").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.program_number).into()),
        );
    }
    if let Some(var_495) = &input.rate_mode {
        object.key("rateMode").string(var_495.as_str());
    }
    if let Some(var_496) = &input.scte35_esam {
        let mut object_497 = object.key("scte35Esam").start_object();
        crate::json_ser::serialize_structure_crate_model_m2ts_scte35_esam(
            &mut object_497,
            var_496,
        )?;
        object_497.finish();
    }
    if input.scte35_pid != 0 {
        object.key("scte35Pid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.scte35_pid).into()),
        );
    }
    if let Some(var_498) = &input.scte35_source {
        object.key("scte35Source").string(var_498.as_str());
    }
    if let Some(var_499) = &input.segmentation_markers {
        object.key("segmentationMarkers").string(var_499.as_str());
    }
    if let Some(var_500) = &input.segmentation_style {
        object.key("segmentationStyle").string(var_500.as_str());
    }
    if input.segmentation_time != 0.0 {
        object.key("segmentationTime").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.segmentation_time).into()),
        );
    }
    if input.timed_metadata_pid != 0 {
        object.key("timedMetadataPid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.timed_metadata_pid).into()),
        );
    }
    if input.transport_stream_id != 0 {
        object.key("transportStreamId").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.transport_stream_id).into()),
        );
    }
    if input.video_pid != 0 {
        object.key("videoPid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.video_pid).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_m3u8_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::M3u8Settings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_501) = &input.audio_duration {
        object.key("audioDuration").string(var_501.as_str());
    }
    if input.audio_frames_per_pes != 0 {
        object.key("audioFramesPerPes").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.audio_frames_per_pes).into()),
        );
    }
    if let Some(var_502) = &input.audio_pids {
        let mut array_503 = object.key("audioPids").start_array();
        for item_504 in var_502 {
            {
                array_503.value().number(
                    #[allow(clippy::useless_conversion)]
                    aws_smithy_types::Number::NegInt((*item_504).into()),
                );
            }
        }
        array_503.finish();
    }
    if let Some(var_505) = &input.data_pts_control {
        object.key("dataPTSControl").string(var_505.as_str());
    }
    if input.max_pcr_interval != 0 {
        object.key("maxPcrInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_pcr_interval).into()),
        );
    }
    if let Some(var_506) = &input.nielsen_id3 {
        object.key("nielsenId3").string(var_506.as_str());
    }
    if input.pat_interval != 0 {
        object.key("patInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.pat_interval).into()),
        );
    }
    if let Some(var_507) = &input.pcr_control {
        object.key("pcrControl").string(var_507.as_str());
    }
    if input.pcr_pid != 0 {
        object.key("pcrPid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.pcr_pid).into()),
        );
    }
    if input.pmt_interval != 0 {
        object.key("pmtInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.pmt_interval).into()),
        );
    }
    if input.pmt_pid != 0 {
        object.key("pmtPid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.pmt_pid).into()),
        );
    }
    if input.private_metadata_pid != 0 {
        object.key("privateMetadataPid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.private_metadata_pid).into()),
        );
    }
    if input.program_number != 0 {
        object.key("programNumber").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.program_number).into()),
        );
    }
    if input.scte35_pid != 0 {
        object.key("scte35Pid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.scte35_pid).into()),
        );
    }
    if let Some(var_508) = &input.scte35_source {
        object.key("scte35Source").string(var_508.as_str());
    }
    if let Some(var_509) = &input.timed_metadata {
        object.key("timedMetadata").string(var_509.as_str());
    }
    if input.timed_metadata_pid != 0 {
        object.key("timedMetadataPid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.timed_metadata_pid).into()),
        );
    }
    if input.transport_stream_id != 0 {
        object.key("transportStreamId").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.transport_stream_id).into()),
        );
    }
    if input.video_pid != 0 {
        object.key("videoPid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.video_pid).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_mov_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MovSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_510) = &input.clap_atom {
        object.key("clapAtom").string(var_510.as_str());
    }
    if let Some(var_511) = &input.cslg_atom {
        object.key("cslgAtom").string(var_511.as_str());
    }
    if let Some(var_512) = &input.mpeg2_four_cc_control {
        object.key("mpeg2FourCCControl").string(var_512.as_str());
    }
    if let Some(var_513) = &input.padding_control {
        object.key("paddingControl").string(var_513.as_str());
    }
    if let Some(var_514) = &input.reference {
        object.key("reference").string(var_514.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_mp4_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Mp4Settings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_515) = &input.audio_duration {
        object.key("audioDuration").string(var_515.as_str());
    }
    if let Some(var_516) = &input.cslg_atom {
        object.key("cslgAtom").string(var_516.as_str());
    }
    if input.ctts_version != 0 {
        object.key("cttsVersion").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.ctts_version).into()),
        );
    }
    if let Some(var_517) = &input.free_space_box {
        object.key("freeSpaceBox").string(var_517.as_str());
    }
    if let Some(var_518) = &input.moov_placement {
        object.key("moovPlacement").string(var_518.as_str());
    }
    if let Some(var_519) = &input.mp4_major_brand {
        object.key("mp4MajorBrand").string(var_519);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_mpd_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MpdSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_520) = &input.accessibility_caption_hints {
        object
            .key("accessibilityCaptionHints")
            .string(var_520.as_str());
    }
    if let Some(var_521) = &input.audio_duration {
        object.key("audioDuration").string(var_521.as_str());
    }
    if let Some(var_522) = &input.caption_container_type {
        object.key("captionContainerType").string(var_522.as_str());
    }
    if let Some(var_523) = &input.scte35_esam {
        object.key("scte35Esam").string(var_523.as_str());
    }
    if let Some(var_524) = &input.scte35_source {
        object.key("scte35Source").string(var_524.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_mxf_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MxfSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_525) = &input.afd_signaling {
        object.key("afdSignaling").string(var_525.as_str());
    }
    if let Some(var_526) = &input.profile {
        object.key("profile").string(var_526.as_str());
    }
    if let Some(var_527) = &input.xavc_profile_settings {
        let mut object_528 = object.key("xavcProfileSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_mxf_xavc_profile_settings(
            &mut object_528,
            var_527,
        )?;
        object_528.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_video_codec_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VideoCodecSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_529) = &input.av1_settings {
        let mut object_530 = object.key("av1Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_av1_settings(&mut object_530, var_529)?;
        object_530.finish();
    }
    if let Some(var_531) = &input.avc_intra_settings {
        let mut object_532 = object.key("avcIntraSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_avc_intra_settings(
            &mut object_532,
            var_531,
        )?;
        object_532.finish();
    }
    if let Some(var_533) = &input.codec {
        object.key("codec").string(var_533.as_str());
    }
    if let Some(var_534) = &input.frame_capture_settings {
        let mut object_535 = object.key("frameCaptureSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_frame_capture_settings(
            &mut object_535,
            var_534,
        )?;
        object_535.finish();
    }
    if let Some(var_536) = &input.h264_settings {
        let mut object_537 = object.key("h264Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_h264_settings(&mut object_537, var_536)?;
        object_537.finish();
    }
    if let Some(var_538) = &input.h265_settings {
        let mut object_539 = object.key("h265Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_h265_settings(&mut object_539, var_538)?;
        object_539.finish();
    }
    if let Some(var_540) = &input.mpeg2_settings {
        let mut object_541 = object.key("mpeg2Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_mpeg2_settings(&mut object_541, var_540)?;
        object_541.finish();
    }
    if let Some(var_542) = &input.prores_settings {
        let mut object_543 = object.key("proresSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_prores_settings(&mut object_543, var_542)?;
        object_543.finish();
    }
    if let Some(var_544) = &input.vc3_settings {
        let mut object_545 = object.key("vc3Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_vc3_settings(&mut object_545, var_544)?;
        object_545.finish();
    }
    if let Some(var_546) = &input.vp8_settings {
        let mut object_547 = object.key("vp8Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_vp8_settings(&mut object_547, var_546)?;
        object_547.finish();
    }
    if let Some(var_548) = &input.vp9_settings {
        let mut object_549 = object.key("vp9Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_vp9_settings(&mut object_549, var_548)?;
        object_549.finish();
    }
    if let Some(var_550) = &input.xavc_settings {
        let mut object_551 = object.key("xavcSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_xavc_settings(&mut object_551, var_550)?;
        object_551.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_video_preprocessor(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VideoPreprocessor,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_552) = &input.color_corrector {
        let mut object_553 = object.key("colorCorrector").start_object();
        crate::json_ser::serialize_structure_crate_model_color_corrector(&mut object_553, var_552)?;
        object_553.finish();
    }
    if let Some(var_554) = &input.deinterlacer {
        let mut object_555 = object.key("deinterlacer").start_object();
        crate::json_ser::serialize_structure_crate_model_deinterlacer(&mut object_555, var_554)?;
        object_555.finish();
    }
    if let Some(var_556) = &input.dolby_vision {
        let mut object_557 = object.key("dolbyVision").start_object();
        crate::json_ser::serialize_structure_crate_model_dolby_vision(&mut object_557, var_556)?;
        object_557.finish();
    }
    if let Some(var_558) = &input.hdr10_plus {
        let mut object_559 = object.key("hdr10Plus").start_object();
        crate::json_ser::serialize_structure_crate_model_hdr10_plus(&mut object_559, var_558)?;
        object_559.finish();
    }
    if let Some(var_560) = &input.image_inserter {
        let mut object_561 = object.key("imageInserter").start_object();
        crate::json_ser::serialize_structure_crate_model_image_inserter(&mut object_561, var_560)?;
        object_561.finish();
    }
    if let Some(var_562) = &input.noise_reducer {
        let mut object_563 = object.key("noiseReducer").start_object();
        crate::json_ser::serialize_structure_crate_model_noise_reducer(&mut object_563, var_562)?;
        object_563.finish();
    }
    if let Some(var_564) = &input.partner_watermarking {
        let mut object_565 = object.key("partnerWatermarking").start_object();
        crate::json_ser::serialize_structure_crate_model_partner_watermarking(
            &mut object_565,
            var_564,
        )?;
        object_565.finish();
    }
    if let Some(var_566) = &input.timecode_burnin {
        let mut object_567 = object.key("timecodeBurnin").start_object();
        crate::json_ser::serialize_structure_crate_model_timecode_burnin(&mut object_567, var_566)?;
        object_567.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_hls_rendition_group_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HlsRenditionGroupSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_568) = &input.rendition_group_id {
        object.key("renditionGroupId").string(var_568);
    }
    if let Some(var_569) = &input.rendition_language_code {
        object.key("renditionLanguageCode").string(var_569.as_str());
    }
    if let Some(var_570) = &input.rendition_name {
        object.key("renditionName").string(var_570);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_caption_source_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CaptionSourceSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_571) = &input.ancillary_source_settings {
        let mut object_572 = object.key("ancillarySourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_ancillary_source_settings(
            &mut object_572,
            var_571,
        )?;
        object_572.finish();
    }
    if let Some(var_573) = &input.dvb_sub_source_settings {
        let mut object_574 = object.key("dvbSubSourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_dvb_sub_source_settings(
            &mut object_574,
            var_573,
        )?;
        object_574.finish();
    }
    if let Some(var_575) = &input.embedded_source_settings {
        let mut object_576 = object.key("embeddedSourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_embedded_source_settings(
            &mut object_576,
            var_575,
        )?;
        object_576.finish();
    }
    if let Some(var_577) = &input.file_source_settings {
        let mut object_578 = object.key("fileSourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_file_source_settings(
            &mut object_578,
            var_577,
        )?;
        object_578.finish();
    }
    if let Some(var_579) = &input.source_type {
        object.key("sourceType").string(var_579.as_str());
    }
    if let Some(var_580) = &input.teletext_source_settings {
        let mut object_581 = object.key("teletextSourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_teletext_source_settings(
            &mut object_581,
            var_580,
        )?;
        object_581.finish();
    }
    if let Some(var_582) = &input.track_source_settings {
        let mut object_583 = object.key("trackSourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_track_source_settings(
            &mut object_583,
            var_582,
        )?;
        object_583.finish();
    }
    if let Some(var_584) = &input.webvtt_hls_source_settings {
        let mut object_585 = object.key("webvttHlsSourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_webvtt_hls_source_settings(
            &mut object_585,
            var_584,
        )?;
        object_585.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_insertable_image(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::InsertableImage,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.duration != 0 {
        object.key("duration").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.duration).into()),
        );
    }
    if input.fade_in != 0 {
        object.key("fadeIn").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.fade_in).into()),
        );
    }
    if input.fade_out != 0 {
        object.key("fadeOut").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.fade_out).into()),
        );
    }
    if input.height != 0 {
        object.key("height").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.height).into()),
        );
    }
    if let Some(var_586) = &input.image_inserter_input {
        object.key("imageInserterInput").string(var_586);
    }
    if input.image_x != 0 {
        object.key("imageX").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.image_x).into()),
        );
    }
    if input.image_y != 0 {
        object.key("imageY").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.image_y).into()),
        );
    }
    if input.layer != 0 {
        object.key("layer").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.layer).into()),
        );
    }
    if input.opacity != 0 {
        object.key("opacity").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.opacity).into()),
        );
    }
    if let Some(var_587) = &input.start_time {
        object.key("startTime").string(var_587);
    }
    if input.width != 0 {
        object.key("width").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.width).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_hdr10_metadata(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Hdr10Metadata,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.blue_primary_x != 0 {
        object.key("bluePrimaryX").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.blue_primary_x).into()),
        );
    }
    if input.blue_primary_y != 0 {
        object.key("bluePrimaryY").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.blue_primary_y).into()),
        );
    }
    if input.green_primary_x != 0 {
        object.key("greenPrimaryX").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.green_primary_x).into()),
        );
    }
    if input.green_primary_y != 0 {
        object.key("greenPrimaryY").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.green_primary_y).into()),
        );
    }
    if input.max_content_light_level != 0 {
        object.key("maxContentLightLevel").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_content_light_level).into()),
        );
    }
    if input.max_frame_average_light_level != 0 {
        object.key("maxFrameAverageLightLevel").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_frame_average_light_level).into()),
        );
    }
    if input.max_luminance != 0 {
        object.key("maxLuminance").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_luminance).into()),
        );
    }
    if input.min_luminance != 0 {
        object.key("minLuminance").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.min_luminance).into()),
        );
    }
    if input.red_primary_x != 0 {
        object.key("redPrimaryX").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.red_primary_x).into()),
        );
    }
    if input.red_primary_y != 0 {
        object.key("redPrimaryY").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.red_primary_y).into()),
        );
    }
    if input.white_point_x != 0 {
        object.key("whitePointX").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.white_point_x).into()),
        );
    }
    if input.white_point_y != 0 {
        object.key("whitePointY").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.white_point_y).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_automated_abr_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AutomatedAbrSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.max_abr_bitrate != 0 {
        object.key("maxAbrBitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_abr_bitrate).into()),
        );
    }
    if input.max_renditions != 0 {
        object.key("maxRenditions").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_renditions).into()),
        );
    }
    if input.min_abr_bitrate != 0 {
        object.key("minAbrBitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.min_abr_bitrate).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_cmaf_group_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CmafGroupSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_588) = &input.additional_manifests {
        let mut array_589 = object.key("additionalManifests").start_array();
        for item_590 in var_588 {
            {
                let mut object_591 = array_589.value().start_object();
                crate::json_ser::serialize_structure_crate_model_cmaf_additional_manifest(
                    &mut object_591,
                    item_590,
                )?;
                object_591.finish();
            }
        }
        array_589.finish();
    }
    if let Some(var_592) = &input.base_url {
        object.key("baseUrl").string(var_592);
    }
    if let Some(var_593) = &input.client_cache {
        object.key("clientCache").string(var_593.as_str());
    }
    if let Some(var_594) = &input.codec_specification {
        object.key("codecSpecification").string(var_594.as_str());
    }
    if let Some(var_595) = &input.destination {
        object.key("destination").string(var_595);
    }
    if let Some(var_596) = &input.destination_settings {
        let mut object_597 = object.key("destinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_destination_settings(
            &mut object_597,
            var_596,
        )?;
        object_597.finish();
    }
    if let Some(var_598) = &input.encryption {
        let mut object_599 = object.key("encryption").start_object();
        crate::json_ser::serialize_structure_crate_model_cmaf_encryption_settings(
            &mut object_599,
            var_598,
        )?;
        object_599.finish();
    }
    if input.fragment_length != 0 {
        object.key("fragmentLength").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.fragment_length).into()),
        );
    }
    if let Some(var_600) = &input.image_based_trick_play {
        object.key("imageBasedTrickPlay").string(var_600.as_str());
    }
    if let Some(var_601) = &input.image_based_trick_play_settings {
        let mut object_602 = object.key("imageBasedTrickPlaySettings").start_object();
        crate::json_ser::serialize_structure_crate_model_cmaf_image_based_trick_play_settings(
            &mut object_602,
            var_601,
        )?;
        object_602.finish();
    }
    if let Some(var_603) = &input.manifest_compression {
        object.key("manifestCompression").string(var_603.as_str());
    }
    if let Some(var_604) = &input.manifest_duration_format {
        object
            .key("manifestDurationFormat")
            .string(var_604.as_str());
    }
    if input.min_buffer_time != 0 {
        object.key("minBufferTime").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.min_buffer_time).into()),
        );
    }
    if input.min_final_segment_length != 0.0 {
        object.key("minFinalSegmentLength").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.min_final_segment_length).into()),
        );
    }
    if let Some(var_605) = &input.mpd_profile {
        object.key("mpdProfile").string(var_605.as_str());
    }
    if let Some(var_606) = &input.pts_offset_handling_for_b_frames {
        object
            .key("ptsOffsetHandlingForBFrames")
            .string(var_606.as_str());
    }
    if let Some(var_607) = &input.segment_control {
        object.key("segmentControl").string(var_607.as_str());
    }
    if input.segment_length != 0 {
        object.key("segmentLength").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.segment_length).into()),
        );
    }
    if let Some(var_608) = &input.segment_length_control {
        object.key("segmentLengthControl").string(var_608.as_str());
    }
    if let Some(var_609) = &input.stream_inf_resolution {
        object.key("streamInfResolution").string(var_609.as_str());
    }
    if let Some(var_610) = &input.target_duration_compatibility_mode {
        object
            .key("targetDurationCompatibilityMode")
            .string(var_610.as_str());
    }
    if let Some(var_611) = &input.write_dash_manifest {
        object.key("writeDashManifest").string(var_611.as_str());
    }
    if let Some(var_612) = &input.write_hls_manifest {
        object.key("writeHlsManifest").string(var_612.as_str());
    }
    if let Some(var_613) = &input.write_segment_timeline_in_representation {
        object
            .key("writeSegmentTimelineInRepresentation")
            .string(var_613.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_dash_iso_group_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DashIsoGroupSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_614) = &input.additional_manifests {
        let mut array_615 = object.key("additionalManifests").start_array();
        for item_616 in var_614 {
            {
                let mut object_617 = array_615.value().start_object();
                crate::json_ser::serialize_structure_crate_model_dash_additional_manifest(
                    &mut object_617,
                    item_616,
                )?;
                object_617.finish();
            }
        }
        array_615.finish();
    }
    if let Some(var_618) = &input.audio_channel_config_scheme_id_uri {
        object
            .key("audioChannelConfigSchemeIdUri")
            .string(var_618.as_str());
    }
    if let Some(var_619) = &input.base_url {
        object.key("baseUrl").string(var_619);
    }
    if let Some(var_620) = &input.destination {
        object.key("destination").string(var_620);
    }
    if let Some(var_621) = &input.destination_settings {
        let mut object_622 = object.key("destinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_destination_settings(
            &mut object_622,
            var_621,
        )?;
        object_622.finish();
    }
    if let Some(var_623) = &input.encryption {
        let mut object_624 = object.key("encryption").start_object();
        crate::json_ser::serialize_structure_crate_model_dash_iso_encryption_settings(
            &mut object_624,
            var_623,
        )?;
        object_624.finish();
    }
    if input.fragment_length != 0 {
        object.key("fragmentLength").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.fragment_length).into()),
        );
    }
    if let Some(var_625) = &input.hbbtv_compliance {
        object.key("hbbtvCompliance").string(var_625.as_str());
    }
    if let Some(var_626) = &input.image_based_trick_play {
        object.key("imageBasedTrickPlay").string(var_626.as_str());
    }
    if let Some(var_627) = &input.image_based_trick_play_settings {
        let mut object_628 = object.key("imageBasedTrickPlaySettings").start_object();
        crate::json_ser::serialize_structure_crate_model_dash_iso_image_based_trick_play_settings(
            &mut object_628,
            var_627,
        )?;
        object_628.finish();
    }
    if input.min_buffer_time != 0 {
        object.key("minBufferTime").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.min_buffer_time).into()),
        );
    }
    if input.min_final_segment_length != 0.0 {
        object.key("minFinalSegmentLength").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.min_final_segment_length).into()),
        );
    }
    if let Some(var_629) = &input.mpd_profile {
        object.key("mpdProfile").string(var_629.as_str());
    }
    if let Some(var_630) = &input.pts_offset_handling_for_b_frames {
        object
            .key("ptsOffsetHandlingForBFrames")
            .string(var_630.as_str());
    }
    if let Some(var_631) = &input.segment_control {
        object.key("segmentControl").string(var_631.as_str());
    }
    if input.segment_length != 0 {
        object.key("segmentLength").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.segment_length).into()),
        );
    }
    if let Some(var_632) = &input.segment_length_control {
        object.key("segmentLengthControl").string(var_632.as_str());
    }
    if let Some(var_633) = &input.write_segment_timeline_in_representation {
        object
            .key("writeSegmentTimelineInRepresentation")
            .string(var_633.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_file_group_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FileGroupSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_634) = &input.destination {
        object.key("destination").string(var_634);
    }
    if let Some(var_635) = &input.destination_settings {
        let mut object_636 = object.key("destinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_destination_settings(
            &mut object_636,
            var_635,
        )?;
        object_636.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_hls_group_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HlsGroupSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_637) = &input.ad_markers {
        let mut array_638 = object.key("adMarkers").start_array();
        for item_639 in var_637 {
            {
                array_638.value().string(item_639.as_str());
            }
        }
        array_638.finish();
    }
    if let Some(var_640) = &input.additional_manifests {
        let mut array_641 = object.key("additionalManifests").start_array();
        for item_642 in var_640 {
            {
                let mut object_643 = array_641.value().start_object();
                crate::json_ser::serialize_structure_crate_model_hls_additional_manifest(
                    &mut object_643,
                    item_642,
                )?;
                object_643.finish();
            }
        }
        array_641.finish();
    }
    if let Some(var_644) = &input.audio_only_header {
        object.key("audioOnlyHeader").string(var_644.as_str());
    }
    if let Some(var_645) = &input.base_url {
        object.key("baseUrl").string(var_645);
    }
    if let Some(var_646) = &input.caption_language_mappings {
        let mut array_647 = object.key("captionLanguageMappings").start_array();
        for item_648 in var_646 {
            {
                let mut object_649 = array_647.value().start_object();
                crate::json_ser::serialize_structure_crate_model_hls_caption_language_mapping(
                    &mut object_649,
                    item_648,
                )?;
                object_649.finish();
            }
        }
        array_647.finish();
    }
    if let Some(var_650) = &input.caption_language_setting {
        object
            .key("captionLanguageSetting")
            .string(var_650.as_str());
    }
    if let Some(var_651) = &input.client_cache {
        object.key("clientCache").string(var_651.as_str());
    }
    if let Some(var_652) = &input.codec_specification {
        object.key("codecSpecification").string(var_652.as_str());
    }
    if let Some(var_653) = &input.destination {
        object.key("destination").string(var_653);
    }
    if let Some(var_654) = &input.destination_settings {
        let mut object_655 = object.key("destinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_destination_settings(
            &mut object_655,
            var_654,
        )?;
        object_655.finish();
    }
    if let Some(var_656) = &input.directory_structure {
        object.key("directoryStructure").string(var_656.as_str());
    }
    if let Some(var_657) = &input.encryption {
        let mut object_658 = object.key("encryption").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_encryption_settings(
            &mut object_658,
            var_657,
        )?;
        object_658.finish();
    }
    if let Some(var_659) = &input.image_based_trick_play {
        object.key("imageBasedTrickPlay").string(var_659.as_str());
    }
    if let Some(var_660) = &input.image_based_trick_play_settings {
        let mut object_661 = object.key("imageBasedTrickPlaySettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_image_based_trick_play_settings(
            &mut object_661,
            var_660,
        )?;
        object_661.finish();
    }
    if let Some(var_662) = &input.manifest_compression {
        object.key("manifestCompression").string(var_662.as_str());
    }
    if let Some(var_663) = &input.manifest_duration_format {
        object
            .key("manifestDurationFormat")
            .string(var_663.as_str());
    }
    if input.min_final_segment_length != 0.0 {
        object.key("minFinalSegmentLength").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.min_final_segment_length).into()),
        );
    }
    if input.min_segment_length != 0 {
        object.key("minSegmentLength").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.min_segment_length).into()),
        );
    }
    if let Some(var_664) = &input.output_selection {
        object.key("outputSelection").string(var_664.as_str());
    }
    if let Some(var_665) = &input.program_date_time {
        object.key("programDateTime").string(var_665.as_str());
    }
    if input.program_date_time_period != 0 {
        object.key("programDateTimePeriod").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.program_date_time_period).into()),
        );
    }
    if let Some(var_666) = &input.segment_control {
        object.key("segmentControl").string(var_666.as_str());
    }
    if input.segment_length != 0 {
        object.key("segmentLength").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.segment_length).into()),
        );
    }
    if let Some(var_667) = &input.segment_length_control {
        object.key("segmentLengthControl").string(var_667.as_str());
    }
    if input.segments_per_subdirectory != 0 {
        object.key("segmentsPerSubdirectory").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.segments_per_subdirectory).into()),
        );
    }
    if let Some(var_668) = &input.stream_inf_resolution {
        object.key("streamInfResolution").string(var_668.as_str());
    }
    if let Some(var_669) = &input.target_duration_compatibility_mode {
        object
            .key("targetDurationCompatibilityMode")
            .string(var_669.as_str());
    }
    if let Some(var_670) = &input.timed_metadata_id3_frame {
        object.key("timedMetadataId3Frame").string(var_670.as_str());
    }
    if input.timed_metadata_id3_period != 0 {
        object.key("timedMetadataId3Period").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.timed_metadata_id3_period).into()),
        );
    }
    if input.timestamp_delta_milliseconds != 0 {
        object.key("timestampDeltaMilliseconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.timestamp_delta_milliseconds).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_ms_smooth_group_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MsSmoothGroupSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_671) = &input.additional_manifests {
        let mut array_672 = object.key("additionalManifests").start_array();
        for item_673 in var_671 {
            {
                let mut object_674 = array_672.value().start_object();
                crate::json_ser::serialize_structure_crate_model_ms_smooth_additional_manifest(
                    &mut object_674,
                    item_673,
                )?;
                object_674.finish();
            }
        }
        array_672.finish();
    }
    if let Some(var_675) = &input.audio_deduplication {
        object.key("audioDeduplication").string(var_675.as_str());
    }
    if let Some(var_676) = &input.destination {
        object.key("destination").string(var_676);
    }
    if let Some(var_677) = &input.destination_settings {
        let mut object_678 = object.key("destinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_destination_settings(
            &mut object_678,
            var_677,
        )?;
        object_678.finish();
    }
    if let Some(var_679) = &input.encryption {
        let mut object_680 = object.key("encryption").start_object();
        crate::json_ser::serialize_structure_crate_model_ms_smooth_encryption_settings(
            &mut object_680,
            var_679,
        )?;
        object_680.finish();
    }
    if input.fragment_length != 0 {
        object.key("fragmentLength").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.fragment_length).into()),
        );
    }
    if let Some(var_681) = &input.fragment_length_control {
        object.key("fragmentLengthControl").string(var_681.as_str());
    }
    if let Some(var_682) = &input.manifest_encoding {
        object.key("manifestEncoding").string(var_682.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_caption_description(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CaptionDescription,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_683) = &input.caption_selector_name {
        object.key("captionSelectorName").string(var_683);
    }
    if let Some(var_684) = &input.custom_language_code {
        object.key("customLanguageCode").string(var_684);
    }
    if let Some(var_685) = &input.destination_settings {
        let mut object_686 = object.key("destinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_caption_destination_settings(
            &mut object_686,
            var_685,
        )?;
        object_686.finish();
    }
    if let Some(var_687) = &input.language_code {
        object.key("languageCode").string(var_687.as_str());
    }
    if let Some(var_688) = &input.language_description {
        object.key("languageDescription").string(var_688);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_output_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::OutputSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_689) = &input.hls_settings {
        let mut object_690 = object.key("hlsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_settings(&mut object_690, var_689)?;
        object_690.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_aac_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AacSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_691) = &input.audio_description_broadcaster_mix {
        object
            .key("audioDescriptionBroadcasterMix")
            .string(var_691.as_str());
    }
    if input.bitrate != 0 {
        object.key("bitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.bitrate).into()),
        );
    }
    if let Some(var_692) = &input.codec_profile {
        object.key("codecProfile").string(var_692.as_str());
    }
    if let Some(var_693) = &input.coding_mode {
        object.key("codingMode").string(var_693.as_str());
    }
    if let Some(var_694) = &input.rate_control_mode {
        object.key("rateControlMode").string(var_694.as_str());
    }
    if let Some(var_695) = &input.raw_format {
        object.key("rawFormat").string(var_695.as_str());
    }
    if input.sample_rate != 0 {
        object.key("sampleRate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.sample_rate).into()),
        );
    }
    if let Some(var_696) = &input.specification {
        object.key("specification").string(var_696.as_str());
    }
    if let Some(var_697) = &input.vbr_quality {
        object.key("vbrQuality").string(var_697.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_ac3_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Ac3Settings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.bitrate != 0 {
        object.key("bitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.bitrate).into()),
        );
    }
    if let Some(var_698) = &input.bitstream_mode {
        object.key("bitstreamMode").string(var_698.as_str());
    }
    if let Some(var_699) = &input.coding_mode {
        object.key("codingMode").string(var_699.as_str());
    }
    if input.dialnorm != 0 {
        object.key("dialnorm").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.dialnorm).into()),
        );
    }
    if let Some(var_700) = &input.dynamic_range_compression_line {
        object
            .key("dynamicRangeCompressionLine")
            .string(var_700.as_str());
    }
    if let Some(var_701) = &input.dynamic_range_compression_profile {
        object
            .key("dynamicRangeCompressionProfile")
            .string(var_701.as_str());
    }
    if let Some(var_702) = &input.dynamic_range_compression_rf {
        object
            .key("dynamicRangeCompressionRf")
            .string(var_702.as_str());
    }
    if let Some(var_703) = &input.lfe_filter {
        object.key("lfeFilter").string(var_703.as_str());
    }
    if let Some(var_704) = &input.metadata_control {
        object.key("metadataControl").string(var_704.as_str());
    }
    if input.sample_rate != 0 {
        object.key("sampleRate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.sample_rate).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_aiff_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AiffSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.bit_depth != 0 {
        object.key("bitDepth").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.bit_depth).into()),
        );
    }
    if input.channels != 0 {
        object.key("channels").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.channels).into()),
        );
    }
    if input.sample_rate != 0 {
        object.key("sampleRate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.sample_rate).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_eac3_atmos_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Eac3AtmosSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.bitrate != 0 {
        object.key("bitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.bitrate).into()),
        );
    }
    if let Some(var_705) = &input.bitstream_mode {
        object.key("bitstreamMode").string(var_705.as_str());
    }
    if let Some(var_706) = &input.coding_mode {
        object.key("codingMode").string(var_706.as_str());
    }
    if let Some(var_707) = &input.dialogue_intelligence {
        object.key("dialogueIntelligence").string(var_707.as_str());
    }
    if let Some(var_708) = &input.downmix_control {
        object.key("downmixControl").string(var_708.as_str());
    }
    if let Some(var_709) = &input.dynamic_range_compression_line {
        object
            .key("dynamicRangeCompressionLine")
            .string(var_709.as_str());
    }
    if let Some(var_710) = &input.dynamic_range_compression_rf {
        object
            .key("dynamicRangeCompressionRf")
            .string(var_710.as_str());
    }
    if let Some(var_711) = &input.dynamic_range_control {
        object.key("dynamicRangeControl").string(var_711.as_str());
    }
    if input.lo_ro_center_mix_level != 0.0 {
        object.key("loRoCenterMixLevel").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.lo_ro_center_mix_level).into()),
        );
    }
    if input.lo_ro_surround_mix_level != 0.0 {
        object.key("loRoSurroundMixLevel").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.lo_ro_surround_mix_level).into()),
        );
    }
    if input.lt_rt_center_mix_level != 0.0 {
        object.key("ltRtCenterMixLevel").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.lt_rt_center_mix_level).into()),
        );
    }
    if input.lt_rt_surround_mix_level != 0.0 {
        object.key("ltRtSurroundMixLevel").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.lt_rt_surround_mix_level).into()),
        );
    }
    if let Some(var_712) = &input.metering_mode {
        object.key("meteringMode").string(var_712.as_str());
    }
    if input.sample_rate != 0 {
        object.key("sampleRate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.sample_rate).into()),
        );
    }
    if input.speech_threshold != 0 {
        object.key("speechThreshold").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.speech_threshold).into()),
        );
    }
    if let Some(var_713) = &input.stereo_downmix {
        object.key("stereoDownmix").string(var_713.as_str());
    }
    if let Some(var_714) = &input.surround_ex_mode {
        object.key("surroundExMode").string(var_714.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_eac3_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Eac3Settings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_715) = &input.attenuation_control {
        object.key("attenuationControl").string(var_715.as_str());
    }
    if input.bitrate != 0 {
        object.key("bitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.bitrate).into()),
        );
    }
    if let Some(var_716) = &input.bitstream_mode {
        object.key("bitstreamMode").string(var_716.as_str());
    }
    if let Some(var_717) = &input.coding_mode {
        object.key("codingMode").string(var_717.as_str());
    }
    if let Some(var_718) = &input.dc_filter {
        object.key("dcFilter").string(var_718.as_str());
    }
    if input.dialnorm != 0 {
        object.key("dialnorm").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.dialnorm).into()),
        );
    }
    if let Some(var_719) = &input.dynamic_range_compression_line {
        object
            .key("dynamicRangeCompressionLine")
            .string(var_719.as_str());
    }
    if let Some(var_720) = &input.dynamic_range_compression_rf {
        object
            .key("dynamicRangeCompressionRf")
            .string(var_720.as_str());
    }
    if let Some(var_721) = &input.lfe_control {
        object.key("lfeControl").string(var_721.as_str());
    }
    if let Some(var_722) = &input.lfe_filter {
        object.key("lfeFilter").string(var_722.as_str());
    }
    if input.lo_ro_center_mix_level != 0.0 {
        object.key("loRoCenterMixLevel").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.lo_ro_center_mix_level).into()),
        );
    }
    if input.lo_ro_surround_mix_level != 0.0 {
        object.key("loRoSurroundMixLevel").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.lo_ro_surround_mix_level).into()),
        );
    }
    if input.lt_rt_center_mix_level != 0.0 {
        object.key("ltRtCenterMixLevel").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.lt_rt_center_mix_level).into()),
        );
    }
    if input.lt_rt_surround_mix_level != 0.0 {
        object.key("ltRtSurroundMixLevel").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.lt_rt_surround_mix_level).into()),
        );
    }
    if let Some(var_723) = &input.metadata_control {
        object.key("metadataControl").string(var_723.as_str());
    }
    if let Some(var_724) = &input.passthrough_control {
        object.key("passthroughControl").string(var_724.as_str());
    }
    if let Some(var_725) = &input.phase_control {
        object.key("phaseControl").string(var_725.as_str());
    }
    if input.sample_rate != 0 {
        object.key("sampleRate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.sample_rate).into()),
        );
    }
    if let Some(var_726) = &input.stereo_downmix {
        object.key("stereoDownmix").string(var_726.as_str());
    }
    if let Some(var_727) = &input.surround_ex_mode {
        object.key("surroundExMode").string(var_727.as_str());
    }
    if let Some(var_728) = &input.surround_mode {
        object.key("surroundMode").string(var_728.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_mp2_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Mp2Settings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.bitrate != 0 {
        object.key("bitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.bitrate).into()),
        );
    }
    if input.channels != 0 {
        object.key("channels").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.channels).into()),
        );
    }
    if input.sample_rate != 0 {
        object.key("sampleRate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.sample_rate).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_mp3_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Mp3Settings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.bitrate != 0 {
        object.key("bitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.bitrate).into()),
        );
    }
    if input.channels != 0 {
        object.key("channels").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.channels).into()),
        );
    }
    if let Some(var_729) = &input.rate_control_mode {
        object.key("rateControlMode").string(var_729.as_str());
    }
    if input.sample_rate != 0 {
        object.key("sampleRate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.sample_rate).into()),
        );
    }
    if input.vbr_quality != 0 {
        object.key("vbrQuality").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.vbr_quality).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_opus_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::OpusSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.bitrate != 0 {
        object.key("bitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.bitrate).into()),
        );
    }
    if input.channels != 0 {
        object.key("channels").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.channels).into()),
        );
    }
    if input.sample_rate != 0 {
        object.key("sampleRate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.sample_rate).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_vorbis_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VorbisSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.channels != 0 {
        object.key("channels").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.channels).into()),
        );
    }
    if input.sample_rate != 0 {
        object.key("sampleRate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.sample_rate).into()),
        );
    }
    if input.vbr_quality != 0 {
        object.key("vbrQuality").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.vbr_quality).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_wav_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::WavSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.bit_depth != 0 {
        object.key("bitDepth").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.bit_depth).into()),
        );
    }
    if input.channels != 0 {
        object.key("channels").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.channels).into()),
        );
    }
    if let Some(var_730) = &input.format {
        object.key("format").string(var_730.as_str());
    }
    if input.sample_rate != 0 {
        object.key("sampleRate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.sample_rate).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_channel_mapping(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ChannelMapping,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_731) = &input.output_channels {
        let mut array_732 = object.key("outputChannels").start_array();
        for item_733 in var_731 {
            {
                let mut object_734 = array_732.value().start_object();
                crate::json_ser::serialize_structure_crate_model_output_channel_mapping(
                    &mut object_734,
                    item_733,
                )?;
                object_734.finish();
            }
        }
        array_732.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_burnin_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::BurninDestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_735) = &input.alignment {
        object.key("alignment").string(var_735.as_str());
    }
    if let Some(var_736) = &input.apply_font_color {
        object.key("applyFontColor").string(var_736.as_str());
    }
    if let Some(var_737) = &input.background_color {
        object.key("backgroundColor").string(var_737.as_str());
    }
    if input.background_opacity != 0 {
        object.key("backgroundOpacity").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.background_opacity).into()),
        );
    }
    if let Some(var_738) = &input.fallback_font {
        object.key("fallbackFont").string(var_738.as_str());
    }
    if let Some(var_739) = &input.font_color {
        object.key("fontColor").string(var_739.as_str());
    }
    if input.font_opacity != 0 {
        object.key("fontOpacity").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.font_opacity).into()),
        );
    }
    if input.font_resolution != 0 {
        object.key("fontResolution").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.font_resolution).into()),
        );
    }
    if let Some(var_740) = &input.font_script {
        object.key("fontScript").string(var_740.as_str());
    }
    if input.font_size != 0 {
        object.key("fontSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.font_size).into()),
        );
    }
    if let Some(var_741) = &input.hex_font_color {
        object.key("hexFontColor").string(var_741);
    }
    if let Some(var_742) = &input.outline_color {
        object.key("outlineColor").string(var_742.as_str());
    }
    if input.outline_size != 0 {
        object.key("outlineSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.outline_size).into()),
        );
    }
    if let Some(var_743) = &input.shadow_color {
        object.key("shadowColor").string(var_743.as_str());
    }
    if input.shadow_opacity != 0 {
        object.key("shadowOpacity").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.shadow_opacity).into()),
        );
    }
    if input.shadow_x_offset != 0 {
        object.key("shadowXOffset").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.shadow_x_offset).into()),
        );
    }
    if input.shadow_y_offset != 0 {
        object.key("shadowYOffset").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.shadow_y_offset).into()),
        );
    }
    if let Some(var_744) = &input.style_passthrough {
        object.key("stylePassthrough").string(var_744.as_str());
    }
    if let Some(var_745) = &input.teletext_spacing {
        object.key("teletextSpacing").string(var_745.as_str());
    }
    if input.x_position != 0 {
        object.key("xPosition").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.x_position).into()),
        );
    }
    if input.y_position != 0 {
        object.key("yPosition").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.y_position).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_dvb_sub_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DvbSubDestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_746) = &input.alignment {
        object.key("alignment").string(var_746.as_str());
    }
    if let Some(var_747) = &input.apply_font_color {
        object.key("applyFontColor").string(var_747.as_str());
    }
    if let Some(var_748) = &input.background_color {
        object.key("backgroundColor").string(var_748.as_str());
    }
    if input.background_opacity != 0 {
        object.key("backgroundOpacity").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.background_opacity).into()),
        );
    }
    if let Some(var_749) = &input.dds_handling {
        object.key("ddsHandling").string(var_749.as_str());
    }
    if input.dds_x_coordinate != 0 {
        object.key("ddsXCoordinate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.dds_x_coordinate).into()),
        );
    }
    if input.dds_y_coordinate != 0 {
        object.key("ddsYCoordinate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.dds_y_coordinate).into()),
        );
    }
    if let Some(var_750) = &input.fallback_font {
        object.key("fallbackFont").string(var_750.as_str());
    }
    if let Some(var_751) = &input.font_color {
        object.key("fontColor").string(var_751.as_str());
    }
    if input.font_opacity != 0 {
        object.key("fontOpacity").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.font_opacity).into()),
        );
    }
    if input.font_resolution != 0 {
        object.key("fontResolution").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.font_resolution).into()),
        );
    }
    if let Some(var_752) = &input.font_script {
        object.key("fontScript").string(var_752.as_str());
    }
    if input.font_size != 0 {
        object.key("fontSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.font_size).into()),
        );
    }
    if input.height != 0 {
        object.key("height").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.height).into()),
        );
    }
    if let Some(var_753) = &input.hex_font_color {
        object.key("hexFontColor").string(var_753);
    }
    if let Some(var_754) = &input.outline_color {
        object.key("outlineColor").string(var_754.as_str());
    }
    if input.outline_size != 0 {
        object.key("outlineSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.outline_size).into()),
        );
    }
    if let Some(var_755) = &input.shadow_color {
        object.key("shadowColor").string(var_755.as_str());
    }
    if input.shadow_opacity != 0 {
        object.key("shadowOpacity").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.shadow_opacity).into()),
        );
    }
    if input.shadow_x_offset != 0 {
        object.key("shadowXOffset").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.shadow_x_offset).into()),
        );
    }
    if input.shadow_y_offset != 0 {
        object.key("shadowYOffset").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.shadow_y_offset).into()),
        );
    }
    if let Some(var_756) = &input.style_passthrough {
        object.key("stylePassthrough").string(var_756.as_str());
    }
    if let Some(var_757) = &input.subtitling_type {
        object.key("subtitlingType").string(var_757.as_str());
    }
    if let Some(var_758) = &input.teletext_spacing {
        object.key("teletextSpacing").string(var_758.as_str());
    }
    if input.width != 0 {
        object.key("width").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.width).into()),
        );
    }
    if input.x_position != 0 {
        object.key("xPosition").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.x_position).into()),
        );
    }
    if input.y_position != 0 {
        object.key("yPosition").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.y_position).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_embedded_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::EmbeddedDestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.destination608_channel_number != 0 {
        object.key("destination608ChannelNumber").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.destination608_channel_number).into()),
        );
    }
    if input.destination708_service_number != 0 {
        object.key("destination708ServiceNumber").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.destination708_service_number).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_imsc_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ImscDestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_759) = &input.style_passthrough {
        object.key("stylePassthrough").string(var_759.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_scc_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SccDestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_760) = &input.framerate {
        object.key("framerate").string(var_760.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_srt_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SrtDestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_761) = &input.style_passthrough {
        object.key("stylePassthrough").string(var_761.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_teletext_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TeletextDestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_762) = &input.page_number {
        object.key("pageNumber").string(var_762);
    }
    if let Some(var_763) = &input.page_types {
        let mut array_764 = object.key("pageTypes").start_array();
        for item_765 in var_763 {
            {
                array_764.value().string(item_765.as_str());
            }
        }
        array_764.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_ttml_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TtmlDestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_766) = &input.style_passthrough {
        object.key("stylePassthrough").string(var_766.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_webvtt_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::WebvttDestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_767) = &input.style_passthrough {
        object.key("stylePassthrough").string(var_767.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_dvb_nit_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DvbNitSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.network_id != 0 {
        object.key("networkId").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.network_id).into()),
        );
    }
    if let Some(var_768) = &input.network_name {
        object.key("networkName").string(var_768);
    }
    if input.nit_interval != 0 {
        object.key("nitInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.nit_interval).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_dvb_sdt_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DvbSdtSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_769) = &input.output_sdt {
        object.key("outputSdt").string(var_769.as_str());
    }
    if input.sdt_interval != 0 {
        object.key("sdtInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.sdt_interval).into()),
        );
    }
    if let Some(var_770) = &input.service_name {
        object.key("serviceName").string(var_770);
    }
    if let Some(var_771) = &input.service_provider_name {
        object.key("serviceProviderName").string(var_771);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_dvb_tdt_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DvbTdtSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.tdt_interval != 0 {
        object.key("tdtInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.tdt_interval).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_m2ts_scte35_esam(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::M2tsScte35Esam,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.scte35_esam_pid != 0 {
        object.key("scte35EsamPid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.scte35_esam_pid).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_mxf_xavc_profile_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MxfXavcProfileSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_772) = &input.duration_mode {
        object.key("durationMode").string(var_772.as_str());
    }
    if input.max_anc_data_size != 0 {
        object.key("maxAncDataSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_anc_data_size).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_av1_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Av1Settings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_773) = &input.adaptive_quantization {
        object.key("adaptiveQuantization").string(var_773.as_str());
    }
    if let Some(var_774) = &input.framerate_control {
        object.key("framerateControl").string(var_774.as_str());
    }
    if let Some(var_775) = &input.framerate_conversion_algorithm {
        object
            .key("framerateConversionAlgorithm")
            .string(var_775.as_str());
    }
    if input.framerate_denominator != 0 {
        object.key("framerateDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_denominator).into()),
        );
    }
    if input.framerate_numerator != 0 {
        object.key("framerateNumerator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_numerator).into()),
        );
    }
    if input.gop_size != 0.0 {
        object.key("gopSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.gop_size).into()),
        );
    }
    if input.max_bitrate != 0 {
        object.key("maxBitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_bitrate).into()),
        );
    }
    if input.number_b_frames_between_reference_frames != 0 {
        object.key("numberBFramesBetweenReferenceFrames").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt(
                (input.number_b_frames_between_reference_frames).into(),
            ),
        );
    }
    if let Some(var_776) = &input.qvbr_settings {
        let mut object_777 = object.key("qvbrSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_av1_qvbr_settings(
            &mut object_777,
            var_776,
        )?;
        object_777.finish();
    }
    if let Some(var_778) = &input.rate_control_mode {
        object.key("rateControlMode").string(var_778.as_str());
    }
    if input.slices != 0 {
        object.key("slices").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.slices).into()),
        );
    }
    if let Some(var_779) = &input.spatial_adaptive_quantization {
        object
            .key("spatialAdaptiveQuantization")
            .string(var_779.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_avc_intra_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AvcIntraSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_780) = &input.avc_intra_class {
        object.key("avcIntraClass").string(var_780.as_str());
    }
    if let Some(var_781) = &input.avc_intra_uhd_settings {
        let mut object_782 = object.key("avcIntraUhdSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_avc_intra_uhd_settings(
            &mut object_782,
            var_781,
        )?;
        object_782.finish();
    }
    if let Some(var_783) = &input.framerate_control {
        object.key("framerateControl").string(var_783.as_str());
    }
    if let Some(var_784) = &input.framerate_conversion_algorithm {
        object
            .key("framerateConversionAlgorithm")
            .string(var_784.as_str());
    }
    if input.framerate_denominator != 0 {
        object.key("framerateDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_denominator).into()),
        );
    }
    if input.framerate_numerator != 0 {
        object.key("framerateNumerator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_numerator).into()),
        );
    }
    if let Some(var_785) = &input.interlace_mode {
        object.key("interlaceMode").string(var_785.as_str());
    }
    if let Some(var_786) = &input.scan_type_conversion_mode {
        object
            .key("scanTypeConversionMode")
            .string(var_786.as_str());
    }
    if let Some(var_787) = &input.slow_pal {
        object.key("slowPal").string(var_787.as_str());
    }
    if let Some(var_788) = &input.telecine {
        object.key("telecine").string(var_788.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_frame_capture_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FrameCaptureSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.framerate_denominator != 0 {
        object.key("framerateDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_denominator).into()),
        );
    }
    if input.framerate_numerator != 0 {
        object.key("framerateNumerator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_numerator).into()),
        );
    }
    if input.max_captures != 0 {
        object.key("maxCaptures").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_captures).into()),
        );
    }
    if input.quality != 0 {
        object.key("quality").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.quality).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_h264_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::H264Settings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_789) = &input.adaptive_quantization {
        object.key("adaptiveQuantization").string(var_789.as_str());
    }
    if input.bitrate != 0 {
        object.key("bitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.bitrate).into()),
        );
    }
    if let Some(var_790) = &input.codec_level {
        object.key("codecLevel").string(var_790.as_str());
    }
    if let Some(var_791) = &input.codec_profile {
        object.key("codecProfile").string(var_791.as_str());
    }
    if let Some(var_792) = &input.dynamic_sub_gop {
        object.key("dynamicSubGop").string(var_792.as_str());
    }
    if let Some(var_793) = &input.entropy_encoding {
        object.key("entropyEncoding").string(var_793.as_str());
    }
    if let Some(var_794) = &input.field_encoding {
        object.key("fieldEncoding").string(var_794.as_str());
    }
    if let Some(var_795) = &input.flicker_adaptive_quantization {
        object
            .key("flickerAdaptiveQuantization")
            .string(var_795.as_str());
    }
    if let Some(var_796) = &input.framerate_control {
        object.key("framerateControl").string(var_796.as_str());
    }
    if let Some(var_797) = &input.framerate_conversion_algorithm {
        object
            .key("framerateConversionAlgorithm")
            .string(var_797.as_str());
    }
    if input.framerate_denominator != 0 {
        object.key("framerateDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_denominator).into()),
        );
    }
    if input.framerate_numerator != 0 {
        object.key("framerateNumerator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_numerator).into()),
        );
    }
    if let Some(var_798) = &input.gop_b_reference {
        object.key("gopBReference").string(var_798.as_str());
    }
    if input.gop_closed_cadence != 0 {
        object.key("gopClosedCadence").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.gop_closed_cadence).into()),
        );
    }
    if input.gop_size != 0.0 {
        object.key("gopSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.gop_size).into()),
        );
    }
    if let Some(var_799) = &input.gop_size_units {
        object.key("gopSizeUnits").string(var_799.as_str());
    }
    if input.hrd_buffer_initial_fill_percentage != 0 {
        object.key("hrdBufferInitialFillPercentage").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.hrd_buffer_initial_fill_percentage).into()),
        );
    }
    if input.hrd_buffer_size != 0 {
        object.key("hrdBufferSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.hrd_buffer_size).into()),
        );
    }
    if let Some(var_800) = &input.interlace_mode {
        object.key("interlaceMode").string(var_800.as_str());
    }
    if input.max_bitrate != 0 {
        object.key("maxBitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_bitrate).into()),
        );
    }
    if input.min_i_interval != 0 {
        object.key("minIInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.min_i_interval).into()),
        );
    }
    if input.number_b_frames_between_reference_frames != 0 {
        object.key("numberBFramesBetweenReferenceFrames").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt(
                (input.number_b_frames_between_reference_frames).into(),
            ),
        );
    }
    if input.number_reference_frames != 0 {
        object.key("numberReferenceFrames").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.number_reference_frames).into()),
        );
    }
    if let Some(var_801) = &input.par_control {
        object.key("parControl").string(var_801.as_str());
    }
    if input.par_denominator != 0 {
        object.key("parDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.par_denominator).into()),
        );
    }
    if input.par_numerator != 0 {
        object.key("parNumerator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.par_numerator).into()),
        );
    }
    if let Some(var_802) = &input.quality_tuning_level {
        object.key("qualityTuningLevel").string(var_802.as_str());
    }
    if let Some(var_803) = &input.qvbr_settings {
        let mut object_804 = object.key("qvbrSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_h264_qvbr_settings(
            &mut object_804,
            var_803,
        )?;
        object_804.finish();
    }
    if let Some(var_805) = &input.rate_control_mode {
        object.key("rateControlMode").string(var_805.as_str());
    }
    if let Some(var_806) = &input.repeat_pps {
        object.key("repeatPps").string(var_806.as_str());
    }
    if let Some(var_807) = &input.scan_type_conversion_mode {
        object
            .key("scanTypeConversionMode")
            .string(var_807.as_str());
    }
    if let Some(var_808) = &input.scene_change_detect {
        object.key("sceneChangeDetect").string(var_808.as_str());
    }
    if input.slices != 0 {
        object.key("slices").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.slices).into()),
        );
    }
    if let Some(var_809) = &input.slow_pal {
        object.key("slowPal").string(var_809.as_str());
    }
    if input.softness != 0 {
        object.key("softness").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.softness).into()),
        );
    }
    if let Some(var_810) = &input.spatial_adaptive_quantization {
        object
            .key("spatialAdaptiveQuantization")
            .string(var_810.as_str());
    }
    if let Some(var_811) = &input.syntax {
        object.key("syntax").string(var_811.as_str());
    }
    if let Some(var_812) = &input.telecine {
        object.key("telecine").string(var_812.as_str());
    }
    if let Some(var_813) = &input.temporal_adaptive_quantization {
        object
            .key("temporalAdaptiveQuantization")
            .string(var_813.as_str());
    }
    if let Some(var_814) = &input.unregistered_sei_timecode {
        object
            .key("unregisteredSeiTimecode")
            .string(var_814.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_h265_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::H265Settings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_815) = &input.adaptive_quantization {
        object.key("adaptiveQuantization").string(var_815.as_str());
    }
    if let Some(var_816) = &input.alternate_transfer_function_sei {
        object
            .key("alternateTransferFunctionSei")
            .string(var_816.as_str());
    }
    if input.bitrate != 0 {
        object.key("bitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.bitrate).into()),
        );
    }
    if let Some(var_817) = &input.codec_level {
        object.key("codecLevel").string(var_817.as_str());
    }
    if let Some(var_818) = &input.codec_profile {
        object.key("codecProfile").string(var_818.as_str());
    }
    if let Some(var_819) = &input.dynamic_sub_gop {
        object.key("dynamicSubGop").string(var_819.as_str());
    }
    if let Some(var_820) = &input.flicker_adaptive_quantization {
        object
            .key("flickerAdaptiveQuantization")
            .string(var_820.as_str());
    }
    if let Some(var_821) = &input.framerate_control {
        object.key("framerateControl").string(var_821.as_str());
    }
    if let Some(var_822) = &input.framerate_conversion_algorithm {
        object
            .key("framerateConversionAlgorithm")
            .string(var_822.as_str());
    }
    if input.framerate_denominator != 0 {
        object.key("framerateDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_denominator).into()),
        );
    }
    if input.framerate_numerator != 0 {
        object.key("framerateNumerator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_numerator).into()),
        );
    }
    if let Some(var_823) = &input.gop_b_reference {
        object.key("gopBReference").string(var_823.as_str());
    }
    if input.gop_closed_cadence != 0 {
        object.key("gopClosedCadence").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.gop_closed_cadence).into()),
        );
    }
    if input.gop_size != 0.0 {
        object.key("gopSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.gop_size).into()),
        );
    }
    if let Some(var_824) = &input.gop_size_units {
        object.key("gopSizeUnits").string(var_824.as_str());
    }
    if input.hrd_buffer_initial_fill_percentage != 0 {
        object.key("hrdBufferInitialFillPercentage").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.hrd_buffer_initial_fill_percentage).into()),
        );
    }
    if input.hrd_buffer_size != 0 {
        object.key("hrdBufferSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.hrd_buffer_size).into()),
        );
    }
    if let Some(var_825) = &input.interlace_mode {
        object.key("interlaceMode").string(var_825.as_str());
    }
    if input.max_bitrate != 0 {
        object.key("maxBitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_bitrate).into()),
        );
    }
    if input.min_i_interval != 0 {
        object.key("minIInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.min_i_interval).into()),
        );
    }
    if input.number_b_frames_between_reference_frames != 0 {
        object.key("numberBFramesBetweenReferenceFrames").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt(
                (input.number_b_frames_between_reference_frames).into(),
            ),
        );
    }
    if input.number_reference_frames != 0 {
        object.key("numberReferenceFrames").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.number_reference_frames).into()),
        );
    }
    if let Some(var_826) = &input.par_control {
        object.key("parControl").string(var_826.as_str());
    }
    if input.par_denominator != 0 {
        object.key("parDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.par_denominator).into()),
        );
    }
    if input.par_numerator != 0 {
        object.key("parNumerator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.par_numerator).into()),
        );
    }
    if let Some(var_827) = &input.quality_tuning_level {
        object.key("qualityTuningLevel").string(var_827.as_str());
    }
    if let Some(var_828) = &input.qvbr_settings {
        let mut object_829 = object.key("qvbrSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_h265_qvbr_settings(
            &mut object_829,
            var_828,
        )?;
        object_829.finish();
    }
    if let Some(var_830) = &input.rate_control_mode {
        object.key("rateControlMode").string(var_830.as_str());
    }
    if let Some(var_831) = &input.sample_adaptive_offset_filter_mode {
        object
            .key("sampleAdaptiveOffsetFilterMode")
            .string(var_831.as_str());
    }
    if let Some(var_832) = &input.scan_type_conversion_mode {
        object
            .key("scanTypeConversionMode")
            .string(var_832.as_str());
    }
    if let Some(var_833) = &input.scene_change_detect {
        object.key("sceneChangeDetect").string(var_833.as_str());
    }
    if input.slices != 0 {
        object.key("slices").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.slices).into()),
        );
    }
    if let Some(var_834) = &input.slow_pal {
        object.key("slowPal").string(var_834.as_str());
    }
    if let Some(var_835) = &input.spatial_adaptive_quantization {
        object
            .key("spatialAdaptiveQuantization")
            .string(var_835.as_str());
    }
    if let Some(var_836) = &input.telecine {
        object.key("telecine").string(var_836.as_str());
    }
    if let Some(var_837) = &input.temporal_adaptive_quantization {
        object
            .key("temporalAdaptiveQuantization")
            .string(var_837.as_str());
    }
    if let Some(var_838) = &input.temporal_ids {
        object.key("temporalIds").string(var_838.as_str());
    }
    if let Some(var_839) = &input.tiles {
        object.key("tiles").string(var_839.as_str());
    }
    if let Some(var_840) = &input.unregistered_sei_timecode {
        object
            .key("unregisteredSeiTimecode")
            .string(var_840.as_str());
    }
    if let Some(var_841) = &input.write_mp4_packaging_type {
        object.key("writeMp4PackagingType").string(var_841.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_mpeg2_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Mpeg2Settings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_842) = &input.adaptive_quantization {
        object.key("adaptiveQuantization").string(var_842.as_str());
    }
    if input.bitrate != 0 {
        object.key("bitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.bitrate).into()),
        );
    }
    if let Some(var_843) = &input.codec_level {
        object.key("codecLevel").string(var_843.as_str());
    }
    if let Some(var_844) = &input.codec_profile {
        object.key("codecProfile").string(var_844.as_str());
    }
    if let Some(var_845) = &input.dynamic_sub_gop {
        object.key("dynamicSubGop").string(var_845.as_str());
    }
    if let Some(var_846) = &input.framerate_control {
        object.key("framerateControl").string(var_846.as_str());
    }
    if let Some(var_847) = &input.framerate_conversion_algorithm {
        object
            .key("framerateConversionAlgorithm")
            .string(var_847.as_str());
    }
    if input.framerate_denominator != 0 {
        object.key("framerateDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_denominator).into()),
        );
    }
    if input.framerate_numerator != 0 {
        object.key("framerateNumerator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_numerator).into()),
        );
    }
    if input.gop_closed_cadence != 0 {
        object.key("gopClosedCadence").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.gop_closed_cadence).into()),
        );
    }
    if input.gop_size != 0.0 {
        object.key("gopSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.gop_size).into()),
        );
    }
    if let Some(var_848) = &input.gop_size_units {
        object.key("gopSizeUnits").string(var_848.as_str());
    }
    if input.hrd_buffer_initial_fill_percentage != 0 {
        object.key("hrdBufferInitialFillPercentage").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.hrd_buffer_initial_fill_percentage).into()),
        );
    }
    if input.hrd_buffer_size != 0 {
        object.key("hrdBufferSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.hrd_buffer_size).into()),
        );
    }
    if let Some(var_849) = &input.interlace_mode {
        object.key("interlaceMode").string(var_849.as_str());
    }
    if let Some(var_850) = &input.intra_dc_precision {
        object.key("intraDcPrecision").string(var_850.as_str());
    }
    if input.max_bitrate != 0 {
        object.key("maxBitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_bitrate).into()),
        );
    }
    if input.min_i_interval != 0 {
        object.key("minIInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.min_i_interval).into()),
        );
    }
    if input.number_b_frames_between_reference_frames != 0 {
        object.key("numberBFramesBetweenReferenceFrames").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt(
                (input.number_b_frames_between_reference_frames).into(),
            ),
        );
    }
    if let Some(var_851) = &input.par_control {
        object.key("parControl").string(var_851.as_str());
    }
    if input.par_denominator != 0 {
        object.key("parDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.par_denominator).into()),
        );
    }
    if input.par_numerator != 0 {
        object.key("parNumerator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.par_numerator).into()),
        );
    }
    if let Some(var_852) = &input.quality_tuning_level {
        object.key("qualityTuningLevel").string(var_852.as_str());
    }
    if let Some(var_853) = &input.rate_control_mode {
        object.key("rateControlMode").string(var_853.as_str());
    }
    if let Some(var_854) = &input.scan_type_conversion_mode {
        object
            .key("scanTypeConversionMode")
            .string(var_854.as_str());
    }
    if let Some(var_855) = &input.scene_change_detect {
        object.key("sceneChangeDetect").string(var_855.as_str());
    }
    if let Some(var_856) = &input.slow_pal {
        object.key("slowPal").string(var_856.as_str());
    }
    if input.softness != 0 {
        object.key("softness").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.softness).into()),
        );
    }
    if let Some(var_857) = &input.spatial_adaptive_quantization {
        object
            .key("spatialAdaptiveQuantization")
            .string(var_857.as_str());
    }
    if let Some(var_858) = &input.syntax {
        object.key("syntax").string(var_858.as_str());
    }
    if let Some(var_859) = &input.telecine {
        object.key("telecine").string(var_859.as_str());
    }
    if let Some(var_860) = &input.temporal_adaptive_quantization {
        object
            .key("temporalAdaptiveQuantization")
            .string(var_860.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_prores_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ProresSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_861) = &input.chroma_sampling {
        object.key("chromaSampling").string(var_861.as_str());
    }
    if let Some(var_862) = &input.codec_profile {
        object.key("codecProfile").string(var_862.as_str());
    }
    if let Some(var_863) = &input.framerate_control {
        object.key("framerateControl").string(var_863.as_str());
    }
    if let Some(var_864) = &input.framerate_conversion_algorithm {
        object
            .key("framerateConversionAlgorithm")
            .string(var_864.as_str());
    }
    if input.framerate_denominator != 0 {
        object.key("framerateDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_denominator).into()),
        );
    }
    if input.framerate_numerator != 0 {
        object.key("framerateNumerator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_numerator).into()),
        );
    }
    if let Some(var_865) = &input.interlace_mode {
        object.key("interlaceMode").string(var_865.as_str());
    }
    if let Some(var_866) = &input.par_control {
        object.key("parControl").string(var_866.as_str());
    }
    if input.par_denominator != 0 {
        object.key("parDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.par_denominator).into()),
        );
    }
    if input.par_numerator != 0 {
        object.key("parNumerator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.par_numerator).into()),
        );
    }
    if let Some(var_867) = &input.scan_type_conversion_mode {
        object
            .key("scanTypeConversionMode")
            .string(var_867.as_str());
    }
    if let Some(var_868) = &input.slow_pal {
        object.key("slowPal").string(var_868.as_str());
    }
    if let Some(var_869) = &input.telecine {
        object.key("telecine").string(var_869.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_vc3_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Vc3Settings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_870) = &input.framerate_control {
        object.key("framerateControl").string(var_870.as_str());
    }
    if let Some(var_871) = &input.framerate_conversion_algorithm {
        object
            .key("framerateConversionAlgorithm")
            .string(var_871.as_str());
    }
    if input.framerate_denominator != 0 {
        object.key("framerateDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_denominator).into()),
        );
    }
    if input.framerate_numerator != 0 {
        object.key("framerateNumerator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_numerator).into()),
        );
    }
    if let Some(var_872) = &input.interlace_mode {
        object.key("interlaceMode").string(var_872.as_str());
    }
    if let Some(var_873) = &input.scan_type_conversion_mode {
        object
            .key("scanTypeConversionMode")
            .string(var_873.as_str());
    }
    if let Some(var_874) = &input.slow_pal {
        object.key("slowPal").string(var_874.as_str());
    }
    if let Some(var_875) = &input.telecine {
        object.key("telecine").string(var_875.as_str());
    }
    if let Some(var_876) = &input.vc3_class {
        object.key("vc3Class").string(var_876.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_vp8_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Vp8Settings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.bitrate != 0 {
        object.key("bitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.bitrate).into()),
        );
    }
    if let Some(var_877) = &input.framerate_control {
        object.key("framerateControl").string(var_877.as_str());
    }
    if let Some(var_878) = &input.framerate_conversion_algorithm {
        object
            .key("framerateConversionAlgorithm")
            .string(var_878.as_str());
    }
    if input.framerate_denominator != 0 {
        object.key("framerateDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_denominator).into()),
        );
    }
    if input.framerate_numerator != 0 {
        object.key("framerateNumerator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_numerator).into()),
        );
    }
    if input.gop_size != 0.0 {
        object.key("gopSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.gop_size).into()),
        );
    }
    if input.hrd_buffer_size != 0 {
        object.key("hrdBufferSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.hrd_buffer_size).into()),
        );
    }
    if input.max_bitrate != 0 {
        object.key("maxBitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_bitrate).into()),
        );
    }
    if let Some(var_879) = &input.par_control {
        object.key("parControl").string(var_879.as_str());
    }
    if input.par_denominator != 0 {
        object.key("parDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.par_denominator).into()),
        );
    }
    if input.par_numerator != 0 {
        object.key("parNumerator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.par_numerator).into()),
        );
    }
    if let Some(var_880) = &input.quality_tuning_level {
        object.key("qualityTuningLevel").string(var_880.as_str());
    }
    if let Some(var_881) = &input.rate_control_mode {
        object.key("rateControlMode").string(var_881.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_vp9_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Vp9Settings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.bitrate != 0 {
        object.key("bitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.bitrate).into()),
        );
    }
    if let Some(var_882) = &input.framerate_control {
        object.key("framerateControl").string(var_882.as_str());
    }
    if let Some(var_883) = &input.framerate_conversion_algorithm {
        object
            .key("framerateConversionAlgorithm")
            .string(var_883.as_str());
    }
    if input.framerate_denominator != 0 {
        object.key("framerateDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_denominator).into()),
        );
    }
    if input.framerate_numerator != 0 {
        object.key("framerateNumerator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_numerator).into()),
        );
    }
    if input.gop_size != 0.0 {
        object.key("gopSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.gop_size).into()),
        );
    }
    if input.hrd_buffer_size != 0 {
        object.key("hrdBufferSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.hrd_buffer_size).into()),
        );
    }
    if input.max_bitrate != 0 {
        object.key("maxBitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_bitrate).into()),
        );
    }
    if let Some(var_884) = &input.par_control {
        object.key("parControl").string(var_884.as_str());
    }
    if input.par_denominator != 0 {
        object.key("parDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.par_denominator).into()),
        );
    }
    if input.par_numerator != 0 {
        object.key("parNumerator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.par_numerator).into()),
        );
    }
    if let Some(var_885) = &input.quality_tuning_level {
        object.key("qualityTuningLevel").string(var_885.as_str());
    }
    if let Some(var_886) = &input.rate_control_mode {
        object.key("rateControlMode").string(var_886.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_xavc_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::XavcSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_887) = &input.adaptive_quantization {
        object.key("adaptiveQuantization").string(var_887.as_str());
    }
    if let Some(var_888) = &input.entropy_encoding {
        object.key("entropyEncoding").string(var_888.as_str());
    }
    if let Some(var_889) = &input.framerate_control {
        object.key("framerateControl").string(var_889.as_str());
    }
    if let Some(var_890) = &input.framerate_conversion_algorithm {
        object
            .key("framerateConversionAlgorithm")
            .string(var_890.as_str());
    }
    if input.framerate_denominator != 0 {
        object.key("framerateDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_denominator).into()),
        );
    }
    if input.framerate_numerator != 0 {
        object.key("framerateNumerator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_numerator).into()),
        );
    }
    if let Some(var_891) = &input.profile {
        object.key("profile").string(var_891.as_str());
    }
    if let Some(var_892) = &input.slow_pal {
        object.key("slowPal").string(var_892.as_str());
    }
    if input.softness != 0 {
        object.key("softness").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.softness).into()),
        );
    }
    if let Some(var_893) = &input.spatial_adaptive_quantization {
        object
            .key("spatialAdaptiveQuantization")
            .string(var_893.as_str());
    }
    if let Some(var_894) = &input.temporal_adaptive_quantization {
        object
            .key("temporalAdaptiveQuantization")
            .string(var_894.as_str());
    }
    if let Some(var_895) = &input.xavc4k_intra_cbg_profile_settings {
        let mut object_896 = object.key("xavc4kIntraCbgProfileSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_xavc4k_intra_cbg_profile_settings(
            &mut object_896,
            var_895,
        )?;
        object_896.finish();
    }
    if let Some(var_897) = &input.xavc4k_intra_vbr_profile_settings {
        let mut object_898 = object.key("xavc4kIntraVbrProfileSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_xavc4k_intra_vbr_profile_settings(
            &mut object_898,
            var_897,
        )?;
        object_898.finish();
    }
    if let Some(var_899) = &input.xavc4k_profile_settings {
        let mut object_900 = object.key("xavc4kProfileSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_xavc4k_profile_settings(
            &mut object_900,
            var_899,
        )?;
        object_900.finish();
    }
    if let Some(var_901) = &input.xavc_hd_intra_cbg_profile_settings {
        let mut object_902 = object.key("xavcHdIntraCbgProfileSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_xavc_hd_intra_cbg_profile_settings(
            &mut object_902,
            var_901,
        )?;
        object_902.finish();
    }
    if let Some(var_903) = &input.xavc_hd_profile_settings {
        let mut object_904 = object.key("xavcHdProfileSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_xavc_hd_profile_settings(
            &mut object_904,
            var_903,
        )?;
        object_904.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_color_corrector(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ColorCorrector,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.brightness != 0 {
        object.key("brightness").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.brightness).into()),
        );
    }
    if let Some(var_905) = &input.color_space_conversion {
        object.key("colorSpaceConversion").string(var_905.as_str());
    }
    if input.contrast != 0 {
        object.key("contrast").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.contrast).into()),
        );
    }
    if let Some(var_906) = &input.hdr10_metadata {
        let mut object_907 = object.key("hdr10Metadata").start_object();
        crate::json_ser::serialize_structure_crate_model_hdr10_metadata(&mut object_907, var_906)?;
        object_907.finish();
    }
    if input.hue != 0 {
        object.key("hue").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.hue).into()),
        );
    }
    if let Some(var_908) = &input.sample_range_conversion {
        object.key("sampleRangeConversion").string(var_908.as_str());
    }
    if input.saturation != 0 {
        object.key("saturation").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.saturation).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_deinterlacer(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Deinterlacer,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_909) = &input.algorithm {
        object.key("algorithm").string(var_909.as_str());
    }
    if let Some(var_910) = &input.control {
        object.key("control").string(var_910.as_str());
    }
    if let Some(var_911) = &input.mode {
        object.key("mode").string(var_911.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_dolby_vision(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DolbyVision,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_912) = &input.l6_metadata {
        let mut object_913 = object.key("l6Metadata").start_object();
        crate::json_ser::serialize_structure_crate_model_dolby_vision_level6_metadata(
            &mut object_913,
            var_912,
        )?;
        object_913.finish();
    }
    if let Some(var_914) = &input.l6_mode {
        object.key("l6Mode").string(var_914.as_str());
    }
    if let Some(var_915) = &input.profile {
        object.key("profile").string(var_915.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_hdr10_plus(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Hdr10Plus,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.mastering_monitor_nits != 0 {
        object.key("masteringMonitorNits").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.mastering_monitor_nits).into()),
        );
    }
    if input.target_monitor_nits != 0 {
        object.key("targetMonitorNits").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.target_monitor_nits).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_noise_reducer(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NoiseReducer,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_916) = &input.filter {
        object.key("filter").string(var_916.as_str());
    }
    if let Some(var_917) = &input.filter_settings {
        let mut object_918 = object.key("filterSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_noise_reducer_filter_settings(
            &mut object_918,
            var_917,
        )?;
        object_918.finish();
    }
    if let Some(var_919) = &input.spatial_filter_settings {
        let mut object_920 = object.key("spatialFilterSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_noise_reducer_spatial_filter_settings(
            &mut object_920,
            var_919,
        )?;
        object_920.finish();
    }
    if let Some(var_921) = &input.temporal_filter_settings {
        let mut object_922 = object.key("temporalFilterSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_noise_reducer_temporal_filter_settings(
            &mut object_922,
            var_921,
        )?;
        object_922.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_partner_watermarking(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::PartnerWatermarking,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_923) = &input.nexguard_file_marker_settings {
        let mut object_924 = object.key("nexguardFileMarkerSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_nex_guard_file_marker_settings(
            &mut object_924,
            var_923,
        )?;
        object_924.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_timecode_burnin(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TimecodeBurnin,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.font_size != 0 {
        object.key("fontSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.font_size).into()),
        );
    }
    if let Some(var_925) = &input.position {
        object.key("position").string(var_925.as_str());
    }
    if let Some(var_926) = &input.prefix {
        object.key("prefix").string(var_926);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_ancillary_source_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AncillarySourceSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_927) = &input.convert608_to708 {
        object.key("convert608To708").string(var_927.as_str());
    }
    if input.source_ancillary_channel_number != 0 {
        object.key("sourceAncillaryChannelNumber").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.source_ancillary_channel_number).into()),
        );
    }
    if let Some(var_928) = &input.terminate_captions {
        object.key("terminateCaptions").string(var_928.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_dvb_sub_source_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DvbSubSourceSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.pid != 0 {
        object.key("pid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.pid).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_embedded_source_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::EmbeddedSourceSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_929) = &input.convert608_to708 {
        object.key("convert608To708").string(var_929.as_str());
    }
    if input.source608_channel_number != 0 {
        object.key("source608ChannelNumber").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.source608_channel_number).into()),
        );
    }
    if input.source608_track_number != 0 {
        object.key("source608TrackNumber").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.source608_track_number).into()),
        );
    }
    if let Some(var_930) = &input.terminate_captions {
        object.key("terminateCaptions").string(var_930.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_file_source_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FileSourceSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_931) = &input.convert608_to708 {
        object.key("convert608To708").string(var_931.as_str());
    }
    if let Some(var_932) = &input.framerate {
        let mut object_933 = object.key("framerate").start_object();
        crate::json_ser::serialize_structure_crate_model_caption_source_framerate(
            &mut object_933,
            var_932,
        )?;
        object_933.finish();
    }
    if let Some(var_934) = &input.source_file {
        object.key("sourceFile").string(var_934);
    }
    if input.time_delta != 0 {
        object.key("timeDelta").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.time_delta).into()),
        );
    }
    if let Some(var_935) = &input.time_delta_units {
        object.key("timeDeltaUnits").string(var_935.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_teletext_source_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TeletextSourceSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_936) = &input.page_number {
        object.key("pageNumber").string(var_936);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_track_source_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TrackSourceSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.track_number != 0 {
        object.key("trackNumber").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.track_number).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_webvtt_hls_source_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::WebvttHlsSourceSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_937) = &input.rendition_group_id {
        object.key("renditionGroupId").string(var_937);
    }
    if let Some(var_938) = &input.rendition_language_code {
        object.key("renditionLanguageCode").string(var_938.as_str());
    }
    if let Some(var_939) = &input.rendition_name {
        object.key("renditionName").string(var_939);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_cmaf_additional_manifest(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CmafAdditionalManifest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_940) = &input.manifest_name_modifier {
        object.key("manifestNameModifier").string(var_940);
    }
    if let Some(var_941) = &input.selected_outputs {
        let mut array_942 = object.key("selectedOutputs").start_array();
        for item_943 in var_941 {
            {
                array_942.value().string(item_943);
            }
        }
        array_942.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_944) = &input.s3_settings {
        let mut object_945 = object.key("s3Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_s3_destination_settings(
            &mut object_945,
            var_944,
        )?;
        object_945.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_cmaf_encryption_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CmafEncryptionSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_946) = &input.constant_initialization_vector {
        object.key("constantInitializationVector").string(var_946);
    }
    if let Some(var_947) = &input.encryption_method {
        object.key("encryptionMethod").string(var_947.as_str());
    }
    if let Some(var_948) = &input.initialization_vector_in_manifest {
        object
            .key("initializationVectorInManifest")
            .string(var_948.as_str());
    }
    if let Some(var_949) = &input.speke_key_provider {
        let mut object_950 = object.key("spekeKeyProvider").start_object();
        crate::json_ser::serialize_structure_crate_model_speke_key_provider_cmaf(
            &mut object_950,
            var_949,
        )?;
        object_950.finish();
    }
    if let Some(var_951) = &input.static_key_provider {
        let mut object_952 = object.key("staticKeyProvider").start_object();
        crate::json_ser::serialize_structure_crate_model_static_key_provider(
            &mut object_952,
            var_951,
        )?;
        object_952.finish();
    }
    if let Some(var_953) = &input.r#type {
        object.key("type").string(var_953.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_cmaf_image_based_trick_play_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CmafImageBasedTrickPlaySettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_954) = &input.interval_cadence {
        object.key("intervalCadence").string(var_954.as_str());
    }
    if input.thumbnail_height != 0 {
        object.key("thumbnailHeight").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.thumbnail_height).into()),
        );
    }
    if input.thumbnail_interval != 0.0 {
        object.key("thumbnailInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.thumbnail_interval).into()),
        );
    }
    if input.thumbnail_width != 0 {
        object.key("thumbnailWidth").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.thumbnail_width).into()),
        );
    }
    if input.tile_height != 0 {
        object.key("tileHeight").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.tile_height).into()),
        );
    }
    if input.tile_width != 0 {
        object.key("tileWidth").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.tile_width).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_dash_additional_manifest(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DashAdditionalManifest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_955) = &input.manifest_name_modifier {
        object.key("manifestNameModifier").string(var_955);
    }
    if let Some(var_956) = &input.selected_outputs {
        let mut array_957 = object.key("selectedOutputs").start_array();
        for item_958 in var_956 {
            {
                array_957.value().string(item_958);
            }
        }
        array_957.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_dash_iso_encryption_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DashIsoEncryptionSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_959) = &input.playback_device_compatibility {
        object
            .key("playbackDeviceCompatibility")
            .string(var_959.as_str());
    }
    if let Some(var_960) = &input.speke_key_provider {
        let mut object_961 = object.key("spekeKeyProvider").start_object();
        crate::json_ser::serialize_structure_crate_model_speke_key_provider(
            &mut object_961,
            var_960,
        )?;
        object_961.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_dash_iso_image_based_trick_play_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DashIsoImageBasedTrickPlaySettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_962) = &input.interval_cadence {
        object.key("intervalCadence").string(var_962.as_str());
    }
    if input.thumbnail_height != 0 {
        object.key("thumbnailHeight").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.thumbnail_height).into()),
        );
    }
    if input.thumbnail_interval != 0.0 {
        object.key("thumbnailInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.thumbnail_interval).into()),
        );
    }
    if input.thumbnail_width != 0 {
        object.key("thumbnailWidth").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.thumbnail_width).into()),
        );
    }
    if input.tile_height != 0 {
        object.key("tileHeight").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.tile_height).into()),
        );
    }
    if input.tile_width != 0 {
        object.key("tileWidth").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.tile_width).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_hls_additional_manifest(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HlsAdditionalManifest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_963) = &input.manifest_name_modifier {
        object.key("manifestNameModifier").string(var_963);
    }
    if let Some(var_964) = &input.selected_outputs {
        let mut array_965 = object.key("selectedOutputs").start_array();
        for item_966 in var_964 {
            {
                array_965.value().string(item_966);
            }
        }
        array_965.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_hls_caption_language_mapping(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HlsCaptionLanguageMapping,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.caption_channel != 0 {
        object.key("captionChannel").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.caption_channel).into()),
        );
    }
    if let Some(var_967) = &input.custom_language_code {
        object.key("customLanguageCode").string(var_967);
    }
    if let Some(var_968) = &input.language_code {
        object.key("languageCode").string(var_968.as_str());
    }
    if let Some(var_969) = &input.language_description {
        object.key("languageDescription").string(var_969);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_hls_encryption_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HlsEncryptionSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_970) = &input.constant_initialization_vector {
        object.key("constantInitializationVector").string(var_970);
    }
    if let Some(var_971) = &input.encryption_method {
        object.key("encryptionMethod").string(var_971.as_str());
    }
    if let Some(var_972) = &input.initialization_vector_in_manifest {
        object
            .key("initializationVectorInManifest")
            .string(var_972.as_str());
    }
    if let Some(var_973) = &input.offline_encrypted {
        object.key("offlineEncrypted").string(var_973.as_str());
    }
    if let Some(var_974) = &input.speke_key_provider {
        let mut object_975 = object.key("spekeKeyProvider").start_object();
        crate::json_ser::serialize_structure_crate_model_speke_key_provider(
            &mut object_975,
            var_974,
        )?;
        object_975.finish();
    }
    if let Some(var_976) = &input.static_key_provider {
        let mut object_977 = object.key("staticKeyProvider").start_object();
        crate::json_ser::serialize_structure_crate_model_static_key_provider(
            &mut object_977,
            var_976,
        )?;
        object_977.finish();
    }
    if let Some(var_978) = &input.r#type {
        object.key("type").string(var_978.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_hls_image_based_trick_play_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HlsImageBasedTrickPlaySettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_979) = &input.interval_cadence {
        object.key("intervalCadence").string(var_979.as_str());
    }
    if input.thumbnail_height != 0 {
        object.key("thumbnailHeight").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.thumbnail_height).into()),
        );
    }
    if input.thumbnail_interval != 0.0 {
        object.key("thumbnailInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.thumbnail_interval).into()),
        );
    }
    if input.thumbnail_width != 0 {
        object.key("thumbnailWidth").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.thumbnail_width).into()),
        );
    }
    if input.tile_height != 0 {
        object.key("tileHeight").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.tile_height).into()),
        );
    }
    if input.tile_width != 0 {
        object.key("tileWidth").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.tile_width).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_ms_smooth_additional_manifest(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MsSmoothAdditionalManifest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_980) = &input.manifest_name_modifier {
        object.key("manifestNameModifier").string(var_980);
    }
    if let Some(var_981) = &input.selected_outputs {
        let mut array_982 = object.key("selectedOutputs").start_array();
        for item_983 in var_981 {
            {
                array_982.value().string(item_983);
            }
        }
        array_982.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_ms_smooth_encryption_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MsSmoothEncryptionSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_984) = &input.speke_key_provider {
        let mut object_985 = object.key("spekeKeyProvider").start_object();
        crate::json_ser::serialize_structure_crate_model_speke_key_provider(
            &mut object_985,
            var_984,
        )?;
        object_985.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_hls_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HlsSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_986) = &input.audio_group_id {
        object.key("audioGroupId").string(var_986);
    }
    if let Some(var_987) = &input.audio_only_container {
        object.key("audioOnlyContainer").string(var_987.as_str());
    }
    if let Some(var_988) = &input.audio_rendition_sets {
        object.key("audioRenditionSets").string(var_988);
    }
    if let Some(var_989) = &input.audio_track_type {
        object.key("audioTrackType").string(var_989.as_str());
    }
    if let Some(var_990) = &input.descriptive_video_service_flag {
        object
            .key("descriptiveVideoServiceFlag")
            .string(var_990.as_str());
    }
    if let Some(var_991) = &input.i_frame_only_manifest {
        object.key("iFrameOnlyManifest").string(var_991.as_str());
    }
    if let Some(var_992) = &input.segment_modifier {
        object.key("segmentModifier").string(var_992);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_output_channel_mapping(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::OutputChannelMapping,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_993) = &input.input_channels {
        let mut array_994 = object.key("inputChannels").start_array();
        for item_995 in var_993 {
            {
                array_994.value().number(
                    #[allow(clippy::useless_conversion)]
                    aws_smithy_types::Number::NegInt((*item_995).into()),
                );
            }
        }
        array_994.finish();
    }
    if let Some(var_996) = &input.input_channels_fine_tune {
        let mut array_997 = object.key("inputChannelsFineTune").start_array();
        for item_998 in var_996 {
            {
                array_997.value().number(
                    #[allow(clippy::useless_conversion)]
                    aws_smithy_types::Number::Float((*item_998).into()),
                );
            }
        }
        array_997.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_av1_qvbr_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Av1QvbrSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.qvbr_quality_level != 0 {
        object.key("qvbrQualityLevel").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.qvbr_quality_level).into()),
        );
    }
    if input.qvbr_quality_level_fine_tune != 0.0 {
        object.key("qvbrQualityLevelFineTune").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.qvbr_quality_level_fine_tune).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_avc_intra_uhd_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AvcIntraUhdSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_999) = &input.quality_tuning_level {
        object.key("qualityTuningLevel").string(var_999.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_h264_qvbr_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::H264QvbrSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.max_average_bitrate != 0 {
        object.key("maxAverageBitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_average_bitrate).into()),
        );
    }
    if input.qvbr_quality_level != 0 {
        object.key("qvbrQualityLevel").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.qvbr_quality_level).into()),
        );
    }
    if input.qvbr_quality_level_fine_tune != 0.0 {
        object.key("qvbrQualityLevelFineTune").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.qvbr_quality_level_fine_tune).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_h265_qvbr_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::H265QvbrSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.max_average_bitrate != 0 {
        object.key("maxAverageBitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_average_bitrate).into()),
        );
    }
    if input.qvbr_quality_level != 0 {
        object.key("qvbrQualityLevel").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.qvbr_quality_level).into()),
        );
    }
    if input.qvbr_quality_level_fine_tune != 0.0 {
        object.key("qvbrQualityLevelFineTune").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.qvbr_quality_level_fine_tune).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_xavc4k_intra_cbg_profile_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Xavc4kIntraCbgProfileSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_1000) = &input.xavc_class {
        object.key("xavcClass").string(var_1000.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_xavc4k_intra_vbr_profile_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Xavc4kIntraVbrProfileSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_1001) = &input.xavc_class {
        object.key("xavcClass").string(var_1001.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_xavc4k_profile_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Xavc4kProfileSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_1002) = &input.bitrate_class {
        object.key("bitrateClass").string(var_1002.as_str());
    }
    if let Some(var_1003) = &input.codec_profile {
        object.key("codecProfile").string(var_1003.as_str());
    }
    if let Some(var_1004) = &input.flicker_adaptive_quantization {
        object
            .key("flickerAdaptiveQuantization")
            .string(var_1004.as_str());
    }
    if let Some(var_1005) = &input.gop_b_reference {
        object.key("gopBReference").string(var_1005.as_str());
    }
    if input.gop_closed_cadence != 0 {
        object.key("gopClosedCadence").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.gop_closed_cadence).into()),
        );
    }
    if input.hrd_buffer_size != 0 {
        object.key("hrdBufferSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.hrd_buffer_size).into()),
        );
    }
    if let Some(var_1006) = &input.quality_tuning_level {
        object.key("qualityTuningLevel").string(var_1006.as_str());
    }
    if input.slices != 0 {
        object.key("slices").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.slices).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_xavc_hd_intra_cbg_profile_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::XavcHdIntraCbgProfileSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_1007) = &input.xavc_class {
        object.key("xavcClass").string(var_1007.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_xavc_hd_profile_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::XavcHdProfileSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_1008) = &input.bitrate_class {
        object.key("bitrateClass").string(var_1008.as_str());
    }
    if let Some(var_1009) = &input.flicker_adaptive_quantization {
        object
            .key("flickerAdaptiveQuantization")
            .string(var_1009.as_str());
    }
    if let Some(var_1010) = &input.gop_b_reference {
        object.key("gopBReference").string(var_1010.as_str());
    }
    if input.gop_closed_cadence != 0 {
        object.key("gopClosedCadence").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.gop_closed_cadence).into()),
        );
    }
    if input.hrd_buffer_size != 0 {
        object.key("hrdBufferSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.hrd_buffer_size).into()),
        );
    }
    if let Some(var_1011) = &input.interlace_mode {
        object.key("interlaceMode").string(var_1011.as_str());
    }
    if let Some(var_1012) = &input.quality_tuning_level {
        object.key("qualityTuningLevel").string(var_1012.as_str());
    }
    if input.slices != 0 {
        object.key("slices").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.slices).into()),
        );
    }
    if let Some(var_1013) = &input.telecine {
        object.key("telecine").string(var_1013.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_dolby_vision_level6_metadata(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DolbyVisionLevel6Metadata,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.max_cll != 0 {
        object.key("maxCll").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_cll).into()),
        );
    }
    if input.max_fall != 0 {
        object.key("maxFall").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_fall).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_noise_reducer_filter_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NoiseReducerFilterSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.strength != 0 {
        object.key("strength").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.strength).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_noise_reducer_spatial_filter_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NoiseReducerSpatialFilterSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.post_filter_sharpen_strength != 0 {
        object.key("postFilterSharpenStrength").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.post_filter_sharpen_strength).into()),
        );
    }
    if input.speed != 0 {
        object.key("speed").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.speed).into()),
        );
    }
    if input.strength != 0 {
        object.key("strength").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.strength).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_noise_reducer_temporal_filter_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NoiseReducerTemporalFilterSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.aggressive_mode != 0 {
        object.key("aggressiveMode").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.aggressive_mode).into()),
        );
    }
    if let Some(var_1014) = &input.post_temporal_sharpening {
        object
            .key("postTemporalSharpening")
            .string(var_1014.as_str());
    }
    if let Some(var_1015) = &input.post_temporal_sharpening_strength {
        object
            .key("postTemporalSharpeningStrength")
            .string(var_1015.as_str());
    }
    if input.speed != 0 {
        object.key("speed").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.speed).into()),
        );
    }
    if input.strength != 0 {
        object.key("strength").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.strength).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_nex_guard_file_marker_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NexGuardFileMarkerSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_1016) = &input.license {
        object.key("license").string(var_1016);
    }
    if input.payload != 0 {
        object.key("payload").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.payload).into()),
        );
    }
    if let Some(var_1017) = &input.preset {
        object.key("preset").string(var_1017);
    }
    if let Some(var_1018) = &input.strength {
        object.key("strength").string(var_1018.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_caption_source_framerate(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CaptionSourceFramerate,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.framerate_denominator != 0 {
        object.key("framerateDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_denominator).into()),
        );
    }
    if input.framerate_numerator != 0 {
        object.key("framerateNumerator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_numerator).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_s3_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::S3DestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_1019) = &input.access_control {
        let mut object_1020 = object.key("accessControl").start_object();
        crate::json_ser::serialize_structure_crate_model_s3_destination_access_control(
            &mut object_1020,
            var_1019,
        )?;
        object_1020.finish();
    }
    if let Some(var_1021) = &input.encryption {
        let mut object_1022 = object.key("encryption").start_object();
        crate::json_ser::serialize_structure_crate_model_s3_encryption_settings(
            &mut object_1022,
            var_1021,
        )?;
        object_1022.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_speke_key_provider_cmaf(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SpekeKeyProviderCmaf,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_1023) = &input.certificate_arn {
        object.key("certificateArn").string(var_1023);
    }
    if let Some(var_1024) = &input.dash_signaled_system_ids {
        let mut array_1025 = object.key("dashSignaledSystemIds").start_array();
        for item_1026 in var_1024 {
            {
                array_1025.value().string(item_1026);
            }
        }
        array_1025.finish();
    }
    if let Some(var_1027) = &input.hls_signaled_system_ids {
        let mut array_1028 = object.key("hlsSignaledSystemIds").start_array();
        for item_1029 in var_1027 {
            {
                array_1028.value().string(item_1029);
            }
        }
        array_1028.finish();
    }
    if let Some(var_1030) = &input.resource_id {
        object.key("resourceId").string(var_1030);
    }
    if let Some(var_1031) = &input.url {
        object.key("url").string(var_1031);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_static_key_provider(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::StaticKeyProvider,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_1032) = &input.key_format {
        object.key("keyFormat").string(var_1032);
    }
    if let Some(var_1033) = &input.key_format_versions {
        object.key("keyFormatVersions").string(var_1033);
    }
    if let Some(var_1034) = &input.static_key_value {
        object.key("staticKeyValue").string(var_1034);
    }
    if let Some(var_1035) = &input.url {
        object.key("url").string(var_1035);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_speke_key_provider(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SpekeKeyProvider,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_1036) = &input.certificate_arn {
        object.key("certificateArn").string(var_1036);
    }
    if let Some(var_1037) = &input.resource_id {
        object.key("resourceId").string(var_1037);
    }
    if let Some(var_1038) = &input.system_ids {
        let mut array_1039 = object.key("systemIds").start_array();
        for item_1040 in var_1038 {
            {
                array_1039.value().string(item_1040);
            }
        }
        array_1039.finish();
    }
    if let Some(var_1041) = &input.url {
        object.key("url").string(var_1041);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_s3_destination_access_control(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::S3DestinationAccessControl,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_1042) = &input.canned_acl {
        object.key("cannedAcl").string(var_1042.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_s3_encryption_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::S3EncryptionSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_1043) = &input.encryption_type {
        object.key("encryptionType").string(var_1043.as_str());
    }
    if let Some(var_1044) = &input.kms_encryption_context {
        object.key("kmsEncryptionContext").string(var_1044);
    }
    if let Some(var_1045) = &input.kms_key_arn {
        object.key("kmsKeyArn").string(var_1045);
    }
    Ok(())
}