aws-sdk-medialive 0.7.0

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub fn serialize_structure_crate_input_batch_delete_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchDeleteInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_1) = &input.channel_ids {
        let mut array_2 = object.key("channelIds").start_array();
        for item_3 in var_1 {
            {
                array_2.value().string(item_3.as_str());
            }
        }
        array_2.finish();
    }
    if let Some(var_4) = &input.input_ids {
        let mut array_5 = object.key("inputIds").start_array();
        for item_6 in var_4 {
            {
                array_5.value().string(item_6.as_str());
            }
        }
        array_5.finish();
    }
    if let Some(var_7) = &input.input_security_group_ids {
        let mut array_8 = object.key("inputSecurityGroupIds").start_array();
        for item_9 in var_7 {
            {
                array_8.value().string(item_9.as_str());
            }
        }
        array_8.finish();
    }
    if let Some(var_10) = &input.multiplex_ids {
        let mut array_11 = object.key("multiplexIds").start_array();
        for item_12 in var_10 {
            {
                array_11.value().string(item_12.as_str());
            }
        }
        array_11.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_batch_start_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchStartInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_13) = &input.channel_ids {
        let mut array_14 = object.key("channelIds").start_array();
        for item_15 in var_13 {
            {
                array_14.value().string(item_15.as_str());
            }
        }
        array_14.finish();
    }
    if let Some(var_16) = &input.multiplex_ids {
        let mut array_17 = object.key("multiplexIds").start_array();
        for item_18 in var_16 {
            {
                array_17.value().string(item_18.as_str());
            }
        }
        array_17.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_batch_stop_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchStopInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_19) = &input.channel_ids {
        let mut array_20 = object.key("channelIds").start_array();
        for item_21 in var_19 {
            {
                array_20.value().string(item_21.as_str());
            }
        }
        array_20.finish();
    }
    if let Some(var_22) = &input.multiplex_ids {
        let mut array_23 = object.key("multiplexIds").start_array();
        for item_24 in var_22 {
            {
                array_23.value().string(item_24.as_str());
            }
        }
        array_23.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_batch_update_schedule_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchUpdateScheduleInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_25) = &input.creates {
        let mut object_26 = object.key("creates").start_object();
        crate::json_ser::serialize_structure_crate_model_batch_schedule_action_create_request(
            &mut object_26,
            var_25,
        )?;
        object_26.finish();
    }
    if let Some(var_27) = &input.deletes {
        let mut object_28 = object.key("deletes").start_object();
        crate::json_ser::serialize_structure_crate_model_batch_schedule_action_delete_request(
            &mut object_28,
            var_27,
        )?;
        object_28.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_claim_device_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ClaimDeviceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_29) = &input.id {
        object.key("id").string(var_29.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_channel_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateChannelInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_30) = &input.cdi_input_specification {
        let mut object_31 = object.key("cdiInputSpecification").start_object();
        crate::json_ser::serialize_structure_crate_model_cdi_input_specification(
            &mut object_31,
            var_30,
        )?;
        object_31.finish();
    }
    if let Some(var_32) = &input.channel_class {
        object.key("channelClass").string(var_32.as_str());
    }
    if let Some(var_33) = &input.destinations {
        let mut array_34 = object.key("destinations").start_array();
        for item_35 in var_33 {
            {
                let mut object_36 = array_34.value().start_object();
                crate::json_ser::serialize_structure_crate_model_output_destination(
                    &mut object_36,
                    item_35,
                )?;
                object_36.finish();
            }
        }
        array_34.finish();
    }
    if let Some(var_37) = &input.encoder_settings {
        let mut object_38 = object.key("encoderSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_encoder_settings(&mut object_38, var_37)?;
        object_38.finish();
    }
    if let Some(var_39) = &input.input_attachments {
        let mut array_40 = object.key("inputAttachments").start_array();
        for item_41 in var_39 {
            {
                let mut object_42 = array_40.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_attachment(
                    &mut object_42,
                    item_41,
                )?;
                object_42.finish();
            }
        }
        array_40.finish();
    }
    if let Some(var_43) = &input.input_specification {
        let mut object_44 = object.key("inputSpecification").start_object();
        crate::json_ser::serialize_structure_crate_model_input_specification(
            &mut object_44,
            var_43,
        )?;
        object_44.finish();
    }
    if let Some(var_45) = &input.log_level {
        object.key("logLevel").string(var_45.as_str());
    }
    if let Some(var_46) = &input.name {
        object.key("name").string(var_46.as_str());
    }
    if let Some(var_47) = &input.request_id {
        object.key("requestId").string(var_47.as_str());
    }
    if let Some(var_48) = &input.reserved {
        object.key("reserved").string(var_48.as_str());
    }
    if let Some(var_49) = &input.role_arn {
        object.key("roleArn").string(var_49.as_str());
    }
    if let Some(var_50) = &input.tags {
        let mut object_51 = object.key("tags").start_object();
        for (key_52, value_53) in var_50 {
            {
                object_51.key(key_52).string(value_53.as_str());
            }
        }
        object_51.finish();
    }
    if let Some(var_54) = &input.vpc {
        let mut object_55 = object.key("vpc").start_object();
        crate::json_ser::serialize_structure_crate_model_vpc_output_settings(
            &mut object_55,
            var_54,
        )?;
        object_55.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_input_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateInputInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_56) = &input.destinations {
        let mut array_57 = object.key("destinations").start_array();
        for item_58 in var_56 {
            {
                let mut object_59 = array_57.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_destination_request(
                    &mut object_59,
                    item_58,
                )?;
                object_59.finish();
            }
        }
        array_57.finish();
    }
    if let Some(var_60) = &input.input_devices {
        let mut array_61 = object.key("inputDevices").start_array();
        for item_62 in var_60 {
            {
                let mut object_63 = array_61.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_device_settings(
                    &mut object_63,
                    item_62,
                )?;
                object_63.finish();
            }
        }
        array_61.finish();
    }
    if let Some(var_64) = &input.input_security_groups {
        let mut array_65 = object.key("inputSecurityGroups").start_array();
        for item_66 in var_64 {
            {
                array_65.value().string(item_66.as_str());
            }
        }
        array_65.finish();
    }
    if let Some(var_67) = &input.media_connect_flows {
        let mut array_68 = object.key("mediaConnectFlows").start_array();
        for item_69 in var_67 {
            {
                let mut object_70 = array_68.value().start_object();
                crate::json_ser::serialize_structure_crate_model_media_connect_flow_request(
                    &mut object_70,
                    item_69,
                )?;
                object_70.finish();
            }
        }
        array_68.finish();
    }
    if let Some(var_71) = &input.name {
        object.key("name").string(var_71.as_str());
    }
    if let Some(var_72) = &input.request_id {
        object.key("requestId").string(var_72.as_str());
    }
    if let Some(var_73) = &input.role_arn {
        object.key("roleArn").string(var_73.as_str());
    }
    if let Some(var_74) = &input.sources {
        let mut array_75 = object.key("sources").start_array();
        for item_76 in var_74 {
            {
                let mut object_77 = array_75.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_source_request(
                    &mut object_77,
                    item_76,
                )?;
                object_77.finish();
            }
        }
        array_75.finish();
    }
    if let Some(var_78) = &input.tags {
        let mut object_79 = object.key("tags").start_object();
        for (key_80, value_81) in var_78 {
            {
                object_79.key(key_80).string(value_81.as_str());
            }
        }
        object_79.finish();
    }
    if let Some(var_82) = &input.r#type {
        object.key("type").string(var_82.as_str());
    }
    if let Some(var_83) = &input.vpc {
        let mut object_84 = object.key("vpc").start_object();
        crate::json_ser::serialize_structure_crate_model_input_vpc_request(&mut object_84, var_83)?;
        object_84.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_input_security_group_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateInputSecurityGroupInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_85) = &input.tags {
        let mut object_86 = object.key("tags").start_object();
        for (key_87, value_88) in var_85 {
            {
                object_86.key(key_87).string(value_88.as_str());
            }
        }
        object_86.finish();
    }
    if let Some(var_89) = &input.whitelist_rules {
        let mut array_90 = object.key("whitelistRules").start_array();
        for item_91 in var_89 {
            {
                let mut object_92 = array_90.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_whitelist_rule_cidr(
                    &mut object_92,
                    item_91,
                )?;
                object_92.finish();
            }
        }
        array_90.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_multiplex_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateMultiplexInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_93) = &input.availability_zones {
        let mut array_94 = object.key("availabilityZones").start_array();
        for item_95 in var_93 {
            {
                array_94.value().string(item_95.as_str());
            }
        }
        array_94.finish();
    }
    if let Some(var_96) = &input.multiplex_settings {
        let mut object_97 = object.key("multiplexSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_settings(
            &mut object_97,
            var_96,
        )?;
        object_97.finish();
    }
    if let Some(var_98) = &input.name {
        object.key("name").string(var_98.as_str());
    }
    if let Some(var_99) = &input.request_id {
        object.key("requestId").string(var_99.as_str());
    }
    if let Some(var_100) = &input.tags {
        let mut object_101 = object.key("tags").start_object();
        for (key_102, value_103) in var_100 {
            {
                object_101.key(key_102).string(value_103.as_str());
            }
        }
        object_101.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_multiplex_program_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateMultiplexProgramInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_104) = &input.multiplex_program_settings {
        let mut object_105 = object.key("multiplexProgramSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_program_settings(
            &mut object_105,
            var_104,
        )?;
        object_105.finish();
    }
    if let Some(var_106) = &input.program_name {
        object.key("programName").string(var_106.as_str());
    }
    if let Some(var_107) = &input.request_id {
        object.key("requestId").string(var_107.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_partner_input_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreatePartnerInputInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_108) = &input.request_id {
        object.key("requestId").string(var_108.as_str());
    }
    if let Some(var_109) = &input.tags {
        let mut object_110 = object.key("tags").start_object();
        for (key_111, value_112) in var_109 {
            {
                object_110.key(key_111).string(value_112.as_str());
            }
        }
        object_110.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_tags_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateTagsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_113) = &input.tags {
        let mut object_114 = object.key("tags").start_object();
        for (key_115, value_116) in var_113 {
            {
                object_114.key(key_115).string(value_116.as_str());
            }
        }
        object_114.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_purchase_offering_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PurchaseOfferingInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    {
        object.key("count").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.count).into()),
        );
    }
    if let Some(var_117) = &input.name {
        object.key("name").string(var_117.as_str());
    }
    if let Some(var_118) = &input.request_id {
        object.key("requestId").string(var_118.as_str());
    }
    if let Some(var_119) = &input.start {
        object.key("start").string(var_119.as_str());
    }
    if let Some(var_120) = &input.tags {
        let mut object_121 = object.key("tags").start_object();
        for (key_122, value_123) in var_120 {
            {
                object_121.key(key_122).string(value_123.as_str());
            }
        }
        object_121.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_transfer_input_device_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::TransferInputDeviceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_124) = &input.target_customer_id {
        object.key("targetCustomerId").string(var_124.as_str());
    }
    if let Some(var_125) = &input.target_region {
        object.key("targetRegion").string(var_125.as_str());
    }
    if let Some(var_126) = &input.transfer_message {
        object.key("transferMessage").string(var_126.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_channel_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateChannelInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_127) = &input.cdi_input_specification {
        let mut object_128 = object.key("cdiInputSpecification").start_object();
        crate::json_ser::serialize_structure_crate_model_cdi_input_specification(
            &mut object_128,
            var_127,
        )?;
        object_128.finish();
    }
    if let Some(var_129) = &input.destinations {
        let mut array_130 = object.key("destinations").start_array();
        for item_131 in var_129 {
            {
                let mut object_132 = array_130.value().start_object();
                crate::json_ser::serialize_structure_crate_model_output_destination(
                    &mut object_132,
                    item_131,
                )?;
                object_132.finish();
            }
        }
        array_130.finish();
    }
    if let Some(var_133) = &input.encoder_settings {
        let mut object_134 = object.key("encoderSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_encoder_settings(
            &mut object_134,
            var_133,
        )?;
        object_134.finish();
    }
    if let Some(var_135) = &input.input_attachments {
        let mut array_136 = object.key("inputAttachments").start_array();
        for item_137 in var_135 {
            {
                let mut object_138 = array_136.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_attachment(
                    &mut object_138,
                    item_137,
                )?;
                object_138.finish();
            }
        }
        array_136.finish();
    }
    if let Some(var_139) = &input.input_specification {
        let mut object_140 = object.key("inputSpecification").start_object();
        crate::json_ser::serialize_structure_crate_model_input_specification(
            &mut object_140,
            var_139,
        )?;
        object_140.finish();
    }
    if let Some(var_141) = &input.log_level {
        object.key("logLevel").string(var_141.as_str());
    }
    if let Some(var_142) = &input.name {
        object.key("name").string(var_142.as_str());
    }
    if let Some(var_143) = &input.role_arn {
        object.key("roleArn").string(var_143.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_channel_class_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateChannelClassInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_144) = &input.channel_class {
        object.key("channelClass").string(var_144.as_str());
    }
    if let Some(var_145) = &input.destinations {
        let mut array_146 = object.key("destinations").start_array();
        for item_147 in var_145 {
            {
                let mut object_148 = array_146.value().start_object();
                crate::json_ser::serialize_structure_crate_model_output_destination(
                    &mut object_148,
                    item_147,
                )?;
                object_148.finish();
            }
        }
        array_146.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_input_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateInputInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_149) = &input.destinations {
        let mut array_150 = object.key("destinations").start_array();
        for item_151 in var_149 {
            {
                let mut object_152 = array_150.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_destination_request(
                    &mut object_152,
                    item_151,
                )?;
                object_152.finish();
            }
        }
        array_150.finish();
    }
    if let Some(var_153) = &input.input_devices {
        let mut array_154 = object.key("inputDevices").start_array();
        for item_155 in var_153 {
            {
                let mut object_156 = array_154.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_device_request(
                    &mut object_156,
                    item_155,
                )?;
                object_156.finish();
            }
        }
        array_154.finish();
    }
    if let Some(var_157) = &input.input_security_groups {
        let mut array_158 = object.key("inputSecurityGroups").start_array();
        for item_159 in var_157 {
            {
                array_158.value().string(item_159.as_str());
            }
        }
        array_158.finish();
    }
    if let Some(var_160) = &input.media_connect_flows {
        let mut array_161 = object.key("mediaConnectFlows").start_array();
        for item_162 in var_160 {
            {
                let mut object_163 = array_161.value().start_object();
                crate::json_ser::serialize_structure_crate_model_media_connect_flow_request(
                    &mut object_163,
                    item_162,
                )?;
                object_163.finish();
            }
        }
        array_161.finish();
    }
    if let Some(var_164) = &input.name {
        object.key("name").string(var_164.as_str());
    }
    if let Some(var_165) = &input.role_arn {
        object.key("roleArn").string(var_165.as_str());
    }
    if let Some(var_166) = &input.sources {
        let mut array_167 = object.key("sources").start_array();
        for item_168 in var_166 {
            {
                let mut object_169 = array_167.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_source_request(
                    &mut object_169,
                    item_168,
                )?;
                object_169.finish();
            }
        }
        array_167.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_input_device_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateInputDeviceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_170) = &input.hd_device_settings {
        let mut object_171 = object.key("hdDeviceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_input_device_configurable_settings(
            &mut object_171,
            var_170,
        )?;
        object_171.finish();
    }
    if let Some(var_172) = &input.name {
        object.key("name").string(var_172.as_str());
    }
    if let Some(var_173) = &input.uhd_device_settings {
        let mut object_174 = object.key("uhdDeviceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_input_device_configurable_settings(
            &mut object_174,
            var_173,
        )?;
        object_174.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_input_security_group_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateInputSecurityGroupInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_175) = &input.tags {
        let mut object_176 = object.key("tags").start_object();
        for (key_177, value_178) in var_175 {
            {
                object_176.key(key_177).string(value_178.as_str());
            }
        }
        object_176.finish();
    }
    if let Some(var_179) = &input.whitelist_rules {
        let mut array_180 = object.key("whitelistRules").start_array();
        for item_181 in var_179 {
            {
                let mut object_182 = array_180.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_whitelist_rule_cidr(
                    &mut object_182,
                    item_181,
                )?;
                object_182.finish();
            }
        }
        array_180.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_multiplex_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateMultiplexInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_183) = &input.multiplex_settings {
        let mut object_184 = object.key("multiplexSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_settings(
            &mut object_184,
            var_183,
        )?;
        object_184.finish();
    }
    if let Some(var_185) = &input.name {
        object.key("name").string(var_185.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_multiplex_program_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateMultiplexProgramInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_186) = &input.multiplex_program_settings {
        let mut object_187 = object.key("multiplexProgramSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_program_settings(
            &mut object_187,
            var_186,
        )?;
        object_187.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_reservation_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateReservationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_188) = &input.name {
        object.key("name").string(var_188.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_batch_schedule_action_create_request(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::BatchScheduleActionCreateRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_189) = &input.schedule_actions {
        let mut array_190 = object.key("scheduleActions").start_array();
        for item_191 in var_189 {
            {
                let mut object_192 = array_190.value().start_object();
                crate::json_ser::serialize_structure_crate_model_schedule_action(
                    &mut object_192,
                    item_191,
                )?;
                object_192.finish();
            }
        }
        array_190.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_batch_schedule_action_delete_request(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::BatchScheduleActionDeleteRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_193) = &input.action_names {
        let mut array_194 = object.key("actionNames").start_array();
        for item_195 in var_193 {
            {
                array_194.value().string(item_195.as_str());
            }
        }
        array_194.finish();
    }
    Ok(())
}

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

pub fn serialize_structure_crate_model_output_destination(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::OutputDestination,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_197) = &input.id {
        object.key("id").string(var_197.as_str());
    }
    if let Some(var_198) = &input.media_package_settings {
        let mut array_199 = object.key("mediaPackageSettings").start_array();
        for item_200 in var_198 {
            {
                let mut object_201 = array_199.value().start_object();
                crate::json_ser::serialize_structure_crate_model_media_package_output_destination_settings(&mut object_201, item_200)?;
                object_201.finish();
            }
        }
        array_199.finish();
    }
    if let Some(var_202) = &input.multiplex_settings {
        let mut object_203 = object.key("multiplexSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_program_channel_destination_settings(&mut object_203, var_202)?;
        object_203.finish();
    }
    if let Some(var_204) = &input.settings {
        let mut array_205 = object.key("settings").start_array();
        for item_206 in var_204 {
            {
                let mut object_207 = array_205.value().start_object();
                crate::json_ser::serialize_structure_crate_model_output_destination_settings(
                    &mut object_207,
                    item_206,
                )?;
                object_207.finish();
            }
        }
        array_205.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_encoder_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::EncoderSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_208) = &input.audio_descriptions {
        let mut array_209 = object.key("audioDescriptions").start_array();
        for item_210 in var_208 {
            {
                let mut object_211 = array_209.value().start_object();
                crate::json_ser::serialize_structure_crate_model_audio_description(
                    &mut object_211,
                    item_210,
                )?;
                object_211.finish();
            }
        }
        array_209.finish();
    }
    if let Some(var_212) = &input.avail_blanking {
        let mut object_213 = object.key("availBlanking").start_object();
        crate::json_ser::serialize_structure_crate_model_avail_blanking(&mut object_213, var_212)?;
        object_213.finish();
    }
    if let Some(var_214) = &input.avail_configuration {
        let mut object_215 = object.key("availConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_avail_configuration(
            &mut object_215,
            var_214,
        )?;
        object_215.finish();
    }
    if let Some(var_216) = &input.blackout_slate {
        let mut object_217 = object.key("blackoutSlate").start_object();
        crate::json_ser::serialize_structure_crate_model_blackout_slate(&mut object_217, var_216)?;
        object_217.finish();
    }
    if let Some(var_218) = &input.caption_descriptions {
        let mut array_219 = object.key("captionDescriptions").start_array();
        for item_220 in var_218 {
            {
                let mut object_221 = array_219.value().start_object();
                crate::json_ser::serialize_structure_crate_model_caption_description(
                    &mut object_221,
                    item_220,
                )?;
                object_221.finish();
            }
        }
        array_219.finish();
    }
    if let Some(var_222) = &input.feature_activations {
        let mut object_223 = object.key("featureActivations").start_object();
        crate::json_ser::serialize_structure_crate_model_feature_activations(
            &mut object_223,
            var_222,
        )?;
        object_223.finish();
    }
    if let Some(var_224) = &input.global_configuration {
        let mut object_225 = object.key("globalConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_global_configuration(
            &mut object_225,
            var_224,
        )?;
        object_225.finish();
    }
    if let Some(var_226) = &input.motion_graphics_configuration {
        let mut object_227 = object.key("motionGraphicsConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_motion_graphics_configuration(
            &mut object_227,
            var_226,
        )?;
        object_227.finish();
    }
    if let Some(var_228) = &input.nielsen_configuration {
        let mut object_229 = object.key("nielsenConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_nielsen_configuration(
            &mut object_229,
            var_228,
        )?;
        object_229.finish();
    }
    if let Some(var_230) = &input.output_groups {
        let mut array_231 = object.key("outputGroups").start_array();
        for item_232 in var_230 {
            {
                let mut object_233 = array_231.value().start_object();
                crate::json_ser::serialize_structure_crate_model_output_group(
                    &mut object_233,
                    item_232,
                )?;
                object_233.finish();
            }
        }
        array_231.finish();
    }
    if let Some(var_234) = &input.timecode_config {
        let mut object_235 = object.key("timecodeConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_timecode_config(&mut object_235, var_234)?;
        object_235.finish();
    }
    if let Some(var_236) = &input.video_descriptions {
        let mut array_237 = object.key("videoDescriptions").start_array();
        for item_238 in var_236 {
            {
                let mut object_239 = array_237.value().start_object();
                crate::json_ser::serialize_structure_crate_model_video_description(
                    &mut object_239,
                    item_238,
                )?;
                object_239.finish();
            }
        }
        array_237.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_input_attachment(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::InputAttachment,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_240) = &input.automatic_input_failover_settings {
        let mut object_241 = object.key("automaticInputFailoverSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_automatic_input_failover_settings(
            &mut object_241,
            var_240,
        )?;
        object_241.finish();
    }
    if let Some(var_242) = &input.input_attachment_name {
        object.key("inputAttachmentName").string(var_242.as_str());
    }
    if let Some(var_243) = &input.input_id {
        object.key("inputId").string(var_243.as_str());
    }
    if let Some(var_244) = &input.input_settings {
        let mut object_245 = object.key("inputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_input_settings(&mut object_245, var_244)?;
        object_245.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_input_specification(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::InputSpecification,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_246) = &input.codec {
        object.key("codec").string(var_246.as_str());
    }
    if let Some(var_247) = &input.maximum_bitrate {
        object.key("maximumBitrate").string(var_247.as_str());
    }
    if let Some(var_248) = &input.resolution {
        object.key("resolution").string(var_248.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_vpc_output_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VpcOutputSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_249) = &input.public_address_allocation_ids {
        let mut array_250 = object.key("publicAddressAllocationIds").start_array();
        for item_251 in var_249 {
            {
                array_250.value().string(item_251.as_str());
            }
        }
        array_250.finish();
    }
    if let Some(var_252) = &input.security_group_ids {
        let mut array_253 = object.key("securityGroupIds").start_array();
        for item_254 in var_252 {
            {
                array_253.value().string(item_254.as_str());
            }
        }
        array_253.finish();
    }
    if let Some(var_255) = &input.subnet_ids {
        let mut array_256 = object.key("subnetIds").start_array();
        for item_257 in var_255 {
            {
                array_256.value().string(item_257.as_str());
            }
        }
        array_256.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_input_destination_request(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::InputDestinationRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_258) = &input.stream_name {
        object.key("streamName").string(var_258.as_str());
    }
    Ok(())
}

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

pub fn serialize_structure_crate_model_media_connect_flow_request(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MediaConnectFlowRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_260) = &input.flow_arn {
        object.key("flowArn").string(var_260.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_input_source_request(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::InputSourceRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_261) = &input.password_param {
        object.key("passwordParam").string(var_261.as_str());
    }
    if let Some(var_262) = &input.url {
        object.key("url").string(var_262.as_str());
    }
    if let Some(var_263) = &input.username {
        object.key("username").string(var_263.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_input_vpc_request(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::InputVpcRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_264) = &input.security_group_ids {
        let mut array_265 = object.key("securityGroupIds").start_array();
        for item_266 in var_264 {
            {
                array_265.value().string(item_266.as_str());
            }
        }
        array_265.finish();
    }
    if let Some(var_267) = &input.subnet_ids {
        let mut array_268 = object.key("subnetIds").start_array();
        for item_269 in var_267 {
            {
                array_268.value().string(item_269.as_str());
            }
        }
        array_268.finish();
    }
    Ok(())
}

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

pub fn serialize_structure_crate_model_multiplex_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MultiplexSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.maximum_video_buffer_delay_milliseconds != 0 {
        object.key("maximumVideoBufferDelayMilliseconds").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt(
                (input.maximum_video_buffer_delay_milliseconds).into(),
            ),
        );
    }
    {
        object.key("transportStreamBitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.transport_stream_bitrate).into()),
        );
    }
    {
        object.key("transportStreamId").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.transport_stream_id).into()),
        );
    }
    if input.transport_stream_reserved_bitrate != 0 {
        object.key("transportStreamReservedBitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.transport_stream_reserved_bitrate).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_multiplex_program_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MultiplexProgramSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_271) = &input.preferred_channel_pipeline {
        object
            .key("preferredChannelPipeline")
            .string(var_271.as_str());
    }
    {
        object.key("programNumber").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.program_number).into()),
        );
    }
    if let Some(var_272) = &input.service_descriptor {
        let mut object_273 = object.key("serviceDescriptor").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_program_service_descriptor(
            &mut object_273,
            var_272,
        )?;
        object_273.finish();
    }
    if let Some(var_274) = &input.video_settings {
        let mut object_275 = object.key("videoSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_video_settings(
            &mut object_275,
            var_274,
        )?;
        object_275.finish();
    }
    Ok(())
}

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

pub fn serialize_structure_crate_model_input_device_configurable_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::InputDeviceConfigurableSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_277) = &input.configured_input {
        object.key("configuredInput").string(var_277.as_str());
    }
    if input.max_bitrate != 0 {
        object.key("maxBitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_bitrate).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_schedule_action(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ScheduleAction,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_278) = &input.action_name {
        object.key("actionName").string(var_278.as_str());
    }
    if let Some(var_279) = &input.schedule_action_settings {
        let mut object_280 = object.key("scheduleActionSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_schedule_action_settings(
            &mut object_280,
            var_279,
        )?;
        object_280.finish();
    }
    if let Some(var_281) = &input.schedule_action_start_settings {
        let mut object_282 = object.key("scheduleActionStartSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_schedule_action_start_settings(
            &mut object_282,
            var_281,
        )?;
        object_282.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_media_package_output_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MediaPackageOutputDestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_283) = &input.channel_id {
        object.key("channelId").string(var_283.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_multiplex_program_channel_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MultiplexProgramChannelDestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_284) = &input.multiplex_id {
        object.key("multiplexId").string(var_284.as_str());
    }
    if let Some(var_285) = &input.program_name {
        object.key("programName").string(var_285.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_output_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::OutputDestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_286) = &input.password_param {
        object.key("passwordParam").string(var_286.as_str());
    }
    if let Some(var_287) = &input.stream_name {
        object.key("streamName").string(var_287.as_str());
    }
    if let Some(var_288) = &input.url {
        object.key("url").string(var_288.as_str());
    }
    if let Some(var_289) = &input.username {
        object.key("username").string(var_289.as_str());
    }
    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_290) = &input.audio_normalization_settings {
        let mut object_291 = object.key("audioNormalizationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_normalization_settings(
            &mut object_291,
            var_290,
        )?;
        object_291.finish();
    }
    if let Some(var_292) = &input.audio_selector_name {
        object.key("audioSelectorName").string(var_292.as_str());
    }
    if let Some(var_293) = &input.audio_type {
        object.key("audioType").string(var_293.as_str());
    }
    if let Some(var_294) = &input.audio_type_control {
        object.key("audioTypeControl").string(var_294.as_str());
    }
    if let Some(var_295) = &input.audio_watermarking_settings {
        let mut object_296 = object.key("audioWatermarkingSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_watermark_settings(
            &mut object_296,
            var_295,
        )?;
        object_296.finish();
    }
    if let Some(var_297) = &input.codec_settings {
        let mut object_298 = object.key("codecSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_codec_settings(
            &mut object_298,
            var_297,
        )?;
        object_298.finish();
    }
    if let Some(var_299) = &input.language_code {
        object.key("languageCode").string(var_299.as_str());
    }
    if let Some(var_300) = &input.language_code_control {
        object.key("languageCodeControl").string(var_300.as_str());
    }
    if let Some(var_301) = &input.name {
        object.key("name").string(var_301.as_str());
    }
    if let Some(var_302) = &input.remix_settings {
        let mut object_303 = object.key("remixSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_remix_settings(&mut object_303, var_302)?;
        object_303.finish();
    }
    if let Some(var_304) = &input.stream_name {
        object.key("streamName").string(var_304.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_305) = &input.avail_blanking_image {
        let mut object_306 = object.key("availBlankingImage").start_object();
        crate::json_ser::serialize_structure_crate_model_input_location(&mut object_306, var_305)?;
        object_306.finish();
    }
    if let Some(var_307) = &input.state {
        object.key("state").string(var_307.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_avail_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AvailConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_308) = &input.avail_settings {
        let mut object_309 = object.key("availSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_avail_settings(&mut object_309, var_308)?;
        object_309.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_blackout_slate(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::BlackoutSlate,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_310) = &input.blackout_slate_image {
        let mut object_311 = object.key("blackoutSlateImage").start_object();
        crate::json_ser::serialize_structure_crate_model_input_location(&mut object_311, var_310)?;
        object_311.finish();
    }
    if let Some(var_312) = &input.network_end_blackout {
        object.key("networkEndBlackout").string(var_312.as_str());
    }
    if let Some(var_313) = &input.network_end_blackout_image {
        let mut object_314 = object.key("networkEndBlackoutImage").start_object();
        crate::json_ser::serialize_structure_crate_model_input_location(&mut object_314, var_313)?;
        object_314.finish();
    }
    if let Some(var_315) = &input.network_id {
        object.key("networkId").string(var_315.as_str());
    }
    if let Some(var_316) = &input.state {
        object.key("state").string(var_316.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_317) = &input.caption_selector_name {
        object.key("captionSelectorName").string(var_317.as_str());
    }
    if let Some(var_318) = &input.destination_settings {
        let mut object_319 = object.key("destinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_caption_destination_settings(
            &mut object_319,
            var_318,
        )?;
        object_319.finish();
    }
    if let Some(var_320) = &input.language_code {
        object.key("languageCode").string(var_320.as_str());
    }
    if let Some(var_321) = &input.language_description {
        object.key("languageDescription").string(var_321.as_str());
    }
    if let Some(var_322) = &input.name {
        object.key("name").string(var_322.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_feature_activations(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FeatureActivations,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_323) = &input.input_prepare_schedule_actions {
        object
            .key("inputPrepareScheduleActions")
            .string(var_323.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_global_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GlobalConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.initial_audio_gain != 0 {
        object.key("initialAudioGain").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.initial_audio_gain).into()),
        );
    }
    if let Some(var_324) = &input.input_end_action {
        object.key("inputEndAction").string(var_324.as_str());
    }
    if let Some(var_325) = &input.input_loss_behavior {
        let mut object_326 = object.key("inputLossBehavior").start_object();
        crate::json_ser::serialize_structure_crate_model_input_loss_behavior(
            &mut object_326,
            var_325,
        )?;
        object_326.finish();
    }
    if let Some(var_327) = &input.output_locking_mode {
        object.key("outputLockingMode").string(var_327.as_str());
    }
    if let Some(var_328) = &input.output_timing_source {
        object.key("outputTimingSource").string(var_328.as_str());
    }
    if let Some(var_329) = &input.support_low_framerate_inputs {
        object
            .key("supportLowFramerateInputs")
            .string(var_329.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_motion_graphics_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MotionGraphicsConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_330) = &input.motion_graphics_insertion {
        object
            .key("motionGraphicsInsertion")
            .string(var_330.as_str());
    }
    if let Some(var_331) = &input.motion_graphics_settings {
        let mut object_332 = object.key("motionGraphicsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_motion_graphics_settings(
            &mut object_332,
            var_331,
        )?;
        object_332.finish();
    }
    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 let Some(var_333) = &input.distributor_id {
        object.key("distributorId").string(var_333.as_str());
    }
    if let Some(var_334) = &input.nielsen_pcm_to_id3_tagging {
        object
            .key("nielsenPcmToId3Tagging")
            .string(var_334.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_335) = &input.name {
        object.key("name").string(var_335.as_str());
    }
    if let Some(var_336) = &input.output_group_settings {
        let mut object_337 = object.key("outputGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_output_group_settings(
            &mut object_337,
            var_336,
        )?;
        object_337.finish();
    }
    if let Some(var_338) = &input.outputs {
        let mut array_339 = object.key("outputs").start_array();
        for item_340 in var_338 {
            {
                let mut object_341 = array_339.value().start_object();
                crate::json_ser::serialize_structure_crate_model_output(&mut object_341, item_340)?;
                object_341.finish();
            }
        }
        array_339.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_342) = &input.source {
        object.key("source").string(var_342.as_str());
    }
    if input.sync_threshold != 0 {
        object.key("syncThreshold").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.sync_threshold).into()),
        );
    }
    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_343) = &input.codec_settings {
        let mut object_344 = object.key("codecSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_video_codec_settings(
            &mut object_344,
            var_343,
        )?;
        object_344.finish();
    }
    if input.height != 0 {
        object.key("height").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.height).into()),
        );
    }
    if let Some(var_345) = &input.name {
        object.key("name").string(var_345.as_str());
    }
    if let Some(var_346) = &input.respond_to_afd {
        object.key("respondToAfd").string(var_346.as_str());
    }
    if let Some(var_347) = &input.scaling_behavior {
        object.key("scalingBehavior").string(var_347.as_str());
    }
    if input.sharpness != 0 {
        object.key("sharpness").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.sharpness).into()),
        );
    }
    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_automatic_input_failover_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AutomaticInputFailoverSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.error_clear_time_msec != 0 {
        object.key("errorClearTimeMsec").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.error_clear_time_msec).into()),
        );
    }
    if let Some(var_348) = &input.failover_conditions {
        let mut array_349 = object.key("failoverConditions").start_array();
        for item_350 in var_348 {
            {
                let mut object_351 = array_349.value().start_object();
                crate::json_ser::serialize_structure_crate_model_failover_condition(
                    &mut object_351,
                    item_350,
                )?;
                object_351.finish();
            }
        }
        array_349.finish();
    }
    if let Some(var_352) = &input.input_preference {
        object.key("inputPreference").string(var_352.as_str());
    }
    if let Some(var_353) = &input.secondary_input_id {
        object.key("secondaryInputId").string(var_353.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_input_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::InputSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_354) = &input.audio_selectors {
        let mut array_355 = object.key("audioSelectors").start_array();
        for item_356 in var_354 {
            {
                let mut object_357 = array_355.value().start_object();
                crate::json_ser::serialize_structure_crate_model_audio_selector(
                    &mut object_357,
                    item_356,
                )?;
                object_357.finish();
            }
        }
        array_355.finish();
    }
    if let Some(var_358) = &input.caption_selectors {
        let mut array_359 = object.key("captionSelectors").start_array();
        for item_360 in var_358 {
            {
                let mut object_361 = array_359.value().start_object();
                crate::json_ser::serialize_structure_crate_model_caption_selector(
                    &mut object_361,
                    item_360,
                )?;
                object_361.finish();
            }
        }
        array_359.finish();
    }
    if let Some(var_362) = &input.deblock_filter {
        object.key("deblockFilter").string(var_362.as_str());
    }
    if let Some(var_363) = &input.denoise_filter {
        object.key("denoiseFilter").string(var_363.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_364) = &input.input_filter {
        object.key("inputFilter").string(var_364.as_str());
    }
    if let Some(var_365) = &input.network_input_settings {
        let mut object_366 = object.key("networkInputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_network_input_settings(
            &mut object_366,
            var_365,
        )?;
        object_366.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_367) = &input.smpte2038_data_preference {
        object
            .key("smpte2038DataPreference")
            .string(var_367.as_str());
    }
    if let Some(var_368) = &input.source_end_behavior {
        object.key("sourceEndBehavior").string(var_368.as_str());
    }
    if let Some(var_369) = &input.video_selector {
        let mut object_370 = object.key("videoSelector").start_object();
        crate::json_ser::serialize_structure_crate_model_video_selector(&mut object_370, var_369)?;
        object_370.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_multiplex_program_service_descriptor(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MultiplexProgramServiceDescriptor,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_371) = &input.provider_name {
        object.key("providerName").string(var_371.as_str());
    }
    if let Some(var_372) = &input.service_name {
        object.key("serviceName").string(var_372.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_multiplex_video_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MultiplexVideoSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.constant_bitrate != 0 {
        object.key("constantBitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.constant_bitrate).into()),
        );
    }
    if let Some(var_373) = &input.statmux_settings {
        let mut object_374 = object.key("statmuxSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_statmux_video_settings(
            &mut object_374,
            var_373,
        )?;
        object_374.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_schedule_action_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ScheduleActionSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_375) = &input.hls_id3_segment_tagging_settings {
        let mut object_376 = object.key("hlsId3SegmentTaggingSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_id3_segment_tagging_schedule_action_settings(&mut object_376, var_375)?;
        object_376.finish();
    }
    if let Some(var_377) = &input.hls_timed_metadata_settings {
        let mut object_378 = object.key("hlsTimedMetadataSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_timed_metadata_schedule_action_settings(&mut object_378, var_377)?;
        object_378.finish();
    }
    if let Some(var_379) = &input.input_prepare_settings {
        let mut object_380 = object.key("inputPrepareSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_input_prepare_schedule_action_settings(
            &mut object_380,
            var_379,
        )?;
        object_380.finish();
    }
    if let Some(var_381) = &input.input_switch_settings {
        let mut object_382 = object.key("inputSwitchSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_input_switch_schedule_action_settings(
            &mut object_382,
            var_381,
        )?;
        object_382.finish();
    }
    if let Some(var_383) = &input.motion_graphics_image_activate_settings {
        let mut object_384 = object
            .key("motionGraphicsImageActivateSettings")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_motion_graphics_activate_schedule_action_settings(&mut object_384, var_383)?;
        object_384.finish();
    }
    if let Some(var_385) = &input.motion_graphics_image_deactivate_settings {
        let mut object_386 = object
            .key("motionGraphicsImageDeactivateSettings")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_motion_graphics_deactivate_schedule_action_settings(&mut object_386, var_385)?;
        object_386.finish();
    }
    if let Some(var_387) = &input.pause_state_settings {
        let mut object_388 = object.key("pauseStateSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_pause_state_schedule_action_settings(
            &mut object_388,
            var_387,
        )?;
        object_388.finish();
    }
    if let Some(var_389) = &input.scte35_return_to_network_settings {
        let mut object_390 = object.key("scte35ReturnToNetworkSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_scte35_return_to_network_schedule_action_settings(&mut object_390, var_389)?;
        object_390.finish();
    }
    if let Some(var_391) = &input.scte35_splice_insert_settings {
        let mut object_392 = object.key("scte35SpliceInsertSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_scte35_splice_insert_schedule_action_settings(&mut object_392, var_391)?;
        object_392.finish();
    }
    if let Some(var_393) = &input.scte35_time_signal_settings {
        let mut object_394 = object.key("scte35TimeSignalSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_scte35_time_signal_schedule_action_settings(&mut object_394, var_393)?;
        object_394.finish();
    }
    if let Some(var_395) = &input.static_image_activate_settings {
        let mut object_396 = object.key("staticImageActivateSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_static_image_activate_schedule_action_settings(&mut object_396, var_395)?;
        object_396.finish();
    }
    if let Some(var_397) = &input.static_image_deactivate_settings {
        let mut object_398 = object.key("staticImageDeactivateSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_static_image_deactivate_schedule_action_settings(&mut object_398, var_397)?;
        object_398.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_schedule_action_start_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ScheduleActionStartSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_399) = &input.fixed_mode_schedule_action_start_settings {
        let mut object_400 = object
            .key("fixedModeScheduleActionStartSettings")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_fixed_mode_schedule_action_start_settings(
            &mut object_400,
            var_399,
        )?;
        object_400.finish();
    }
    if let Some(var_401) = &input.follow_mode_schedule_action_start_settings {
        let mut object_402 = object
            .key("followModeScheduleActionStartSettings")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_follow_mode_schedule_action_start_settings(&mut object_402, var_401)?;
        object_402.finish();
    }
    if let Some(var_403) = &input.immediate_mode_schedule_action_start_settings {
        let mut object_404 = object
            .key("immediateModeScheduleActionStartSettings")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_immediate_mode_schedule_action_start_settings(&mut object_404, var_403)?;
        object_404.finish();
    }
    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_405) = &input.algorithm {
        object.key("algorithm").string(var_405.as_str());
    }
    if let Some(var_406) = &input.algorithm_control {
        object.key("algorithmControl").string(var_406.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_watermark_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AudioWatermarkSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_407) = &input.nielsen_watermarks_settings {
        let mut object_408 = object.key("nielsenWatermarksSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_nielsen_watermarks_settings(
            &mut object_408,
            var_407,
        )?;
        object_408.finish();
    }
    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_409) = &input.aac_settings {
        let mut object_410 = object.key("aacSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_aac_settings(&mut object_410, var_409)?;
        object_410.finish();
    }
    if let Some(var_411) = &input.ac3_settings {
        let mut object_412 = object.key("ac3Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_ac3_settings(&mut object_412, var_411)?;
        object_412.finish();
    }
    if let Some(var_413) = &input.eac3_settings {
        let mut object_414 = object.key("eac3Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_eac3_settings(&mut object_414, var_413)?;
        object_414.finish();
    }
    if let Some(var_415) = &input.mp2_settings {
        let mut object_416 = object.key("mp2Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_mp2_settings(&mut object_416, var_415)?;
        object_416.finish();
    }
    if let Some(var_417) = &input.pass_through_settings {
        let mut object_418 = object.key("passThroughSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_pass_through_settings(
            &mut object_418,
            var_417,
        )?;
        object_418.finish();
    }
    if let Some(var_419) = &input.wav_settings {
        let mut object_420 = object.key("wavSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_wav_settings(&mut object_420, var_419)?;
        object_420.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_421) = &input.channel_mappings {
        let mut array_422 = object.key("channelMappings").start_array();
        for item_423 in var_421 {
            {
                let mut object_424 = array_422.value().start_object();
                crate::json_ser::serialize_structure_crate_model_audio_channel_mapping(
                    &mut object_424,
                    item_423,
                )?;
                object_424.finish();
            }
        }
        array_422.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_input_location(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::InputLocation,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_425) = &input.password_param {
        object.key("passwordParam").string(var_425.as_str());
    }
    if let Some(var_426) = &input.uri {
        object.key("uri").string(var_426.as_str());
    }
    if let Some(var_427) = &input.username {
        object.key("username").string(var_427.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_avail_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AvailSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_428) = &input.scte35_splice_insert {
        let mut object_429 = object.key("scte35SpliceInsert").start_object();
        crate::json_ser::serialize_structure_crate_model_scte35_splice_insert(
            &mut object_429,
            var_428,
        )?;
        object_429.finish();
    }
    if let Some(var_430) = &input.scte35_time_signal_apos {
        let mut object_431 = object.key("scte35TimeSignalApos").start_object();
        crate::json_ser::serialize_structure_crate_model_scte35_time_signal_apos(
            &mut object_431,
            var_430,
        )?;
        object_431.finish();
    }
    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_432) = &input.arib_destination_settings {
        let mut object_433 = object.key("aribDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_arib_destination_settings(
            &mut object_433,
            var_432,
        )?;
        object_433.finish();
    }
    if let Some(var_434) = &input.burn_in_destination_settings {
        let mut object_435 = object.key("burnInDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_burn_in_destination_settings(
            &mut object_435,
            var_434,
        )?;
        object_435.finish();
    }
    if let Some(var_436) = &input.dvb_sub_destination_settings {
        let mut object_437 = object.key("dvbSubDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_dvb_sub_destination_settings(
            &mut object_437,
            var_436,
        )?;
        object_437.finish();
    }
    if let Some(var_438) = &input.ebu_tt_d_destination_settings {
        let mut object_439 = object.key("ebuTtDDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_ebu_tt_d_destination_settings(
            &mut object_439,
            var_438,
        )?;
        object_439.finish();
    }
    if let Some(var_440) = &input.embedded_destination_settings {
        let mut object_441 = object.key("embeddedDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_embedded_destination_settings(
            &mut object_441,
            var_440,
        )?;
        object_441.finish();
    }
    if let Some(var_442) = &input.embedded_plus_scte20_destination_settings {
        let mut object_443 = object
            .key("embeddedPlusScte20DestinationSettings")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_embedded_plus_scte20_destination_settings(
            &mut object_443,
            var_442,
        )?;
        object_443.finish();
    }
    if let Some(var_444) = &input.rtmp_caption_info_destination_settings {
        let mut object_445 = object
            .key("rtmpCaptionInfoDestinationSettings")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_rtmp_caption_info_destination_settings(
            &mut object_445,
            var_444,
        )?;
        object_445.finish();
    }
    if let Some(var_446) = &input.scte20_plus_embedded_destination_settings {
        let mut object_447 = object
            .key("scte20PlusEmbeddedDestinationSettings")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_scte20_plus_embedded_destination_settings(
            &mut object_447,
            var_446,
        )?;
        object_447.finish();
    }
    if let Some(var_448) = &input.scte27_destination_settings {
        let mut object_449 = object.key("scte27DestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_scte27_destination_settings(
            &mut object_449,
            var_448,
        )?;
        object_449.finish();
    }
    if let Some(var_450) = &input.smpte_tt_destination_settings {
        let mut object_451 = object.key("smpteTtDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_smpte_tt_destination_settings(
            &mut object_451,
            var_450,
        )?;
        object_451.finish();
    }
    if let Some(var_452) = &input.teletext_destination_settings {
        let mut object_453 = object.key("teletextDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_teletext_destination_settings(
            &mut object_453,
            var_452,
        )?;
        object_453.finish();
    }
    if let Some(var_454) = &input.ttml_destination_settings {
        let mut object_455 = object.key("ttmlDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_ttml_destination_settings(
            &mut object_455,
            var_454,
        )?;
        object_455.finish();
    }
    if let Some(var_456) = &input.webvtt_destination_settings {
        let mut object_457 = object.key("webvttDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_webvtt_destination_settings(
            &mut object_457,
            var_456,
        )?;
        object_457.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_input_loss_behavior(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::InputLossBehavior,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.black_frame_msec != 0 {
        object.key("blackFrameMsec").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.black_frame_msec).into()),
        );
    }
    if let Some(var_458) = &input.input_loss_image_color {
        object.key("inputLossImageColor").string(var_458.as_str());
    }
    if let Some(var_459) = &input.input_loss_image_slate {
        let mut object_460 = object.key("inputLossImageSlate").start_object();
        crate::json_ser::serialize_structure_crate_model_input_location(&mut object_460, var_459)?;
        object_460.finish();
    }
    if let Some(var_461) = &input.input_loss_image_type {
        object.key("inputLossImageType").string(var_461.as_str());
    }
    if input.repeat_frame_msec != 0 {
        object.key("repeatFrameMsec").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.repeat_frame_msec).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_motion_graphics_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MotionGraphicsSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_462) = &input.html_motion_graphics_settings {
        let mut object_463 = object.key("htmlMotionGraphicsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_html_motion_graphics_settings(
            &mut object_463,
            var_462,
        )?;
        object_463.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_464) = &input.archive_group_settings {
        let mut object_465 = object.key("archiveGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_archive_group_settings(
            &mut object_465,
            var_464,
        )?;
        object_465.finish();
    }
    if let Some(var_466) = &input.frame_capture_group_settings {
        let mut object_467 = object.key("frameCaptureGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_frame_capture_group_settings(
            &mut object_467,
            var_466,
        )?;
        object_467.finish();
    }
    if let Some(var_468) = &input.hls_group_settings {
        let mut object_469 = object.key("hlsGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_group_settings(
            &mut object_469,
            var_468,
        )?;
        object_469.finish();
    }
    if let Some(var_470) = &input.media_package_group_settings {
        let mut object_471 = object.key("mediaPackageGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_media_package_group_settings(
            &mut object_471,
            var_470,
        )?;
        object_471.finish();
    }
    if let Some(var_472) = &input.ms_smooth_group_settings {
        let mut object_473 = object.key("msSmoothGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_ms_smooth_group_settings(
            &mut object_473,
            var_472,
        )?;
        object_473.finish();
    }
    if let Some(var_474) = &input.multiplex_group_settings {
        let mut object_475 = object.key("multiplexGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_group_settings(
            &mut object_475,
            var_474,
        )?;
        object_475.finish();
    }
    if let Some(var_476) = &input.rtmp_group_settings {
        let mut object_477 = object.key("rtmpGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_rtmp_group_settings(
            &mut object_477,
            var_476,
        )?;
        object_477.finish();
    }
    if let Some(var_478) = &input.udp_group_settings {
        let mut object_479 = object.key("udpGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_udp_group_settings(
            &mut object_479,
            var_478,
        )?;
        object_479.finish();
    }
    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_480) = &input.audio_description_names {
        let mut array_481 = object.key("audioDescriptionNames").start_array();
        for item_482 in var_480 {
            {
                array_481.value().string(item_482.as_str());
            }
        }
        array_481.finish();
    }
    if let Some(var_483) = &input.caption_description_names {
        let mut array_484 = object.key("captionDescriptionNames").start_array();
        for item_485 in var_483 {
            {
                array_484.value().string(item_485.as_str());
            }
        }
        array_484.finish();
    }
    if let Some(var_486) = &input.output_name {
        object.key("outputName").string(var_486.as_str());
    }
    if let Some(var_487) = &input.output_settings {
        let mut object_488 = object.key("outputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_output_settings(&mut object_488, var_487)?;
        object_488.finish();
    }
    if let Some(var_489) = &input.video_description_name {
        object.key("videoDescriptionName").string(var_489.as_str());
    }
    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_490) = &input.frame_capture_settings {
        let mut object_491 = object.key("frameCaptureSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_frame_capture_settings(
            &mut object_491,
            var_490,
        )?;
        object_491.finish();
    }
    if let Some(var_492) = &input.h264_settings {
        let mut object_493 = object.key("h264Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_h264_settings(&mut object_493, var_492)?;
        object_493.finish();
    }
    if let Some(var_494) = &input.h265_settings {
        let mut object_495 = object.key("h265Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_h265_settings(&mut object_495, var_494)?;
        object_495.finish();
    }
    if let Some(var_496) = &input.mpeg2_settings {
        let mut object_497 = object.key("mpeg2Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_mpeg2_settings(&mut object_497, var_496)?;
        object_497.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_failover_condition(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FailoverCondition,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_498) = &input.failover_condition_settings {
        let mut object_499 = object.key("failoverConditionSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_failover_condition_settings(
            &mut object_499,
            var_498,
        )?;
        object_499.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_500) = &input.name {
        object.key("name").string(var_500.as_str());
    }
    if let Some(var_501) = &input.selector_settings {
        let mut object_502 = object.key("selectorSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_selector_settings(
            &mut object_502,
            var_501,
        )?;
        object_502.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_503) = &input.language_code {
        object.key("languageCode").string(var_503.as_str());
    }
    if let Some(var_504) = &input.name {
        object.key("name").string(var_504.as_str());
    }
    if let Some(var_505) = &input.selector_settings {
        let mut object_506 = object.key("selectorSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_caption_selector_settings(
            &mut object_506,
            var_505,
        )?;
        object_506.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_network_input_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NetworkInputSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_507) = &input.hls_input_settings {
        let mut object_508 = object.key("hlsInputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_input_settings(
            &mut object_508,
            var_507,
        )?;
        object_508.finish();
    }
    if let Some(var_509) = &input.server_validation {
        object.key("serverValidation").string(var_509.as_str());
    }
    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_510) = &input.color_space {
        object.key("colorSpace").string(var_510.as_str());
    }
    if let Some(var_511) = &input.color_space_settings {
        let mut object_512 = object.key("colorSpaceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_video_selector_color_space_settings(
            &mut object_512,
            var_511,
        )?;
        object_512.finish();
    }
    if let Some(var_513) = &input.color_space_usage {
        object.key("colorSpaceUsage").string(var_513.as_str());
    }
    if let Some(var_514) = &input.selector_settings {
        let mut object_515 = object.key("selectorSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_video_selector_settings(
            &mut object_515,
            var_514,
        )?;
        object_515.finish();
    }
    Ok(())
}

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

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

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

pub fn serialize_structure_crate_model_input_prepare_schedule_action_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::InputPrepareScheduleActionSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_518) = &input.input_attachment_name_reference {
        object
            .key("inputAttachmentNameReference")
            .string(var_518.as_str());
    }
    if let Some(var_519) = &input.input_clipping_settings {
        let mut object_520 = object.key("inputClippingSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_input_clipping_settings(
            &mut object_520,
            var_519,
        )?;
        object_520.finish();
    }
    if let Some(var_521) = &input.url_path {
        let mut array_522 = object.key("urlPath").start_array();
        for item_523 in var_521 {
            {
                array_522.value().string(item_523.as_str());
            }
        }
        array_522.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_input_switch_schedule_action_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::InputSwitchScheduleActionSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_524) = &input.input_attachment_name_reference {
        object
            .key("inputAttachmentNameReference")
            .string(var_524.as_str());
    }
    if let Some(var_525) = &input.input_clipping_settings {
        let mut object_526 = object.key("inputClippingSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_input_clipping_settings(
            &mut object_526,
            var_525,
        )?;
        object_526.finish();
    }
    if let Some(var_527) = &input.url_path {
        let mut array_528 = object.key("urlPath").start_array();
        for item_529 in var_527 {
            {
                array_528.value().string(item_529.as_str());
            }
        }
        array_528.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_motion_graphics_activate_schedule_action_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MotionGraphicsActivateScheduleActionSettings,
) -> 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 let Some(var_530) = &input.password_param {
        object.key("passwordParam").string(var_530.as_str());
    }
    if let Some(var_531) = &input.url {
        object.key("url").string(var_531.as_str());
    }
    if let Some(var_532) = &input.username {
        object.key("username").string(var_532.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_motion_graphics_deactivate_schedule_action_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MotionGraphicsDeactivateScheduleActionSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    Ok(())
}

pub fn serialize_structure_crate_model_pause_state_schedule_action_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::PauseStateScheduleActionSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_533) = &input.pipelines {
        let mut array_534 = object.key("pipelines").start_array();
        for item_535 in var_533 {
            {
                let mut object_536 = array_534.value().start_object();
                crate::json_ser::serialize_structure_crate_model_pipeline_pause_state_settings(
                    &mut object_536,
                    item_535,
                )?;
                object_536.finish();
            }
        }
        array_534.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_scte35_return_to_network_schedule_action_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Scte35ReturnToNetworkScheduleActionSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    {
        object.key("spliceEventId").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.splice_event_id).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_scte35_splice_insert_schedule_action_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Scte35SpliceInsertScheduleActionSettings,
) -> 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()),
        );
    }
    {
        object.key("spliceEventId").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.splice_event_id).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_scte35_time_signal_schedule_action_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Scte35TimeSignalScheduleActionSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_537) = &input.scte35_descriptors {
        let mut array_538 = object.key("scte35Descriptors").start_array();
        for item_539 in var_537 {
            {
                let mut object_540 = array_538.value().start_object();
                crate::json_ser::serialize_structure_crate_model_scte35_descriptor(
                    &mut object_540,
                    item_539,
                )?;
                object_540.finish();
            }
        }
        array_538.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_static_image_activate_schedule_action_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::StaticImageActivateScheduleActionSettings,
) -> 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_541) = &input.image {
        let mut object_542 = object.key("image").start_object();
        crate::json_ser::serialize_structure_crate_model_input_location(&mut object_542, var_541)?;
        object_542.finish();
    }
    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 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_static_image_deactivate_schedule_action_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::StaticImageDeactivateScheduleActionSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.fade_out != 0 {
        object.key("fadeOut").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.fade_out).into()),
        );
    }
    if input.layer != 0 {
        object.key("layer").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.layer).into()),
        );
    }
    Ok(())
}

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

pub fn serialize_structure_crate_model_follow_mode_schedule_action_start_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FollowModeScheduleActionStartSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_544) = &input.follow_point {
        object.key("followPoint").string(var_544.as_str());
    }
    if let Some(var_545) = &input.reference_action_name {
        object.key("referenceActionName").string(var_545.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_immediate_mode_schedule_action_start_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ImmediateModeScheduleActionStartSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    Ok(())
}

pub fn serialize_structure_crate_model_nielsen_watermarks_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NielsenWatermarksSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_546) = &input.nielsen_cbet_settings {
        let mut object_547 = object.key("nielsenCbetSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_nielsen_cbet(&mut object_547, var_546)?;
        object_547.finish();
    }
    if let Some(var_548) = &input.nielsen_distribution_type {
        object
            .key("nielsenDistributionType")
            .string(var_548.as_str());
    }
    if let Some(var_549) = &input.nielsen_naes_ii_nw_settings {
        let mut object_550 = object.key("nielsenNaesIiNwSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_nielsen_naes_ii_nw(
            &mut object_550,
            var_549,
        )?;
        object_550.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 input.bitrate != 0.0 {
        object.key("bitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.bitrate).into()),
        );
    }
    if let Some(var_551) = &input.coding_mode {
        object.key("codingMode").string(var_551.as_str());
    }
    if let Some(var_552) = &input.input_type {
        object.key("inputType").string(var_552.as_str());
    }
    if let Some(var_553) = &input.profile {
        object.key("profile").string(var_553.as_str());
    }
    if let Some(var_554) = &input.rate_control_mode {
        object.key("rateControlMode").string(var_554.as_str());
    }
    if let Some(var_555) = &input.raw_format {
        object.key("rawFormat").string(var_555.as_str());
    }
    if input.sample_rate != 0.0 {
        object.key("sampleRate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.sample_rate).into()),
        );
    }
    if let Some(var_556) = &input.spec {
        object.key("spec").string(var_556.as_str());
    }
    if let Some(var_557) = &input.vbr_quality {
        object.key("vbrQuality").string(var_557.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.0 {
        object.key("bitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.bitrate).into()),
        );
    }
    if let Some(var_558) = &input.bitstream_mode {
        object.key("bitstreamMode").string(var_558.as_str());
    }
    if let Some(var_559) = &input.coding_mode {
        object.key("codingMode").string(var_559.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_560) = &input.drc_profile {
        object.key("drcProfile").string(var_560.as_str());
    }
    if let Some(var_561) = &input.lfe_filter {
        object.key("lfeFilter").string(var_561.as_str());
    }
    if let Some(var_562) = &input.metadata_control {
        object.key("metadataControl").string(var_562.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_563) = &input.attenuation_control {
        object.key("attenuationControl").string(var_563.as_str());
    }
    if input.bitrate != 0.0 {
        object.key("bitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.bitrate).into()),
        );
    }
    if let Some(var_564) = &input.bitstream_mode {
        object.key("bitstreamMode").string(var_564.as_str());
    }
    if let Some(var_565) = &input.coding_mode {
        object.key("codingMode").string(var_565.as_str());
    }
    if let Some(var_566) = &input.dc_filter {
        object.key("dcFilter").string(var_566.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_567) = &input.drc_line {
        object.key("drcLine").string(var_567.as_str());
    }
    if let Some(var_568) = &input.drc_rf {
        object.key("drcRf").string(var_568.as_str());
    }
    if let Some(var_569) = &input.lfe_control {
        object.key("lfeControl").string(var_569.as_str());
    }
    if let Some(var_570) = &input.lfe_filter {
        object.key("lfeFilter").string(var_570.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_571) = &input.metadata_control {
        object.key("metadataControl").string(var_571.as_str());
    }
    if let Some(var_572) = &input.passthrough_control {
        object.key("passthroughControl").string(var_572.as_str());
    }
    if let Some(var_573) = &input.phase_control {
        object.key("phaseControl").string(var_573.as_str());
    }
    if let Some(var_574) = &input.stereo_downmix {
        object.key("stereoDownmix").string(var_574.as_str());
    }
    if let Some(var_575) = &input.surround_ex_mode {
        object.key("surroundExMode").string(var_575.as_str());
    }
    if let Some(var_576) = &input.surround_mode {
        object.key("surroundMode").string(var_576.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.0 {
        object.key("bitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.bitrate).into()),
        );
    }
    if let Some(var_577) = &input.coding_mode {
        object.key("codingMode").string(var_577.as_str());
    }
    if input.sample_rate != 0.0 {
        object.key("sampleRate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.sample_rate).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_pass_through_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::PassThroughSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    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.0 {
        object.key("bitDepth").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.bit_depth).into()),
        );
    }
    if let Some(var_578) = &input.coding_mode {
        object.key("codingMode").string(var_578.as_str());
    }
    if input.sample_rate != 0.0 {
        object.key("sampleRate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.sample_rate).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_audio_channel_mapping(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AudioChannelMapping,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_579) = &input.input_channel_levels {
        let mut array_580 = object.key("inputChannelLevels").start_array();
        for item_581 in var_579 {
            {
                let mut object_582 = array_580.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_channel_level(
                    &mut object_582,
                    item_581,
                )?;
                object_582.finish();
            }
        }
        array_580.finish();
    }
    {
        object.key("outputChannel").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.output_channel).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_scte35_splice_insert(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Scte35SpliceInsert,
) -> 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_583) = &input.no_regional_blackout_flag {
        object
            .key("noRegionalBlackoutFlag")
            .string(var_583.as_str());
    }
    if let Some(var_584) = &input.web_delivery_allowed_flag {
        object
            .key("webDeliveryAllowedFlag")
            .string(var_584.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_scte35_time_signal_apos(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Scte35TimeSignalApos,
) -> 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_585) = &input.no_regional_blackout_flag {
        object
            .key("noRegionalBlackoutFlag")
            .string(var_585.as_str());
    }
    if let Some(var_586) = &input.web_delivery_allowed_flag {
        object
            .key("webDeliveryAllowedFlag")
            .string(var_586.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_arib_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AribDestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    Ok(())
}

pub fn serialize_structure_crate_model_burn_in_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::BurnInDestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_587) = &input.alignment {
        object.key("alignment").string(var_587.as_str());
    }
    if let Some(var_588) = &input.background_color {
        object.key("backgroundColor").string(var_588.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_589) = &input.font {
        let mut object_590 = object.key("font").start_object();
        crate::json_ser::serialize_structure_crate_model_input_location(&mut object_590, var_589)?;
        object_590.finish();
    }
    if let Some(var_591) = &input.font_color {
        object.key("fontColor").string(var_591.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_592) = &input.font_size {
        object.key("fontSize").string(var_592.as_str());
    }
    if let Some(var_593) = &input.outline_color {
        object.key("outlineColor").string(var_593.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_594) = &input.shadow_color {
        object.key("shadowColor").string(var_594.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_595) = &input.teletext_grid_control {
        object.key("teletextGridControl").string(var_595.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_596) = &input.alignment {
        object.key("alignment").string(var_596.as_str());
    }
    if let Some(var_597) = &input.background_color {
        object.key("backgroundColor").string(var_597.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_598) = &input.font {
        let mut object_599 = object.key("font").start_object();
        crate::json_ser::serialize_structure_crate_model_input_location(&mut object_599, var_598)?;
        object_599.finish();
    }
    if let Some(var_600) = &input.font_color {
        object.key("fontColor").string(var_600.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_601) = &input.font_size {
        object.key("fontSize").string(var_601.as_str());
    }
    if let Some(var_602) = &input.outline_color {
        object.key("outlineColor").string(var_602.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_603) = &input.shadow_color {
        object.key("shadowColor").string(var_603.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_604) = &input.teletext_grid_control {
        object.key("teletextGridControl").string(var_604.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_ebu_tt_d_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::EbuTtDDestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_605) = &input.copyright_holder {
        object.key("copyrightHolder").string(var_605.as_str());
    }
    if let Some(var_606) = &input.fill_line_gap {
        object.key("fillLineGap").string(var_606.as_str());
    }
    if let Some(var_607) = &input.font_family {
        object.key("fontFamily").string(var_607.as_str());
    }
    if let Some(var_608) = &input.style_control {
        object.key("styleControl").string(var_608.as_str());
    }
    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> {
    let (_, _) = (object, input);
    Ok(())
}

pub fn serialize_structure_crate_model_embedded_plus_scte20_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::EmbeddedPlusScte20DestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    Ok(())
}

pub fn serialize_structure_crate_model_rtmp_caption_info_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::RtmpCaptionInfoDestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    Ok(())
}

pub fn serialize_structure_crate_model_scte20_plus_embedded_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Scte20PlusEmbeddedDestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    Ok(())
}

pub fn serialize_structure_crate_model_scte27_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Scte27DestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    Ok(())
}

pub fn serialize_structure_crate_model_smpte_tt_destination_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SmpteTtDestinationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    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> {
    let (_, _) = (object, input);
    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_609) = &input.style_control {
        object.key("styleControl").string(var_609.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_610) = &input.style_control {
        object.key("styleControl").string(var_610.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_html_motion_graphics_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HtmlMotionGraphicsSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    Ok(())
}

pub fn serialize_structure_crate_model_archive_group_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ArchiveGroupSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_611) = &input.archive_cdn_settings {
        let mut object_612 = object.key("archiveCdnSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_archive_cdn_settings(
            &mut object_612,
            var_611,
        )?;
        object_612.finish();
    }
    if let Some(var_613) = &input.destination {
        let mut object_614 = object.key("destination").start_object();
        crate::json_ser::serialize_structure_crate_model_output_location_ref(
            &mut object_614,
            var_613,
        )?;
        object_614.finish();
    }
    if input.rollover_interval != 0 {
        object.key("rolloverInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.rollover_interval).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_frame_capture_group_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FrameCaptureGroupSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_615) = &input.destination {
        let mut object_616 = object.key("destination").start_object();
        crate::json_ser::serialize_structure_crate_model_output_location_ref(
            &mut object_616,
            var_615,
        )?;
        object_616.finish();
    }
    if let Some(var_617) = &input.frame_capture_cdn_settings {
        let mut object_618 = object.key("frameCaptureCdnSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_frame_capture_cdn_settings(
            &mut object_618,
            var_617,
        )?;
        object_618.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_619) = &input.ad_markers {
        let mut array_620 = object.key("adMarkers").start_array();
        for item_621 in var_619 {
            {
                array_620.value().string(item_621.as_str());
            }
        }
        array_620.finish();
    }
    if let Some(var_622) = &input.base_url_content {
        object.key("baseUrlContent").string(var_622.as_str());
    }
    if let Some(var_623) = &input.base_url_content1 {
        object.key("baseUrlContent1").string(var_623.as_str());
    }
    if let Some(var_624) = &input.base_url_manifest {
        object.key("baseUrlManifest").string(var_624.as_str());
    }
    if let Some(var_625) = &input.base_url_manifest1 {
        object.key("baseUrlManifest1").string(var_625.as_str());
    }
    if let Some(var_626) = &input.caption_language_mappings {
        let mut array_627 = object.key("captionLanguageMappings").start_array();
        for item_628 in var_626 {
            {
                let mut object_629 = array_627.value().start_object();
                crate::json_ser::serialize_structure_crate_model_caption_language_mapping(
                    &mut object_629,
                    item_628,
                )?;
                object_629.finish();
            }
        }
        array_627.finish();
    }
    if let Some(var_630) = &input.caption_language_setting {
        object
            .key("captionLanguageSetting")
            .string(var_630.as_str());
    }
    if let Some(var_631) = &input.client_cache {
        object.key("clientCache").string(var_631.as_str());
    }
    if let Some(var_632) = &input.codec_specification {
        object.key("codecSpecification").string(var_632.as_str());
    }
    if let Some(var_633) = &input.constant_iv {
        object.key("constantIv").string(var_633.as_str());
    }
    if let Some(var_634) = &input.destination {
        let mut object_635 = object.key("destination").start_object();
        crate::json_ser::serialize_structure_crate_model_output_location_ref(
            &mut object_635,
            var_634,
        )?;
        object_635.finish();
    }
    if let Some(var_636) = &input.directory_structure {
        object.key("directoryStructure").string(var_636.as_str());
    }
    if let Some(var_637) = &input.discontinuity_tags {
        object.key("discontinuityTags").string(var_637.as_str());
    }
    if let Some(var_638) = &input.encryption_type {
        object.key("encryptionType").string(var_638.as_str());
    }
    if let Some(var_639) = &input.hls_cdn_settings {
        let mut object_640 = object.key("hlsCdnSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_cdn_settings(
            &mut object_640,
            var_639,
        )?;
        object_640.finish();
    }
    if let Some(var_641) = &input.hls_id3_segment_tagging {
        object.key("hlsId3SegmentTagging").string(var_641.as_str());
    }
    if let Some(var_642) = &input.i_frame_only_playlists {
        object.key("iFrameOnlyPlaylists").string(var_642.as_str());
    }
    if let Some(var_643) = &input.incomplete_segment_behavior {
        object
            .key("incompleteSegmentBehavior")
            .string(var_643.as_str());
    }
    if input.index_n_segments != 0 {
        object.key("indexNSegments").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.index_n_segments).into()),
        );
    }
    if let Some(var_644) = &input.input_loss_action {
        object.key("inputLossAction").string(var_644.as_str());
    }
    if let Some(var_645) = &input.iv_in_manifest {
        object.key("ivInManifest").string(var_645.as_str());
    }
    if let Some(var_646) = &input.iv_source {
        object.key("ivSource").string(var_646.as_str());
    }
    if input.keep_segments != 0 {
        object.key("keepSegments").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.keep_segments).into()),
        );
    }
    if let Some(var_647) = &input.key_format {
        object.key("keyFormat").string(var_647.as_str());
    }
    if let Some(var_648) = &input.key_format_versions {
        object.key("keyFormatVersions").string(var_648.as_str());
    }
    if let Some(var_649) = &input.key_provider_settings {
        let mut object_650 = object.key("keyProviderSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_key_provider_settings(
            &mut object_650,
            var_649,
        )?;
        object_650.finish();
    }
    if let Some(var_651) = &input.manifest_compression {
        object.key("manifestCompression").string(var_651.as_str());
    }
    if let Some(var_652) = &input.manifest_duration_format {
        object
            .key("manifestDurationFormat")
            .string(var_652.as_str());
    }
    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_653) = &input.mode {
        object.key("mode").string(var_653.as_str());
    }
    if let Some(var_654) = &input.output_selection {
        object.key("outputSelection").string(var_654.as_str());
    }
    if let Some(var_655) = &input.program_date_time {
        object.key("programDateTime").string(var_655.as_str());
    }
    if let Some(var_656) = &input.program_date_time_clock {
        object.key("programDateTimeClock").string(var_656.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_657) = &input.redundant_manifest {
        object.key("redundantManifest").string(var_657.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_658) = &input.segmentation_mode {
        object.key("segmentationMode").string(var_658.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_659) = &input.stream_inf_resolution {
        object.key("streamInfResolution").string(var_659.as_str());
    }
    if let Some(var_660) = &input.timed_metadata_id3_frame {
        object.key("timedMetadataId3Frame").string(var_660.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()),
        );
    }
    if let Some(var_661) = &input.ts_file_mode {
        object.key("tsFileMode").string(var_661.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_media_package_group_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MediaPackageGroupSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_662) = &input.destination {
        let mut object_663 = object.key("destination").start_object();
        crate::json_ser::serialize_structure_crate_model_output_location_ref(
            &mut object_663,
            var_662,
        )?;
        object_663.finish();
    }
    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_664) = &input.acquisition_point_id {
        object.key("acquisitionPointId").string(var_664.as_str());
    }
    if let Some(var_665) = &input.audio_only_timecode_control {
        object
            .key("audioOnlyTimecodeControl")
            .string(var_665.as_str());
    }
    if let Some(var_666) = &input.certificate_mode {
        object.key("certificateMode").string(var_666.as_str());
    }
    if input.connection_retry_interval != 0 {
        object.key("connectionRetryInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.connection_retry_interval).into()),
        );
    }
    if let Some(var_667) = &input.destination {
        let mut object_668 = object.key("destination").start_object();
        crate::json_ser::serialize_structure_crate_model_output_location_ref(
            &mut object_668,
            var_667,
        )?;
        object_668.finish();
    }
    if let Some(var_669) = &input.event_id {
        object.key("eventId").string(var_669.as_str());
    }
    if let Some(var_670) = &input.event_id_mode {
        object.key("eventIdMode").string(var_670.as_str());
    }
    if let Some(var_671) = &input.event_stop_behavior {
        object.key("eventStopBehavior").string(var_671.as_str());
    }
    if input.filecache_duration != 0 {
        object.key("filecacheDuration").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.filecache_duration).into()),
        );
    }
    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_672) = &input.input_loss_action {
        object.key("inputLossAction").string(var_672.as_str());
    }
    if input.num_retries != 0 {
        object.key("numRetries").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.num_retries).into()),
        );
    }
    if input.restart_delay != 0 {
        object.key("restartDelay").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.restart_delay).into()),
        );
    }
    if let Some(var_673) = &input.segmentation_mode {
        object.key("segmentationMode").string(var_673.as_str());
    }
    if input.send_delay_ms != 0 {
        object.key("sendDelayMs").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.send_delay_ms).into()),
        );
    }
    if let Some(var_674) = &input.sparse_track_type {
        object.key("sparseTrackType").string(var_674.as_str());
    }
    if let Some(var_675) = &input.stream_manifest_behavior {
        object
            .key("streamManifestBehavior")
            .string(var_675.as_str());
    }
    if let Some(var_676) = &input.timestamp_offset {
        object.key("timestampOffset").string(var_676.as_str());
    }
    if let Some(var_677) = &input.timestamp_offset_mode {
        object.key("timestampOffsetMode").string(var_677.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_multiplex_group_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MultiplexGroupSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    Ok(())
}

pub fn serialize_structure_crate_model_rtmp_group_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::RtmpGroupSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_678) = &input.ad_markers {
        let mut array_679 = object.key("adMarkers").start_array();
        for item_680 in var_678 {
            {
                array_679.value().string(item_680.as_str());
            }
        }
        array_679.finish();
    }
    if let Some(var_681) = &input.authentication_scheme {
        object.key("authenticationScheme").string(var_681.as_str());
    }
    if let Some(var_682) = &input.cache_full_behavior {
        object.key("cacheFullBehavior").string(var_682.as_str());
    }
    if input.cache_length != 0 {
        object.key("cacheLength").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.cache_length).into()),
        );
    }
    if let Some(var_683) = &input.caption_data {
        object.key("captionData").string(var_683.as_str());
    }
    if let Some(var_684) = &input.input_loss_action {
        object.key("inputLossAction").string(var_684.as_str());
    }
    if input.restart_delay != 0 {
        object.key("restartDelay").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.restart_delay).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_udp_group_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::UdpGroupSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_685) = &input.input_loss_action {
        object.key("inputLossAction").string(var_685.as_str());
    }
    if let Some(var_686) = &input.timed_metadata_id3_frame {
        object.key("timedMetadataId3Frame").string(var_686.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()),
        );
    }
    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_687) = &input.archive_output_settings {
        let mut object_688 = object.key("archiveOutputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_archive_output_settings(
            &mut object_688,
            var_687,
        )?;
        object_688.finish();
    }
    if let Some(var_689) = &input.frame_capture_output_settings {
        let mut object_690 = object.key("frameCaptureOutputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_frame_capture_output_settings(
            &mut object_690,
            var_689,
        )?;
        object_690.finish();
    }
    if let Some(var_691) = &input.hls_output_settings {
        let mut object_692 = object.key("hlsOutputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_output_settings(
            &mut object_692,
            var_691,
        )?;
        object_692.finish();
    }
    if let Some(var_693) = &input.media_package_output_settings {
        let mut object_694 = object.key("mediaPackageOutputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_media_package_output_settings(
            &mut object_694,
            var_693,
        )?;
        object_694.finish();
    }
    if let Some(var_695) = &input.ms_smooth_output_settings {
        let mut object_696 = object.key("msSmoothOutputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_ms_smooth_output_settings(
            &mut object_696,
            var_695,
        )?;
        object_696.finish();
    }
    if let Some(var_697) = &input.multiplex_output_settings {
        let mut object_698 = object.key("multiplexOutputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_output_settings(
            &mut object_698,
            var_697,
        )?;
        object_698.finish();
    }
    if let Some(var_699) = &input.rtmp_output_settings {
        let mut object_700 = object.key("rtmpOutputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_rtmp_output_settings(
            &mut object_700,
            var_699,
        )?;
        object_700.finish();
    }
    if let Some(var_701) = &input.udp_output_settings {
        let mut object_702 = object.key("udpOutputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_udp_output_settings(
            &mut object_702,
            var_701,
        )?;
        object_702.finish();
    }
    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.capture_interval != 0 {
        object.key("captureInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.capture_interval).into()),
        );
    }
    if let Some(var_703) = &input.capture_interval_units {
        object.key("captureIntervalUnits").string(var_703.as_str());
    }
    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_704) = &input.adaptive_quantization {
        object.key("adaptiveQuantization").string(var_704.as_str());
    }
    if let Some(var_705) = &input.afd_signaling {
        object.key("afdSignaling").string(var_705.as_str());
    }
    if input.bitrate != 0 {
        object.key("bitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.bitrate).into()),
        );
    }
    if input.buf_fill_pct != 0 {
        object.key("bufFillPct").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.buf_fill_pct).into()),
        );
    }
    if input.buf_size != 0 {
        object.key("bufSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.buf_size).into()),
        );
    }
    if let Some(var_706) = &input.color_metadata {
        object.key("colorMetadata").string(var_706.as_str());
    }
    if let Some(var_707) = &input.color_space_settings {
        let mut object_708 = object.key("colorSpaceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_h264_color_space_settings(
            &mut object_708,
            var_707,
        )?;
        object_708.finish();
    }
    if let Some(var_709) = &input.entropy_encoding {
        object.key("entropyEncoding").string(var_709.as_str());
    }
    if let Some(var_710) = &input.filter_settings {
        let mut object_711 = object.key("filterSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_h264_filter_settings(
            &mut object_711,
            var_710,
        )?;
        object_711.finish();
    }
    if let Some(var_712) = &input.fixed_afd {
        object.key("fixedAfd").string(var_712.as_str());
    }
    if let Some(var_713) = &input.flicker_aq {
        object.key("flickerAq").string(var_713.as_str());
    }
    if let Some(var_714) = &input.force_field_pictures {
        object.key("forceFieldPictures").string(var_714.as_str());
    }
    if let Some(var_715) = &input.framerate_control {
        object.key("framerateControl").string(var_715.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_716) = &input.gop_b_reference {
        object.key("gopBReference").string(var_716.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_num_b_frames != 0 {
        object.key("gopNumBFrames").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.gop_num_b_frames).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_717) = &input.gop_size_units {
        object.key("gopSizeUnits").string(var_717.as_str());
    }
    if let Some(var_718) = &input.level {
        object.key("level").string(var_718.as_str());
    }
    if let Some(var_719) = &input.look_ahead_rate_control {
        object.key("lookAheadRateControl").string(var_719.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.num_ref_frames != 0 {
        object.key("numRefFrames").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.num_ref_frames).into()),
        );
    }
    if let Some(var_720) = &input.par_control {
        object.key("parControl").string(var_720.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_721) = &input.profile {
        object.key("profile").string(var_721.as_str());
    }
    if let Some(var_722) = &input.quality_level {
        object.key("qualityLevel").string(var_722.as_str());
    }
    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 let Some(var_723) = &input.rate_control_mode {
        object.key("rateControlMode").string(var_723.as_str());
    }
    if let Some(var_724) = &input.scan_type {
        object.key("scanType").string(var_724.as_str());
    }
    if let Some(var_725) = &input.scene_change_detect {
        object.key("sceneChangeDetect").string(var_725.as_str());
    }
    if input.slices != 0 {
        object.key("slices").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.slices).into()),
        );
    }
    if input.softness != 0 {
        object.key("softness").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.softness).into()),
        );
    }
    if let Some(var_726) = &input.spatial_aq {
        object.key("spatialAq").string(var_726.as_str());
    }
    if let Some(var_727) = &input.subgop_length {
        object.key("subgopLength").string(var_727.as_str());
    }
    if let Some(var_728) = &input.syntax {
        object.key("syntax").string(var_728.as_str());
    }
    if let Some(var_729) = &input.temporal_aq {
        object.key("temporalAq").string(var_729.as_str());
    }
    if let Some(var_730) = &input.timecode_insertion {
        object.key("timecodeInsertion").string(var_730.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_731) = &input.adaptive_quantization {
        object.key("adaptiveQuantization").string(var_731.as_str());
    }
    if let Some(var_732) = &input.afd_signaling {
        object.key("afdSignaling").string(var_732.as_str());
    }
    if let Some(var_733) = &input.alternative_transfer_function {
        object
            .key("alternativeTransferFunction")
            .string(var_733.as_str());
    }
    if input.bitrate != 0 {
        object.key("bitrate").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.bitrate).into()),
        );
    }
    if input.buf_size != 0 {
        object.key("bufSize").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.buf_size).into()),
        );
    }
    if let Some(var_734) = &input.color_metadata {
        object.key("colorMetadata").string(var_734.as_str());
    }
    if let Some(var_735) = &input.color_space_settings {
        let mut object_736 = object.key("colorSpaceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_h265_color_space_settings(
            &mut object_736,
            var_735,
        )?;
        object_736.finish();
    }
    if let Some(var_737) = &input.filter_settings {
        let mut object_738 = object.key("filterSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_h265_filter_settings(
            &mut object_738,
            var_737,
        )?;
        object_738.finish();
    }
    if let Some(var_739) = &input.fixed_afd {
        object.key("fixedAfd").string(var_739.as_str());
    }
    if let Some(var_740) = &input.flicker_aq {
        object.key("flickerAq").string(var_740.as_str());
    }
    {
        object.key("framerateDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_denominator).into()),
        );
    }
    {
        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_741) = &input.gop_size_units {
        object.key("gopSizeUnits").string(var_741.as_str());
    }
    if let Some(var_742) = &input.level {
        object.key("level").string(var_742.as_str());
    }
    if let Some(var_743) = &input.look_ahead_rate_control {
        object.key("lookAheadRateControl").string(var_743.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.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_744) = &input.profile {
        object.key("profile").string(var_744.as_str());
    }
    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 let Some(var_745) = &input.rate_control_mode {
        object.key("rateControlMode").string(var_745.as_str());
    }
    if let Some(var_746) = &input.scan_type {
        object.key("scanType").string(var_746.as_str());
    }
    if let Some(var_747) = &input.scene_change_detect {
        object.key("sceneChangeDetect").string(var_747.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_748) = &input.tier {
        object.key("tier").string(var_748.as_str());
    }
    if let Some(var_749) = &input.timecode_insertion {
        object.key("timecodeInsertion").string(var_749.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_750) = &input.adaptive_quantization {
        object.key("adaptiveQuantization").string(var_750.as_str());
    }
    if let Some(var_751) = &input.afd_signaling {
        object.key("afdSignaling").string(var_751.as_str());
    }
    if let Some(var_752) = &input.color_metadata {
        object.key("colorMetadata").string(var_752.as_str());
    }
    if let Some(var_753) = &input.color_space {
        object.key("colorSpace").string(var_753.as_str());
    }
    if let Some(var_754) = &input.display_aspect_ratio {
        object.key("displayAspectRatio").string(var_754.as_str());
    }
    if let Some(var_755) = &input.filter_settings {
        let mut object_756 = object.key("filterSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_mpeg2_filter_settings(
            &mut object_756,
            var_755,
        )?;
        object_756.finish();
    }
    if let Some(var_757) = &input.fixed_afd {
        object.key("fixedAfd").string(var_757.as_str());
    }
    {
        object.key("framerateDenominator").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.framerate_denominator).into()),
        );
    }
    {
        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_num_b_frames != 0 {
        object.key("gopNumBFrames").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.gop_num_b_frames).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_758) = &input.gop_size_units {
        object.key("gopSizeUnits").string(var_758.as_str());
    }
    if let Some(var_759) = &input.scan_type {
        object.key("scanType").string(var_759.as_str());
    }
    if let Some(var_760) = &input.subgop_length {
        object.key("subgopLength").string(var_760.as_str());
    }
    if let Some(var_761) = &input.timecode_insertion {
        object.key("timecodeInsertion").string(var_761.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_failover_condition_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FailoverConditionSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_762) = &input.audio_silence_settings {
        let mut object_763 = object.key("audioSilenceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_silence_failover_settings(
            &mut object_763,
            var_762,
        )?;
        object_763.finish();
    }
    if let Some(var_764) = &input.input_loss_settings {
        let mut object_765 = object.key("inputLossSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_input_loss_failover_settings(
            &mut object_765,
            var_764,
        )?;
        object_765.finish();
    }
    if let Some(var_766) = &input.video_black_settings {
        let mut object_767 = object.key("videoBlackSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_video_black_failover_settings(
            &mut object_767,
            var_766,
        )?;
        object_767.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_audio_selector_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AudioSelectorSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_768) = &input.audio_hls_rendition_selection {
        let mut object_769 = object.key("audioHlsRenditionSelection").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_hls_rendition_selection(
            &mut object_769,
            var_768,
        )?;
        object_769.finish();
    }
    if let Some(var_770) = &input.audio_language_selection {
        let mut object_771 = object.key("audioLanguageSelection").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_language_selection(
            &mut object_771,
            var_770,
        )?;
        object_771.finish();
    }
    if let Some(var_772) = &input.audio_pid_selection {
        let mut object_773 = object.key("audioPidSelection").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_pid_selection(
            &mut object_773,
            var_772,
        )?;
        object_773.finish();
    }
    if let Some(var_774) = &input.audio_track_selection {
        let mut object_775 = object.key("audioTrackSelection").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_track_selection(
            &mut object_775,
            var_774,
        )?;
        object_775.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_caption_selector_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CaptionSelectorSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_776) = &input.ancillary_source_settings {
        let mut object_777 = object.key("ancillarySourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_ancillary_source_settings(
            &mut object_777,
            var_776,
        )?;
        object_777.finish();
    }
    if let Some(var_778) = &input.arib_source_settings {
        let mut object_779 = object.key("aribSourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_arib_source_settings(
            &mut object_779,
            var_778,
        )?;
        object_779.finish();
    }
    if let Some(var_780) = &input.dvb_sub_source_settings {
        let mut object_781 = object.key("dvbSubSourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_dvb_sub_source_settings(
            &mut object_781,
            var_780,
        )?;
        object_781.finish();
    }
    if let Some(var_782) = &input.embedded_source_settings {
        let mut object_783 = object.key("embeddedSourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_embedded_source_settings(
            &mut object_783,
            var_782,
        )?;
        object_783.finish();
    }
    if let Some(var_784) = &input.scte20_source_settings {
        let mut object_785 = object.key("scte20SourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_scte20_source_settings(
            &mut object_785,
            var_784,
        )?;
        object_785.finish();
    }
    if let Some(var_786) = &input.scte27_source_settings {
        let mut object_787 = object.key("scte27SourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_scte27_source_settings(
            &mut object_787,
            var_786,
        )?;
        object_787.finish();
    }
    if let Some(var_788) = &input.teletext_source_settings {
        let mut object_789 = object.key("teletextSourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_teletext_source_settings(
            &mut object_789,
            var_788,
        )?;
        object_789.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_hls_input_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HlsInputSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.bandwidth != 0 {
        object.key("bandwidth").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.bandwidth).into()),
        );
    }
    if input.buffer_segments != 0 {
        object.key("bufferSegments").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.buffer_segments).into()),
        );
    }
    if input.retries != 0 {
        object.key("retries").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.retries).into()),
        );
    }
    if input.retry_interval != 0 {
        object.key("retryInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.retry_interval).into()),
        );
    }
    if let Some(var_790) = &input.scte35_source {
        object.key("scte35Source").string(var_790.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_video_selector_color_space_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VideoSelectorColorSpaceSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_791) = &input.hdr10_settings {
        let mut object_792 = object.key("hdr10Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_hdr10_settings(&mut object_792, var_791)?;
        object_792.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_video_selector_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VideoSelectorSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_793) = &input.video_selector_pid {
        let mut object_794 = object.key("videoSelectorPid").start_object();
        crate::json_ser::serialize_structure_crate_model_video_selector_pid(
            &mut object_794,
            var_793,
        )?;
        object_794.finish();
    }
    if let Some(var_795) = &input.video_selector_program_id {
        let mut object_796 = object.key("videoSelectorProgramId").start_object();
        crate::json_ser::serialize_structure_crate_model_video_selector_program_id(
            &mut object_796,
            var_795,
        )?;
        object_796.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_input_clipping_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::InputClippingSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_797) = &input.input_timecode_source {
        object.key("inputTimecodeSource").string(var_797.as_str());
    }
    if let Some(var_798) = &input.start_timecode {
        let mut object_799 = object.key("startTimecode").start_object();
        crate::json_ser::serialize_structure_crate_model_start_timecode(&mut object_799, var_798)?;
        object_799.finish();
    }
    if let Some(var_800) = &input.stop_timecode {
        let mut object_801 = object.key("stopTimecode").start_object();
        crate::json_ser::serialize_structure_crate_model_stop_timecode(&mut object_801, var_800)?;
        object_801.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_pipeline_pause_state_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::PipelinePauseStateSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_802) = &input.pipeline_id {
        object.key("pipelineId").string(var_802.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_scte35_descriptor(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Scte35Descriptor,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_803) = &input.scte35_descriptor_settings {
        let mut object_804 = object.key("scte35DescriptorSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_scte35_descriptor_settings(
            &mut object_804,
            var_803,
        )?;
        object_804.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_nielsen_cbet(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NielsenCbet,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_805) = &input.cbet_check_digit_string {
        object.key("cbetCheckDigitString").string(var_805.as_str());
    }
    if let Some(var_806) = &input.cbet_stepaside {
        object.key("cbetStepaside").string(var_806.as_str());
    }
    if let Some(var_807) = &input.csid {
        object.key("csid").string(var_807.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_nielsen_naes_ii_nw(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::NielsenNaesIiNw,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_808) = &input.check_digit_string {
        object.key("checkDigitString").string(var_808.as_str());
    }
    {
        object.key("sid").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.sid).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_input_channel_level(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::InputChannelLevel,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    {
        object.key("gain").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.gain).into()),
        );
    }
    {
        object.key("inputChannel").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.input_channel).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_archive_cdn_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ArchiveCdnSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_809) = &input.archive_s3_settings {
        let mut object_810 = object.key("archiveS3Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_archive_s3_settings(
            &mut object_810,
            var_809,
        )?;
        object_810.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_output_location_ref(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::OutputLocationRef,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_811) = &input.destination_ref_id {
        object.key("destinationRefId").string(var_811.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_frame_capture_cdn_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FrameCaptureCdnSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_812) = &input.frame_capture_s3_settings {
        let mut object_813 = object.key("frameCaptureS3Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_frame_capture_s3_settings(
            &mut object_813,
            var_812,
        )?;
        object_813.finish();
    }
    Ok(())
}

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

pub fn serialize_structure_crate_model_hls_cdn_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HlsCdnSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_816) = &input.hls_akamai_settings {
        let mut object_817 = object.key("hlsAkamaiSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_akamai_settings(
            &mut object_817,
            var_816,
        )?;
        object_817.finish();
    }
    if let Some(var_818) = &input.hls_basic_put_settings {
        let mut object_819 = object.key("hlsBasicPutSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_basic_put_settings(
            &mut object_819,
            var_818,
        )?;
        object_819.finish();
    }
    if let Some(var_820) = &input.hls_media_store_settings {
        let mut object_821 = object.key("hlsMediaStoreSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_media_store_settings(
            &mut object_821,
            var_820,
        )?;
        object_821.finish();
    }
    if let Some(var_822) = &input.hls_s3_settings {
        let mut object_823 = object.key("hlsS3Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_s3_settings(&mut object_823, var_822)?;
        object_823.finish();
    }
    if let Some(var_824) = &input.hls_webdav_settings {
        let mut object_825 = object.key("hlsWebdavSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_webdav_settings(
            &mut object_825,
            var_824,
        )?;
        object_825.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_key_provider_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::KeyProviderSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_826) = &input.static_key_settings {
        let mut object_827 = object.key("staticKeySettings").start_object();
        crate::json_ser::serialize_structure_crate_model_static_key_settings(
            &mut object_827,
            var_826,
        )?;
        object_827.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_archive_output_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ArchiveOutputSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_828) = &input.container_settings {
        let mut object_829 = object.key("containerSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_archive_container_settings(
            &mut object_829,
            var_828,
        )?;
        object_829.finish();
    }
    if let Some(var_830) = &input.extension {
        object.key("extension").string(var_830.as_str());
    }
    if let Some(var_831) = &input.name_modifier {
        object.key("nameModifier").string(var_831.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_frame_capture_output_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FrameCaptureOutputSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_832) = &input.name_modifier {
        object.key("nameModifier").string(var_832.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_hls_output_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HlsOutputSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_833) = &input.h265_packaging_type {
        object.key("h265PackagingType").string(var_833.as_str());
    }
    if let Some(var_834) = &input.hls_settings {
        let mut object_835 = object.key("hlsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_settings(&mut object_835, var_834)?;
        object_835.finish();
    }
    if let Some(var_836) = &input.name_modifier {
        object.key("nameModifier").string(var_836.as_str());
    }
    if let Some(var_837) = &input.segment_modifier {
        object.key("segmentModifier").string(var_837.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_media_package_output_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MediaPackageOutputSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    Ok(())
}

pub fn serialize_structure_crate_model_ms_smooth_output_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MsSmoothOutputSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_838) = &input.h265_packaging_type {
        object.key("h265PackagingType").string(var_838.as_str());
    }
    if let Some(var_839) = &input.name_modifier {
        object.key("nameModifier").string(var_839.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_multiplex_output_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MultiplexOutputSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_840) = &input.destination {
        let mut object_841 = object.key("destination").start_object();
        crate::json_ser::serialize_structure_crate_model_output_location_ref(
            &mut object_841,
            var_840,
        )?;
        object_841.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_rtmp_output_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::RtmpOutputSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_842) = &input.certificate_mode {
        object.key("certificateMode").string(var_842.as_str());
    }
    if input.connection_retry_interval != 0 {
        object.key("connectionRetryInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.connection_retry_interval).into()),
        );
    }
    if let Some(var_843) = &input.destination {
        let mut object_844 = object.key("destination").start_object();
        crate::json_ser::serialize_structure_crate_model_output_location_ref(
            &mut object_844,
            var_843,
        )?;
        object_844.finish();
    }
    if input.num_retries != 0 {
        object.key("numRetries").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.num_retries).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_udp_output_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::UdpOutputSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.buffer_msec != 0 {
        object.key("bufferMsec").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.buffer_msec).into()),
        );
    }
    if let Some(var_845) = &input.container_settings {
        let mut object_846 = object.key("containerSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_udp_container_settings(
            &mut object_846,
            var_845,
        )?;
        object_846.finish();
    }
    if let Some(var_847) = &input.destination {
        let mut object_848 = object.key("destination").start_object();
        crate::json_ser::serialize_structure_crate_model_output_location_ref(
            &mut object_848,
            var_847,
        )?;
        object_848.finish();
    }
    if let Some(var_849) = &input.fec_output_settings {
        let mut object_850 = object.key("fecOutputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_fec_output_settings(
            &mut object_850,
            var_849,
        )?;
        object_850.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_h264_color_space_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::H264ColorSpaceSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_851) = &input.color_space_passthrough_settings {
        let mut object_852 = object.key("colorSpacePassthroughSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_color_space_passthrough_settings(
            &mut object_852,
            var_851,
        )?;
        object_852.finish();
    }
    if let Some(var_853) = &input.rec601_settings {
        let mut object_854 = object.key("rec601Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_rec601_settings(&mut object_854, var_853)?;
        object_854.finish();
    }
    if let Some(var_855) = &input.rec709_settings {
        let mut object_856 = object.key("rec709Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_rec709_settings(&mut object_856, var_855)?;
        object_856.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_h264_filter_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::H264FilterSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_857) = &input.temporal_filter_settings {
        let mut object_858 = object.key("temporalFilterSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_temporal_filter_settings(
            &mut object_858,
            var_857,
        )?;
        object_858.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_h265_color_space_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::H265ColorSpaceSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_859) = &input.color_space_passthrough_settings {
        let mut object_860 = object.key("colorSpacePassthroughSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_color_space_passthrough_settings(
            &mut object_860,
            var_859,
        )?;
        object_860.finish();
    }
    if let Some(var_861) = &input.hdr10_settings {
        let mut object_862 = object.key("hdr10Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_hdr10_settings(&mut object_862, var_861)?;
        object_862.finish();
    }
    if let Some(var_863) = &input.rec601_settings {
        let mut object_864 = object.key("rec601Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_rec601_settings(&mut object_864, var_863)?;
        object_864.finish();
    }
    if let Some(var_865) = &input.rec709_settings {
        let mut object_866 = object.key("rec709Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_rec709_settings(&mut object_866, var_865)?;
        object_866.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_h265_filter_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::H265FilterSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_867) = &input.temporal_filter_settings {
        let mut object_868 = object.key("temporalFilterSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_temporal_filter_settings(
            &mut object_868,
            var_867,
        )?;
        object_868.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_mpeg2_filter_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Mpeg2FilterSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_869) = &input.temporal_filter_settings {
        let mut object_870 = object.key("temporalFilterSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_temporal_filter_settings(
            &mut object_870,
            var_869,
        )?;
        object_870.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_audio_silence_failover_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AudioSilenceFailoverSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_871) = &input.audio_selector_name {
        object.key("audioSelectorName").string(var_871.as_str());
    }
    if input.audio_silence_threshold_msec != 0 {
        object.key("audioSilenceThresholdMsec").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.audio_silence_threshold_msec).into()),
        );
    }
    Ok(())
}

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

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

pub fn serialize_structure_crate_model_audio_hls_rendition_selection(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AudioHlsRenditionSelection,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_872) = &input.group_id {
        object.key("groupId").string(var_872.as_str());
    }
    if let Some(var_873) = &input.name {
        object.key("name").string(var_873.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_audio_language_selection(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AudioLanguageSelection,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_874) = &input.language_code {
        object.key("languageCode").string(var_874.as_str());
    }
    if let Some(var_875) = &input.language_selection_policy {
        object
            .key("languageSelectionPolicy")
            .string(var_875.as_str());
    }
    Ok(())
}

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

pub fn serialize_structure_crate_model_audio_track_selection(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AudioTrackSelection,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_876) = &input.tracks {
        let mut array_877 = object.key("tracks").start_array();
        for item_878 in var_876 {
            {
                let mut object_879 = array_877.value().start_object();
                crate::json_ser::serialize_structure_crate_model_audio_track(
                    &mut object_879,
                    item_878,
                )?;
                object_879.finish();
            }
        }
        array_877.finish();
    }
    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 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()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_arib_source_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AribSourceSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    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 let Some(var_880) = &input.ocr_language {
        object.key("ocrLanguage").string(var_880.as_str());
    }
    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_881) = &input.convert608_to708 {
        object.key("convert608To708").string(var_881.as_str());
    }
    if let Some(var_882) = &input.scte20_detection {
        object.key("scte20Detection").string(var_882.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()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_scte20_source_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Scte20SourceSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_883) = &input.convert608_to708 {
        object.key("convert608To708").string(var_883.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()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_scte27_source_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Scte27SourceSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_884) = &input.ocr_language {
        object.key("ocrLanguage").string(var_884.as_str());
    }
    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_teletext_source_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TeletextSourceSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_885) = &input.output_rectangle {
        let mut object_886 = object.key("outputRectangle").start_object();
        crate::json_ser::serialize_structure_crate_model_caption_rectangle(
            &mut object_886,
            var_885,
        )?;
        object_886.finish();
    }
    if let Some(var_887) = &input.page_number {
        object.key("pageNumber").string(var_887.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_hdr10_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Hdr10Settings,
) -> 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_video_selector_pid(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VideoSelectorPid,
) -> 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_video_selector_program_id(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VideoSelectorProgramId,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.program_id != 0 {
        object.key("programId").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.program_id).into()),
        );
    }
    Ok(())
}

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

pub fn serialize_structure_crate_model_stop_timecode(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::StopTimecode,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_889) = &input.last_frame_clipping_behavior {
        object
            .key("lastFrameClippingBehavior")
            .string(var_889.as_str());
    }
    if let Some(var_890) = &input.timecode {
        object.key("timecode").string(var_890.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_scte35_descriptor_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Scte35DescriptorSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_891) = &input.segmentation_descriptor_scte35_descriptor_settings {
        let mut object_892 = object
            .key("segmentationDescriptorScte35DescriptorSettings")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_scte35_segmentation_descriptor(
            &mut object_892,
            var_891,
        )?;
        object_892.finish();
    }
    Ok(())
}

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

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

pub fn serialize_structure_crate_model_hls_akamai_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HlsAkamaiSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.connection_retry_interval != 0 {
        object.key("connectionRetryInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.connection_retry_interval).into()),
        );
    }
    if input.filecache_duration != 0 {
        object.key("filecacheDuration").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.filecache_duration).into()),
        );
    }
    if let Some(var_895) = &input.http_transfer_mode {
        object.key("httpTransferMode").string(var_895.as_str());
    }
    if input.num_retries != 0 {
        object.key("numRetries").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.num_retries).into()),
        );
    }
    if input.restart_delay != 0 {
        object.key("restartDelay").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.restart_delay).into()),
        );
    }
    if let Some(var_896) = &input.salt {
        object.key("salt").string(var_896.as_str());
    }
    if let Some(var_897) = &input.token {
        object.key("token").string(var_897.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_hls_basic_put_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HlsBasicPutSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.connection_retry_interval != 0 {
        object.key("connectionRetryInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.connection_retry_interval).into()),
        );
    }
    if input.filecache_duration != 0 {
        object.key("filecacheDuration").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.filecache_duration).into()),
        );
    }
    if input.num_retries != 0 {
        object.key("numRetries").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.num_retries).into()),
        );
    }
    if input.restart_delay != 0 {
        object.key("restartDelay").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.restart_delay).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_hls_media_store_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HlsMediaStoreSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.connection_retry_interval != 0 {
        object.key("connectionRetryInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.connection_retry_interval).into()),
        );
    }
    if input.filecache_duration != 0 {
        object.key("filecacheDuration").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.filecache_duration).into()),
        );
    }
    if let Some(var_898) = &input.media_store_storage_class {
        object
            .key("mediaStoreStorageClass")
            .string(var_898.as_str());
    }
    if input.num_retries != 0 {
        object.key("numRetries").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.num_retries).into()),
        );
    }
    if input.restart_delay != 0 {
        object.key("restartDelay").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.restart_delay).into()),
        );
    }
    Ok(())
}

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

pub fn serialize_structure_crate_model_hls_webdav_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HlsWebdavSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.connection_retry_interval != 0 {
        object.key("connectionRetryInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.connection_retry_interval).into()),
        );
    }
    if input.filecache_duration != 0 {
        object.key("filecacheDuration").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.filecache_duration).into()),
        );
    }
    if let Some(var_900) = &input.http_transfer_mode {
        object.key("httpTransferMode").string(var_900.as_str());
    }
    if input.num_retries != 0 {
        object.key("numRetries").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.num_retries).into()),
        );
    }
    if input.restart_delay != 0 {
        object.key("restartDelay").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.restart_delay).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_static_key_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::StaticKeySettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_901) = &input.key_provider_server {
        let mut object_902 = object.key("keyProviderServer").start_object();
        crate::json_ser::serialize_structure_crate_model_input_location(&mut object_902, var_901)?;
        object_902.finish();
    }
    if let Some(var_903) = &input.static_key_value {
        object.key("staticKeyValue").string(var_903.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_archive_container_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ArchiveContainerSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_904) = &input.m2ts_settings {
        let mut object_905 = object.key("m2tsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_m2ts_settings(&mut object_905, var_904)?;
        object_905.finish();
    }
    if let Some(var_906) = &input.raw_settings {
        let mut object_907 = object.key("rawSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_raw_settings(&mut object_907, var_906)?;
        object_907.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_908) = &input.audio_only_hls_settings {
        let mut object_909 = object.key("audioOnlyHlsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_only_hls_settings(
            &mut object_909,
            var_908,
        )?;
        object_909.finish();
    }
    if let Some(var_910) = &input.fmp4_hls_settings {
        let mut object_911 = object.key("fmp4HlsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_fmp4_hls_settings(
            &mut object_911,
            var_910,
        )?;
        object_911.finish();
    }
    if let Some(var_912) = &input.frame_capture_hls_settings {
        let mut object_913 = object.key("frameCaptureHlsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_frame_capture_hls_settings(
            &mut object_913,
            var_912,
        )?;
        object_913.finish();
    }
    if let Some(var_914) = &input.standard_hls_settings {
        let mut object_915 = object.key("standardHlsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_standard_hls_settings(
            &mut object_915,
            var_914,
        )?;
        object_915.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_udp_container_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::UdpContainerSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_916) = &input.m2ts_settings {
        let mut object_917 = object.key("m2tsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_m2ts_settings(&mut object_917, var_916)?;
        object_917.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_fec_output_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FecOutputSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if input.column_depth != 0 {
        object.key("columnDepth").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.column_depth).into()),
        );
    }
    if let Some(var_918) = &input.include_fec {
        object.key("includeFec").string(var_918.as_str());
    }
    if input.row_length != 0 {
        object.key("rowLength").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.row_length).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_color_space_passthrough_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ColorSpacePassthroughSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    Ok(())
}

pub fn serialize_structure_crate_model_rec601_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Rec601Settings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    Ok(())
}

pub fn serialize_structure_crate_model_rec709_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Rec709Settings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    Ok(())
}

pub fn serialize_structure_crate_model_temporal_filter_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TemporalFilterSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_919) = &input.post_filter_sharpening {
        object.key("postFilterSharpening").string(var_919.as_str());
    }
    if let Some(var_920) = &input.strength {
        object.key("strength").string(var_920.as_str());
    }
    Ok(())
}

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

pub fn serialize_structure_crate_model_caption_rectangle(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CaptionRectangle,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    {
        object.key("height").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.height).into()),
        );
    }
    {
        object.key("leftOffset").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.left_offset).into()),
        );
    }
    {
        object.key("topOffset").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.top_offset).into()),
        );
    }
    {
        object.key("width").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.width).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_scte35_segmentation_descriptor(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Scte35SegmentationDescriptor,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_921) = &input.delivery_restrictions {
        let mut object_922 = object.key("deliveryRestrictions").start_object();
        crate::json_ser::serialize_structure_crate_model_scte35_delivery_restrictions(
            &mut object_922,
            var_921,
        )?;
        object_922.finish();
    }
    if input.segment_num != 0 {
        object.key("segmentNum").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.segment_num).into()),
        );
    }
    if let Some(var_923) = &input.segmentation_cancel_indicator {
        object
            .key("segmentationCancelIndicator")
            .string(var_923.as_str());
    }
    if input.segmentation_duration != 0 {
        object.key("segmentationDuration").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.segmentation_duration).into()),
        );
    }
    {
        object.key("segmentationEventId").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.segmentation_event_id).into()),
        );
    }
    if input.segmentation_type_id != 0 {
        object.key("segmentationTypeId").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.segmentation_type_id).into()),
        );
    }
    if let Some(var_924) = &input.segmentation_upid {
        object.key("segmentationUpid").string(var_924.as_str());
    }
    if input.segmentation_upid_type != 0 {
        object.key("segmentationUpidType").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.segmentation_upid_type).into()),
        );
    }
    if input.segments_expected != 0 {
        object.key("segmentsExpected").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.segments_expected).into()),
        );
    }
    if input.sub_segment_num != 0 {
        object.key("subSegmentNum").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.sub_segment_num).into()),
        );
    }
    if input.sub_segments_expected != 0 {
        object.key("subSegmentsExpected").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.sub_segments_expected).into()),
        );
    }
    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_925) = &input.absent_input_audio_behavior {
        object
            .key("absentInputAudioBehavior")
            .string(var_925.as_str());
    }
    if let Some(var_926) = &input.arib {
        object.key("arib").string(var_926.as_str());
    }
    if let Some(var_927) = &input.arib_captions_pid {
        object.key("aribCaptionsPid").string(var_927.as_str());
    }
    if let Some(var_928) = &input.arib_captions_pid_control {
        object
            .key("aribCaptionsPidControl")
            .string(var_928.as_str());
    }
    if let Some(var_929) = &input.audio_buffer_model {
        object.key("audioBufferModel").string(var_929.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_930) = &input.audio_pids {
        object.key("audioPids").string(var_930.as_str());
    }
    if let Some(var_931) = &input.audio_stream_type {
        object.key("audioStreamType").string(var_931.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_932) = &input.buffer_model {
        object.key("bufferModel").string(var_932.as_str());
    }
    if let Some(var_933) = &input.cc_descriptor {
        object.key("ccDescriptor").string(var_933.as_str());
    }
    if let Some(var_934) = &input.dvb_nit_settings {
        let mut object_935 = object.key("dvbNitSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_dvb_nit_settings(
            &mut object_935,
            var_934,
        )?;
        object_935.finish();
    }
    if let Some(var_936) = &input.dvb_sdt_settings {
        let mut object_937 = object.key("dvbSdtSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_dvb_sdt_settings(
            &mut object_937,
            var_936,
        )?;
        object_937.finish();
    }
    if let Some(var_938) = &input.dvb_sub_pids {
        object.key("dvbSubPids").string(var_938.as_str());
    }
    if let Some(var_939) = &input.dvb_tdt_settings {
        let mut object_940 = object.key("dvbTdtSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_dvb_tdt_settings(
            &mut object_940,
            var_939,
        )?;
        object_940.finish();
    }
    if let Some(var_941) = &input.dvb_teletext_pid {
        object.key("dvbTeletextPid").string(var_941.as_str());
    }
    if let Some(var_942) = &input.ebif {
        object.key("ebif").string(var_942.as_str());
    }
    if let Some(var_943) = &input.ebp_audio_interval {
        object.key("ebpAudioInterval").string(var_943.as_str());
    }
    if input.ebp_lookahead_ms != 0 {
        object.key("ebpLookaheadMs").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.ebp_lookahead_ms).into()),
        );
    }
    if let Some(var_944) = &input.ebp_placement {
        object.key("ebpPlacement").string(var_944.as_str());
    }
    if let Some(var_945) = &input.ecm_pid {
        object.key("ecmPid").string(var_945.as_str());
    }
    if let Some(var_946) = &input.es_rate_in_pes {
        object.key("esRateInPes").string(var_946.as_str());
    }
    if let Some(var_947) = &input.etv_platform_pid {
        object.key("etvPlatformPid").string(var_947.as_str());
    }
    if let Some(var_948) = &input.etv_signal_pid {
        object.key("etvSignalPid").string(var_948.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 let Some(var_949) = &input.klv {
        object.key("klv").string(var_949.as_str());
    }
    if let Some(var_950) = &input.klv_data_pids {
        object.key("klvDataPids").string(var_950.as_str());
    }
    if let Some(var_951) = &input.nielsen_id3_behavior {
        object.key("nielsenId3Behavior").string(var_951.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_952) = &input.pcr_control {
        object.key("pcrControl").string(var_952.as_str());
    }
    if input.pcr_period != 0 {
        object.key("pcrPeriod").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.pcr_period).into()),
        );
    }
    if let Some(var_953) = &input.pcr_pid {
        object.key("pcrPid").string(var_953.as_str());
    }
    if input.pmt_interval != 0 {
        object.key("pmtInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.pmt_interval).into()),
        );
    }
    if let Some(var_954) = &input.pmt_pid {
        object.key("pmtPid").string(var_954.as_str());
    }
    if input.program_num != 0 {
        object.key("programNum").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.program_num).into()),
        );
    }
    if let Some(var_955) = &input.rate_mode {
        object.key("rateMode").string(var_955.as_str());
    }
    if let Some(var_956) = &input.scte27_pids {
        object.key("scte27Pids").string(var_956.as_str());
    }
    if let Some(var_957) = &input.scte35_control {
        object.key("scte35Control").string(var_957.as_str());
    }
    if let Some(var_958) = &input.scte35_pid {
        object.key("scte35Pid").string(var_958.as_str());
    }
    if let Some(var_959) = &input.segmentation_markers {
        object.key("segmentationMarkers").string(var_959.as_str());
    }
    if let Some(var_960) = &input.segmentation_style {
        object.key("segmentationStyle").string(var_960.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 let Some(var_961) = &input.timed_metadata_behavior {
        object.key("timedMetadataBehavior").string(var_961.as_str());
    }
    if let Some(var_962) = &input.timed_metadata_pid {
        object.key("timedMetadataPid").string(var_962.as_str());
    }
    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 let Some(var_963) = &input.video_pid {
        object.key("videoPid").string(var_963.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_raw_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::RawSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    Ok(())
}

pub fn serialize_structure_crate_model_audio_only_hls_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AudioOnlyHlsSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_964) = &input.audio_group_id {
        object.key("audioGroupId").string(var_964.as_str());
    }
    if let Some(var_965) = &input.audio_only_image {
        let mut object_966 = object.key("audioOnlyImage").start_object();
        crate::json_ser::serialize_structure_crate_model_input_location(&mut object_966, var_965)?;
        object_966.finish();
    }
    if let Some(var_967) = &input.audio_track_type {
        object.key("audioTrackType").string(var_967.as_str());
    }
    if let Some(var_968) = &input.segment_type {
        object.key("segmentType").string(var_968.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_fmp4_hls_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Fmp4HlsSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_969) = &input.audio_rendition_sets {
        object.key("audioRenditionSets").string(var_969.as_str());
    }
    if let Some(var_970) = &input.nielsen_id3_behavior {
        object.key("nielsenId3Behavior").string(var_970.as_str());
    }
    if let Some(var_971) = &input.timed_metadata_behavior {
        object.key("timedMetadataBehavior").string(var_971.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_frame_capture_hls_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FrameCaptureHlsSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    let (_, _) = (object, input);
    Ok(())
}

pub fn serialize_structure_crate_model_standard_hls_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::StandardHlsSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_972) = &input.audio_rendition_sets {
        object.key("audioRenditionSets").string(var_972.as_str());
    }
    if let Some(var_973) = &input.m3u8_settings {
        let mut object_974 = object.key("m3u8Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_m3u8_settings(&mut object_974, var_973)?;
        object_974.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_scte35_delivery_restrictions(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Scte35DeliveryRestrictions,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_975) = &input.archive_allowed_flag {
        object.key("archiveAllowedFlag").string(var_975.as_str());
    }
    if let Some(var_976) = &input.device_restrictions {
        object.key("deviceRestrictions").string(var_976.as_str());
    }
    if let Some(var_977) = &input.no_regional_blackout_flag {
        object
            .key("noRegionalBlackoutFlag")
            .string(var_977.as_str());
    }
    if let Some(var_978) = &input.web_delivery_allowed_flag {
        object
            .key("webDeliveryAllowedFlag")
            .string(var_978.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> {
    {
        object.key("networkId").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.network_id).into()),
        );
    }
    if let Some(var_979) = &input.network_name {
        object.key("networkName").string(var_979.as_str());
    }
    if input.rep_interval != 0 {
        object.key("repInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.rep_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_980) = &input.output_sdt {
        object.key("outputSdt").string(var_980.as_str());
    }
    if input.rep_interval != 0 {
        object.key("repInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.rep_interval).into()),
        );
    }
    if let Some(var_981) = &input.service_name {
        object.key("serviceName").string(var_981.as_str());
    }
    if let Some(var_982) = &input.service_provider_name {
        object.key("serviceProviderName").string(var_982.as_str());
    }
    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.rep_interval != 0 {
        object.key("repInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.rep_interval).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 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_983) = &input.audio_pids {
        object.key("audioPids").string(var_983.as_str());
    }
    if let Some(var_984) = &input.ecm_pid {
        object.key("ecmPid").string(var_984.as_str());
    }
    if let Some(var_985) = &input.nielsen_id3_behavior {
        object.key("nielsenId3Behavior").string(var_985.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_986) = &input.pcr_control {
        object.key("pcrControl").string(var_986.as_str());
    }
    if input.pcr_period != 0 {
        object.key("pcrPeriod").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.pcr_period).into()),
        );
    }
    if let Some(var_987) = &input.pcr_pid {
        object.key("pcrPid").string(var_987.as_str());
    }
    if input.pmt_interval != 0 {
        object.key("pmtInterval").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.pmt_interval).into()),
        );
    }
    if let Some(var_988) = &input.pmt_pid {
        object.key("pmtPid").string(var_988.as_str());
    }
    if input.program_num != 0 {
        object.key("programNum").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.program_num).into()),
        );
    }
    if let Some(var_989) = &input.scte35_behavior {
        object.key("scte35Behavior").string(var_989.as_str());
    }
    if let Some(var_990) = &input.scte35_pid {
        object.key("scte35Pid").string(var_990.as_str());
    }
    if let Some(var_991) = &input.timed_metadata_behavior {
        object.key("timedMetadataBehavior").string(var_991.as_str());
    }
    if let Some(var_992) = &input.timed_metadata_pid {
        object.key("timedMetadataPid").string(var_992.as_str());
    }
    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 let Some(var_993) = &input.video_pid {
        object.key("videoPid").string(var_993.as_str());
    }
    Ok(())
}