aws-sdk-medialive 0.16.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.maintenance {
        let mut object_47 = object.key("maintenance").start_object();
        crate::json_ser::serialize_structure_crate_model_maintenance_create_settings(
            &mut object_47,
            var_46,
        )?;
        object_47.finish();
    }
    if let Some(var_48) = &input.name {
        object.key("name").string(var_48.as_str());
    }
    if let Some(var_49) = &input.request_id {
        object.key("requestId").string(var_49.as_str());
    }
    if let Some(var_50) = &input.reserved {
        object.key("reserved").string(var_50.as_str());
    }
    if let Some(var_51) = &input.role_arn {
        object.key("roleArn").string(var_51.as_str());
    }
    if let Some(var_52) = &input.tags {
        let mut object_53 = object.key("tags").start_object();
        for (key_54, value_55) in var_52 {
            {
                object_53.key(key_54).string(value_55.as_str());
            }
        }
        object_53.finish();
    }
    if let Some(var_56) = &input.vpc {
        let mut object_57 = object.key("vpc").start_object();
        crate::json_ser::serialize_structure_crate_model_vpc_output_settings(
            &mut object_57,
            var_56,
        )?;
        object_57.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_58) = &input.destinations {
        let mut array_59 = object.key("destinations").start_array();
        for item_60 in var_58 {
            {
                let mut object_61 = array_59.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_destination_request(
                    &mut object_61,
                    item_60,
                )?;
                object_61.finish();
            }
        }
        array_59.finish();
    }
    if let Some(var_62) = &input.input_devices {
        let mut array_63 = object.key("inputDevices").start_array();
        for item_64 in var_62 {
            {
                let mut object_65 = array_63.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_device_settings(
                    &mut object_65,
                    item_64,
                )?;
                object_65.finish();
            }
        }
        array_63.finish();
    }
    if let Some(var_66) = &input.input_security_groups {
        let mut array_67 = object.key("inputSecurityGroups").start_array();
        for item_68 in var_66 {
            {
                array_67.value().string(item_68.as_str());
            }
        }
        array_67.finish();
    }
    if let Some(var_69) = &input.media_connect_flows {
        let mut array_70 = object.key("mediaConnectFlows").start_array();
        for item_71 in var_69 {
            {
                let mut object_72 = array_70.value().start_object();
                crate::json_ser::serialize_structure_crate_model_media_connect_flow_request(
                    &mut object_72,
                    item_71,
                )?;
                object_72.finish();
            }
        }
        array_70.finish();
    }
    if let Some(var_73) = &input.name {
        object.key("name").string(var_73.as_str());
    }
    if let Some(var_74) = &input.request_id {
        object.key("requestId").string(var_74.as_str());
    }
    if let Some(var_75) = &input.role_arn {
        object.key("roleArn").string(var_75.as_str());
    }
    if let Some(var_76) = &input.sources {
        let mut array_77 = object.key("sources").start_array();
        for item_78 in var_76 {
            {
                let mut object_79 = array_77.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_source_request(
                    &mut object_79,
                    item_78,
                )?;
                object_79.finish();
            }
        }
        array_77.finish();
    }
    if let Some(var_80) = &input.tags {
        let mut object_81 = object.key("tags").start_object();
        for (key_82, value_83) in var_80 {
            {
                object_81.key(key_82).string(value_83.as_str());
            }
        }
        object_81.finish();
    }
    if let Some(var_84) = &input.r#type {
        object.key("type").string(var_84.as_str());
    }
    if let Some(var_85) = &input.vpc {
        let mut object_86 = object.key("vpc").start_object();
        crate::json_ser::serialize_structure_crate_model_input_vpc_request(&mut object_86, var_85)?;
        object_86.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_87) = &input.tags {
        let mut object_88 = object.key("tags").start_object();
        for (key_89, value_90) in var_87 {
            {
                object_88.key(key_89).string(value_90.as_str());
            }
        }
        object_88.finish();
    }
    if let Some(var_91) = &input.whitelist_rules {
        let mut array_92 = object.key("whitelistRules").start_array();
        for item_93 in var_91 {
            {
                let mut object_94 = array_92.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_whitelist_rule_cidr(
                    &mut object_94,
                    item_93,
                )?;
                object_94.finish();
            }
        }
        array_92.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_95) = &input.availability_zones {
        let mut array_96 = object.key("availabilityZones").start_array();
        for item_97 in var_95 {
            {
                array_96.value().string(item_97.as_str());
            }
        }
        array_96.finish();
    }
    if let Some(var_98) = &input.multiplex_settings {
        let mut object_99 = object.key("multiplexSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_settings(
            &mut object_99,
            var_98,
        )?;
        object_99.finish();
    }
    if let Some(var_100) = &input.name {
        object.key("name").string(var_100.as_str());
    }
    if let Some(var_101) = &input.request_id {
        object.key("requestId").string(var_101.as_str());
    }
    if let Some(var_102) = &input.tags {
        let mut object_103 = object.key("tags").start_object();
        for (key_104, value_105) in var_102 {
            {
                object_103.key(key_104).string(value_105.as_str());
            }
        }
        object_103.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_106) = &input.multiplex_program_settings {
        let mut object_107 = object.key("multiplexProgramSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_program_settings(
            &mut object_107,
            var_106,
        )?;
        object_107.finish();
    }
    if let Some(var_108) = &input.program_name {
        object.key("programName").string(var_108.as_str());
    }
    if let Some(var_109) = &input.request_id {
        object.key("requestId").string(var_109.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_110) = &input.request_id {
        object.key("requestId").string(var_110.as_str());
    }
    if let Some(var_111) = &input.tags {
        let mut object_112 = object.key("tags").start_object();
        for (key_113, value_114) in var_111 {
            {
                object_112.key(key_113).string(value_114.as_str());
            }
        }
        object_112.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_115) = &input.tags {
        let mut object_116 = object.key("tags").start_object();
        for (key_117, value_118) in var_115 {
            {
                object_116.key(key_117).string(value_118.as_str());
            }
        }
        object_116.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_119) = &input.name {
        object.key("name").string(var_119.as_str());
    }
    if let Some(var_120) = &input.renewal_settings {
        let mut object_121 = object.key("renewalSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_renewal_settings(
            &mut object_121,
            var_120,
        )?;
        object_121.finish();
    }
    if let Some(var_122) = &input.request_id {
        object.key("requestId").string(var_122.as_str());
    }
    if let Some(var_123) = &input.start {
        object.key("start").string(var_123.as_str());
    }
    if let Some(var_124) = &input.tags {
        let mut object_125 = object.key("tags").start_object();
        for (key_126, value_127) in var_124 {
            {
                object_125.key(key_126).string(value_127.as_str());
            }
        }
        object_125.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_128) = &input.target_customer_id {
        object.key("targetCustomerId").string(var_128.as_str());
    }
    if let Some(var_129) = &input.target_region {
        object.key("targetRegion").string(var_129.as_str());
    }
    if let Some(var_130) = &input.transfer_message {
        object.key("transferMessage").string(var_130.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_131) = &input.cdi_input_specification {
        let mut object_132 = object.key("cdiInputSpecification").start_object();
        crate::json_ser::serialize_structure_crate_model_cdi_input_specification(
            &mut object_132,
            var_131,
        )?;
        object_132.finish();
    }
    if let Some(var_133) = &input.destinations {
        let mut array_134 = object.key("destinations").start_array();
        for item_135 in var_133 {
            {
                let mut object_136 = array_134.value().start_object();
                crate::json_ser::serialize_structure_crate_model_output_destination(
                    &mut object_136,
                    item_135,
                )?;
                object_136.finish();
            }
        }
        array_134.finish();
    }
    if let Some(var_137) = &input.encoder_settings {
        let mut object_138 = object.key("encoderSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_encoder_settings(
            &mut object_138,
            var_137,
        )?;
        object_138.finish();
    }
    if let Some(var_139) = &input.input_attachments {
        let mut array_140 = object.key("inputAttachments").start_array();
        for item_141 in var_139 {
            {
                let mut object_142 = array_140.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_attachment(
                    &mut object_142,
                    item_141,
                )?;
                object_142.finish();
            }
        }
        array_140.finish();
    }
    if let Some(var_143) = &input.input_specification {
        let mut object_144 = object.key("inputSpecification").start_object();
        crate::json_ser::serialize_structure_crate_model_input_specification(
            &mut object_144,
            var_143,
        )?;
        object_144.finish();
    }
    if let Some(var_145) = &input.log_level {
        object.key("logLevel").string(var_145.as_str());
    }
    if let Some(var_146) = &input.maintenance {
        let mut object_147 = object.key("maintenance").start_object();
        crate::json_ser::serialize_structure_crate_model_maintenance_update_settings(
            &mut object_147,
            var_146,
        )?;
        object_147.finish();
    }
    if let Some(var_148) = &input.name {
        object.key("name").string(var_148.as_str());
    }
    if let Some(var_149) = &input.role_arn {
        object.key("roleArn").string(var_149.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_150) = &input.channel_class {
        object.key("channelClass").string(var_150.as_str());
    }
    if let Some(var_151) = &input.destinations {
        let mut array_152 = object.key("destinations").start_array();
        for item_153 in var_151 {
            {
                let mut object_154 = array_152.value().start_object();
                crate::json_ser::serialize_structure_crate_model_output_destination(
                    &mut object_154,
                    item_153,
                )?;
                object_154.finish();
            }
        }
        array_152.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_155) = &input.destinations {
        let mut array_156 = object.key("destinations").start_array();
        for item_157 in var_155 {
            {
                let mut object_158 = array_156.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_destination_request(
                    &mut object_158,
                    item_157,
                )?;
                object_158.finish();
            }
        }
        array_156.finish();
    }
    if let Some(var_159) = &input.input_devices {
        let mut array_160 = object.key("inputDevices").start_array();
        for item_161 in var_159 {
            {
                let mut object_162 = array_160.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_device_request(
                    &mut object_162,
                    item_161,
                )?;
                object_162.finish();
            }
        }
        array_160.finish();
    }
    if let Some(var_163) = &input.input_security_groups {
        let mut array_164 = object.key("inputSecurityGroups").start_array();
        for item_165 in var_163 {
            {
                array_164.value().string(item_165.as_str());
            }
        }
        array_164.finish();
    }
    if let Some(var_166) = &input.media_connect_flows {
        let mut array_167 = object.key("mediaConnectFlows").start_array();
        for item_168 in var_166 {
            {
                let mut object_169 = array_167.value().start_object();
                crate::json_ser::serialize_structure_crate_model_media_connect_flow_request(
                    &mut object_169,
                    item_168,
                )?;
                object_169.finish();
            }
        }
        array_167.finish();
    }
    if let Some(var_170) = &input.name {
        object.key("name").string(var_170.as_str());
    }
    if let Some(var_171) = &input.role_arn {
        object.key("roleArn").string(var_171.as_str());
    }
    if let Some(var_172) = &input.sources {
        let mut array_173 = object.key("sources").start_array();
        for item_174 in var_172 {
            {
                let mut object_175 = array_173.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_source_request(
                    &mut object_175,
                    item_174,
                )?;
                object_175.finish();
            }
        }
        array_173.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_176) = &input.hd_device_settings {
        let mut object_177 = object.key("hdDeviceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_input_device_configurable_settings(
            &mut object_177,
            var_176,
        )?;
        object_177.finish();
    }
    if let Some(var_178) = &input.name {
        object.key("name").string(var_178.as_str());
    }
    if let Some(var_179) = &input.uhd_device_settings {
        let mut object_180 = object.key("uhdDeviceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_input_device_configurable_settings(
            &mut object_180,
            var_179,
        )?;
        object_180.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_181) = &input.tags {
        let mut object_182 = object.key("tags").start_object();
        for (key_183, value_184) in var_181 {
            {
                object_182.key(key_183).string(value_184.as_str());
            }
        }
        object_182.finish();
    }
    if let Some(var_185) = &input.whitelist_rules {
        let mut array_186 = object.key("whitelistRules").start_array();
        for item_187 in var_185 {
            {
                let mut object_188 = array_186.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_whitelist_rule_cidr(
                    &mut object_188,
                    item_187,
                )?;
                object_188.finish();
            }
        }
        array_186.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_189) = &input.multiplex_settings {
        let mut object_190 = object.key("multiplexSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_settings(
            &mut object_190,
            var_189,
        )?;
        object_190.finish();
    }
    if let Some(var_191) = &input.name {
        object.key("name").string(var_191.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_192) = &input.multiplex_program_settings {
        let mut object_193 = object.key("multiplexProgramSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_program_settings(
            &mut object_193,
            var_192,
        )?;
        object_193.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_194) = &input.name {
        object.key("name").string(var_194.as_str());
    }
    if let Some(var_195) = &input.renewal_settings {
        let mut object_196 = object.key("renewalSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_renewal_settings(
            &mut object_196,
            var_195,
        )?;
        object_196.finish();
    }
    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_197) = &input.schedule_actions {
        let mut array_198 = object.key("scheduleActions").start_array();
        for item_199 in var_197 {
            {
                let mut object_200 = array_198.value().start_object();
                crate::json_ser::serialize_structure_crate_model_schedule_action(
                    &mut object_200,
                    item_199,
                )?;
                object_200.finish();
            }
        }
        array_198.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_201) = &input.action_names {
        let mut array_202 = object.key("actionNames").start_array();
        for item_203 in var_201 {
            {
                array_202.value().string(item_203.as_str());
            }
        }
        array_202.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_204) = &input.resolution {
        object.key("resolution").string(var_204.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_205) = &input.id {
        object.key("id").string(var_205.as_str());
    }
    if let Some(var_206) = &input.media_package_settings {
        let mut array_207 = object.key("mediaPackageSettings").start_array();
        for item_208 in var_206 {
            {
                let mut object_209 = array_207.value().start_object();
                crate::json_ser::serialize_structure_crate_model_media_package_output_destination_settings(&mut object_209, item_208)?;
                object_209.finish();
            }
        }
        array_207.finish();
    }
    if let Some(var_210) = &input.multiplex_settings {
        let mut object_211 = object.key("multiplexSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_program_channel_destination_settings(&mut object_211, var_210)?;
        object_211.finish();
    }
    if let Some(var_212) = &input.settings {
        let mut array_213 = object.key("settings").start_array();
        for item_214 in var_212 {
            {
                let mut object_215 = array_213.value().start_object();
                crate::json_ser::serialize_structure_crate_model_output_destination_settings(
                    &mut object_215,
                    item_214,
                )?;
                object_215.finish();
            }
        }
        array_213.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_216) = &input.audio_descriptions {
        let mut array_217 = object.key("audioDescriptions").start_array();
        for item_218 in var_216 {
            {
                let mut object_219 = array_217.value().start_object();
                crate::json_ser::serialize_structure_crate_model_audio_description(
                    &mut object_219,
                    item_218,
                )?;
                object_219.finish();
            }
        }
        array_217.finish();
    }
    if let Some(var_220) = &input.avail_blanking {
        let mut object_221 = object.key("availBlanking").start_object();
        crate::json_ser::serialize_structure_crate_model_avail_blanking(&mut object_221, var_220)?;
        object_221.finish();
    }
    if let Some(var_222) = &input.avail_configuration {
        let mut object_223 = object.key("availConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_avail_configuration(
            &mut object_223,
            var_222,
        )?;
        object_223.finish();
    }
    if let Some(var_224) = &input.blackout_slate {
        let mut object_225 = object.key("blackoutSlate").start_object();
        crate::json_ser::serialize_structure_crate_model_blackout_slate(&mut object_225, var_224)?;
        object_225.finish();
    }
    if let Some(var_226) = &input.caption_descriptions {
        let mut array_227 = object.key("captionDescriptions").start_array();
        for item_228 in var_226 {
            {
                let mut object_229 = array_227.value().start_object();
                crate::json_ser::serialize_structure_crate_model_caption_description(
                    &mut object_229,
                    item_228,
                )?;
                object_229.finish();
            }
        }
        array_227.finish();
    }
    if let Some(var_230) = &input.feature_activations {
        let mut object_231 = object.key("featureActivations").start_object();
        crate::json_ser::serialize_structure_crate_model_feature_activations(
            &mut object_231,
            var_230,
        )?;
        object_231.finish();
    }
    if let Some(var_232) = &input.global_configuration {
        let mut object_233 = object.key("globalConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_global_configuration(
            &mut object_233,
            var_232,
        )?;
        object_233.finish();
    }
    if let Some(var_234) = &input.motion_graphics_configuration {
        let mut object_235 = object.key("motionGraphicsConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_motion_graphics_configuration(
            &mut object_235,
            var_234,
        )?;
        object_235.finish();
    }
    if let Some(var_236) = &input.nielsen_configuration {
        let mut object_237 = object.key("nielsenConfiguration").start_object();
        crate::json_ser::serialize_structure_crate_model_nielsen_configuration(
            &mut object_237,
            var_236,
        )?;
        object_237.finish();
    }
    if let Some(var_238) = &input.output_groups {
        let mut array_239 = object.key("outputGroups").start_array();
        for item_240 in var_238 {
            {
                let mut object_241 = array_239.value().start_object();
                crate::json_ser::serialize_structure_crate_model_output_group(
                    &mut object_241,
                    item_240,
                )?;
                object_241.finish();
            }
        }
        array_239.finish();
    }
    if let Some(var_242) = &input.timecode_config {
        let mut object_243 = object.key("timecodeConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_timecode_config(&mut object_243, var_242)?;
        object_243.finish();
    }
    if let Some(var_244) = &input.video_descriptions {
        let mut array_245 = object.key("videoDescriptions").start_array();
        for item_246 in var_244 {
            {
                let mut object_247 = array_245.value().start_object();
                crate::json_ser::serialize_structure_crate_model_video_description(
                    &mut object_247,
                    item_246,
                )?;
                object_247.finish();
            }
        }
        array_245.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_248) = &input.automatic_input_failover_settings {
        let mut object_249 = object.key("automaticInputFailoverSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_automatic_input_failover_settings(
            &mut object_249,
            var_248,
        )?;
        object_249.finish();
    }
    if let Some(var_250) = &input.input_attachment_name {
        object.key("inputAttachmentName").string(var_250.as_str());
    }
    if let Some(var_251) = &input.input_id {
        object.key("inputId").string(var_251.as_str());
    }
    if let Some(var_252) = &input.input_settings {
        let mut object_253 = object.key("inputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_input_settings(&mut object_253, var_252)?;
        object_253.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_254) = &input.codec {
        object.key("codec").string(var_254.as_str());
    }
    if let Some(var_255) = &input.maximum_bitrate {
        object.key("maximumBitrate").string(var_255.as_str());
    }
    if let Some(var_256) = &input.resolution {
        object.key("resolution").string(var_256.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_maintenance_create_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MaintenanceCreateSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_257) = &input.maintenance_day {
        object.key("maintenanceDay").string(var_257.as_str());
    }
    if let Some(var_258) = &input.maintenance_start_time {
        object.key("maintenanceStartTime").string(var_258.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_259) = &input.public_address_allocation_ids {
        let mut array_260 = object.key("publicAddressAllocationIds").start_array();
        for item_261 in var_259 {
            {
                array_260.value().string(item_261.as_str());
            }
        }
        array_260.finish();
    }
    if let Some(var_262) = &input.security_group_ids {
        let mut array_263 = object.key("securityGroupIds").start_array();
        for item_264 in var_262 {
            {
                array_263.value().string(item_264.as_str());
            }
        }
        array_263.finish();
    }
    if let Some(var_265) = &input.subnet_ids {
        let mut array_266 = object.key("subnetIds").start_array();
        for item_267 in var_265 {
            {
                array_266.value().string(item_267.as_str());
            }
        }
        array_266.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_268) = &input.stream_name {
        object.key("streamName").string(var_268.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_269) = &input.id {
        object.key("id").string(var_269.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_270) = &input.flow_arn {
        object.key("flowArn").string(var_270.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_271) = &input.password_param {
        object.key("passwordParam").string(var_271.as_str());
    }
    if let Some(var_272) = &input.url {
        object.key("url").string(var_272.as_str());
    }
    if let Some(var_273) = &input.username {
        object.key("username").string(var_273.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_274) = &input.security_group_ids {
        let mut array_275 = object.key("securityGroupIds").start_array();
        for item_276 in var_274 {
            {
                array_275.value().string(item_276.as_str());
            }
        }
        array_275.finish();
    }
    if let Some(var_277) = &input.subnet_ids {
        let mut array_278 = object.key("subnetIds").start_array();
        for item_279 in var_277 {
            {
                array_278.value().string(item_279.as_str());
            }
        }
        array_278.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_280) = &input.cidr {
        object.key("cidr").string(var_280.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_281) = &input.preferred_channel_pipeline {
        object
            .key("preferredChannelPipeline")
            .string(var_281.as_str());
    }
    {
        object.key("programNumber").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.program_number).into()),
        );
    }
    if let Some(var_282) = &input.service_descriptor {
        let mut object_283 = object.key("serviceDescriptor").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_program_service_descriptor(
            &mut object_283,
            var_282,
        )?;
        object_283.finish();
    }
    if let Some(var_284) = &input.video_settings {
        let mut object_285 = object.key("videoSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_video_settings(
            &mut object_285,
            var_284,
        )?;
        object_285.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_renewal_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::RenewalSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_286) = &input.automatic_renewal {
        object.key("automaticRenewal").string(var_286.as_str());
    }
    if input.renewal_count != 0 {
        object.key("renewalCount").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.renewal_count).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_maintenance_update_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MaintenanceUpdateSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_287) = &input.maintenance_day {
        object.key("maintenanceDay").string(var_287.as_str());
    }
    if let Some(var_288) = &input.maintenance_scheduled_date {
        object
            .key("maintenanceScheduledDate")
            .string(var_288.as_str());
    }
    if let Some(var_289) = &input.maintenance_start_time {
        object.key("maintenanceStartTime").string(var_289.as_str());
    }
    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_290) = &input.id {
        object.key("id").string(var_290.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_291) = &input.configured_input {
        object.key("configuredInput").string(var_291.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_292) = &input.action_name {
        object.key("actionName").string(var_292.as_str());
    }
    if let Some(var_293) = &input.schedule_action_settings {
        let mut object_294 = object.key("scheduleActionSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_schedule_action_settings(
            &mut object_294,
            var_293,
        )?;
        object_294.finish();
    }
    if let Some(var_295) = &input.schedule_action_start_settings {
        let mut object_296 = object.key("scheduleActionStartSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_schedule_action_start_settings(
            &mut object_296,
            var_295,
        )?;
        object_296.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_297) = &input.channel_id {
        object.key("channelId").string(var_297.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_298) = &input.multiplex_id {
        object.key("multiplexId").string(var_298.as_str());
    }
    if let Some(var_299) = &input.program_name {
        object.key("programName").string(var_299.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_300) = &input.password_param {
        object.key("passwordParam").string(var_300.as_str());
    }
    if let Some(var_301) = &input.stream_name {
        object.key("streamName").string(var_301.as_str());
    }
    if let Some(var_302) = &input.url {
        object.key("url").string(var_302.as_str());
    }
    if let Some(var_303) = &input.username {
        object.key("username").string(var_303.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_304) = &input.audio_normalization_settings {
        let mut object_305 = object.key("audioNormalizationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_normalization_settings(
            &mut object_305,
            var_304,
        )?;
        object_305.finish();
    }
    if let Some(var_306) = &input.audio_selector_name {
        object.key("audioSelectorName").string(var_306.as_str());
    }
    if let Some(var_307) = &input.audio_type {
        object.key("audioType").string(var_307.as_str());
    }
    if let Some(var_308) = &input.audio_type_control {
        object.key("audioTypeControl").string(var_308.as_str());
    }
    if let Some(var_309) = &input.audio_watermarking_settings {
        let mut object_310 = object.key("audioWatermarkingSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_watermark_settings(
            &mut object_310,
            var_309,
        )?;
        object_310.finish();
    }
    if let Some(var_311) = &input.codec_settings {
        let mut object_312 = object.key("codecSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_codec_settings(
            &mut object_312,
            var_311,
        )?;
        object_312.finish();
    }
    if let Some(var_313) = &input.language_code {
        object.key("languageCode").string(var_313.as_str());
    }
    if let Some(var_314) = &input.language_code_control {
        object.key("languageCodeControl").string(var_314.as_str());
    }
    if let Some(var_315) = &input.name {
        object.key("name").string(var_315.as_str());
    }
    if let Some(var_316) = &input.remix_settings {
        let mut object_317 = object.key("remixSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_remix_settings(&mut object_317, var_316)?;
        object_317.finish();
    }
    if let Some(var_318) = &input.stream_name {
        object.key("streamName").string(var_318.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_319) = &input.avail_blanking_image {
        let mut object_320 = object.key("availBlankingImage").start_object();
        crate::json_ser::serialize_structure_crate_model_input_location(&mut object_320, var_319)?;
        object_320.finish();
    }
    if let Some(var_321) = &input.state {
        object.key("state").string(var_321.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_322) = &input.avail_settings {
        let mut object_323 = object.key("availSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_avail_settings(&mut object_323, var_322)?;
        object_323.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_324) = &input.blackout_slate_image {
        let mut object_325 = object.key("blackoutSlateImage").start_object();
        crate::json_ser::serialize_structure_crate_model_input_location(&mut object_325, var_324)?;
        object_325.finish();
    }
    if let Some(var_326) = &input.network_end_blackout {
        object.key("networkEndBlackout").string(var_326.as_str());
    }
    if let Some(var_327) = &input.network_end_blackout_image {
        let mut object_328 = object.key("networkEndBlackoutImage").start_object();
        crate::json_ser::serialize_structure_crate_model_input_location(&mut object_328, var_327)?;
        object_328.finish();
    }
    if let Some(var_329) = &input.network_id {
        object.key("networkId").string(var_329.as_str());
    }
    if let Some(var_330) = &input.state {
        object.key("state").string(var_330.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_331) = &input.accessibility {
        object.key("accessibility").string(var_331.as_str());
    }
    if let Some(var_332) = &input.caption_selector_name {
        object.key("captionSelectorName").string(var_332.as_str());
    }
    if let Some(var_333) = &input.destination_settings {
        let mut object_334 = object.key("destinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_caption_destination_settings(
            &mut object_334,
            var_333,
        )?;
        object_334.finish();
    }
    if let Some(var_335) = &input.language_code {
        object.key("languageCode").string(var_335.as_str());
    }
    if let Some(var_336) = &input.language_description {
        object.key("languageDescription").string(var_336.as_str());
    }
    if let Some(var_337) = &input.name {
        object.key("name").string(var_337.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_338) = &input.input_prepare_schedule_actions {
        object
            .key("inputPrepareScheduleActions")
            .string(var_338.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_339) = &input.input_end_action {
        object.key("inputEndAction").string(var_339.as_str());
    }
    if let Some(var_340) = &input.input_loss_behavior {
        let mut object_341 = object.key("inputLossBehavior").start_object();
        crate::json_ser::serialize_structure_crate_model_input_loss_behavior(
            &mut object_341,
            var_340,
        )?;
        object_341.finish();
    }
    if let Some(var_342) = &input.output_locking_mode {
        object.key("outputLockingMode").string(var_342.as_str());
    }
    if let Some(var_343) = &input.output_timing_source {
        object.key("outputTimingSource").string(var_343.as_str());
    }
    if let Some(var_344) = &input.support_low_framerate_inputs {
        object
            .key("supportLowFramerateInputs")
            .string(var_344.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_345) = &input.motion_graphics_insertion {
        object
            .key("motionGraphicsInsertion")
            .string(var_345.as_str());
    }
    if let Some(var_346) = &input.motion_graphics_settings {
        let mut object_347 = object.key("motionGraphicsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_motion_graphics_settings(
            &mut object_347,
            var_346,
        )?;
        object_347.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_348) = &input.distributor_id {
        object.key("distributorId").string(var_348.as_str());
    }
    if let Some(var_349) = &input.nielsen_pcm_to_id3_tagging {
        object
            .key("nielsenPcmToId3Tagging")
            .string(var_349.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_350) = &input.name {
        object.key("name").string(var_350.as_str());
    }
    if let Some(var_351) = &input.output_group_settings {
        let mut object_352 = object.key("outputGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_output_group_settings(
            &mut object_352,
            var_351,
        )?;
        object_352.finish();
    }
    if let Some(var_353) = &input.outputs {
        let mut array_354 = object.key("outputs").start_array();
        for item_355 in var_353 {
            {
                let mut object_356 = array_354.value().start_object();
                crate::json_ser::serialize_structure_crate_model_output(&mut object_356, item_355)?;
                object_356.finish();
            }
        }
        array_354.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_357) = &input.source {
        object.key("source").string(var_357.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_358) = &input.codec_settings {
        let mut object_359 = object.key("codecSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_video_codec_settings(
            &mut object_359,
            var_358,
        )?;
        object_359.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_360) = &input.name {
        object.key("name").string(var_360.as_str());
    }
    if let Some(var_361) = &input.respond_to_afd {
        object.key("respondToAfd").string(var_361.as_str());
    }
    if let Some(var_362) = &input.scaling_behavior {
        object.key("scalingBehavior").string(var_362.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_363) = &input.failover_conditions {
        let mut array_364 = object.key("failoverConditions").start_array();
        for item_365 in var_363 {
            {
                let mut object_366 = array_364.value().start_object();
                crate::json_ser::serialize_structure_crate_model_failover_condition(
                    &mut object_366,
                    item_365,
                )?;
                object_366.finish();
            }
        }
        array_364.finish();
    }
    if let Some(var_367) = &input.input_preference {
        object.key("inputPreference").string(var_367.as_str());
    }
    if let Some(var_368) = &input.secondary_input_id {
        object.key("secondaryInputId").string(var_368.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_369) = &input.audio_selectors {
        let mut array_370 = object.key("audioSelectors").start_array();
        for item_371 in var_369 {
            {
                let mut object_372 = array_370.value().start_object();
                crate::json_ser::serialize_structure_crate_model_audio_selector(
                    &mut object_372,
                    item_371,
                )?;
                object_372.finish();
            }
        }
        array_370.finish();
    }
    if let Some(var_373) = &input.caption_selectors {
        let mut array_374 = object.key("captionSelectors").start_array();
        for item_375 in var_373 {
            {
                let mut object_376 = array_374.value().start_object();
                crate::json_ser::serialize_structure_crate_model_caption_selector(
                    &mut object_376,
                    item_375,
                )?;
                object_376.finish();
            }
        }
        array_374.finish();
    }
    if let Some(var_377) = &input.deblock_filter {
        object.key("deblockFilter").string(var_377.as_str());
    }
    if let Some(var_378) = &input.denoise_filter {
        object.key("denoiseFilter").string(var_378.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_379) = &input.input_filter {
        object.key("inputFilter").string(var_379.as_str());
    }
    if let Some(var_380) = &input.network_input_settings {
        let mut object_381 = object.key("networkInputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_network_input_settings(
            &mut object_381,
            var_380,
        )?;
        object_381.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_382) = &input.smpte2038_data_preference {
        object
            .key("smpte2038DataPreference")
            .string(var_382.as_str());
    }
    if let Some(var_383) = &input.source_end_behavior {
        object.key("sourceEndBehavior").string(var_383.as_str());
    }
    if let Some(var_384) = &input.video_selector {
        let mut object_385 = object.key("videoSelector").start_object();
        crate::json_ser::serialize_structure_crate_model_video_selector(&mut object_385, var_384)?;
        object_385.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_386) = &input.provider_name {
        object.key("providerName").string(var_386.as_str());
    }
    if let Some(var_387) = &input.service_name {
        object.key("serviceName").string(var_387.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_388) = &input.statmux_settings {
        let mut object_389 = object.key("statmuxSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_statmux_video_settings(
            &mut object_389,
            var_388,
        )?;
        object_389.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_390) = &input.hls_id3_segment_tagging_settings {
        let mut object_391 = object.key("hlsId3SegmentTaggingSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_id3_segment_tagging_schedule_action_settings(&mut object_391, var_390)?;
        object_391.finish();
    }
    if let Some(var_392) = &input.hls_timed_metadata_settings {
        let mut object_393 = object.key("hlsTimedMetadataSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_timed_metadata_schedule_action_settings(&mut object_393, var_392)?;
        object_393.finish();
    }
    if let Some(var_394) = &input.input_prepare_settings {
        let mut object_395 = object.key("inputPrepareSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_input_prepare_schedule_action_settings(
            &mut object_395,
            var_394,
        )?;
        object_395.finish();
    }
    if let Some(var_396) = &input.input_switch_settings {
        let mut object_397 = object.key("inputSwitchSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_input_switch_schedule_action_settings(
            &mut object_397,
            var_396,
        )?;
        object_397.finish();
    }
    if let Some(var_398) = &input.motion_graphics_image_activate_settings {
        let mut object_399 = object
            .key("motionGraphicsImageActivateSettings")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_motion_graphics_activate_schedule_action_settings(&mut object_399, var_398)?;
        object_399.finish();
    }
    if let Some(var_400) = &input.motion_graphics_image_deactivate_settings {
        let mut object_401 = object
            .key("motionGraphicsImageDeactivateSettings")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_motion_graphics_deactivate_schedule_action_settings(&mut object_401, var_400)?;
        object_401.finish();
    }
    if let Some(var_402) = &input.pause_state_settings {
        let mut object_403 = object.key("pauseStateSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_pause_state_schedule_action_settings(
            &mut object_403,
            var_402,
        )?;
        object_403.finish();
    }
    if let Some(var_404) = &input.scte35_return_to_network_settings {
        let mut object_405 = object.key("scte35ReturnToNetworkSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_scte35_return_to_network_schedule_action_settings(&mut object_405, var_404)?;
        object_405.finish();
    }
    if let Some(var_406) = &input.scte35_splice_insert_settings {
        let mut object_407 = object.key("scte35SpliceInsertSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_scte35_splice_insert_schedule_action_settings(&mut object_407, var_406)?;
        object_407.finish();
    }
    if let Some(var_408) = &input.scte35_time_signal_settings {
        let mut object_409 = object.key("scte35TimeSignalSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_scte35_time_signal_schedule_action_settings(&mut object_409, var_408)?;
        object_409.finish();
    }
    if let Some(var_410) = &input.static_image_activate_settings {
        let mut object_411 = object.key("staticImageActivateSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_static_image_activate_schedule_action_settings(&mut object_411, var_410)?;
        object_411.finish();
    }
    if let Some(var_412) = &input.static_image_deactivate_settings {
        let mut object_413 = object.key("staticImageDeactivateSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_static_image_deactivate_schedule_action_settings(&mut object_413, var_412)?;
        object_413.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_414) = &input.fixed_mode_schedule_action_start_settings {
        let mut object_415 = object
            .key("fixedModeScheduleActionStartSettings")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_fixed_mode_schedule_action_start_settings(
            &mut object_415,
            var_414,
        )?;
        object_415.finish();
    }
    if let Some(var_416) = &input.follow_mode_schedule_action_start_settings {
        let mut object_417 = object
            .key("followModeScheduleActionStartSettings")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_follow_mode_schedule_action_start_settings(&mut object_417, var_416)?;
        object_417.finish();
    }
    if let Some(var_418) = &input.immediate_mode_schedule_action_start_settings {
        let mut object_419 = object
            .key("immediateModeScheduleActionStartSettings")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_immediate_mode_schedule_action_start_settings(&mut object_419, var_418)?;
        object_419.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_420) = &input.algorithm {
        object.key("algorithm").string(var_420.as_str());
    }
    if let Some(var_421) = &input.algorithm_control {
        object.key("algorithmControl").string(var_421.as_str());
    }
    if input.target_lkfs != 0.0 {
        object.key("targetLkfs").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::Float((input.target_lkfs).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_audio_watermark_settings(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AudioWatermarkSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_422) = &input.nielsen_watermarks_settings {
        let mut object_423 = object.key("nielsenWatermarksSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_nielsen_watermarks_settings(
            &mut object_423,
            var_422,
        )?;
        object_423.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_424) = &input.aac_settings {
        let mut object_425 = object.key("aacSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_aac_settings(&mut object_425, var_424)?;
        object_425.finish();
    }
    if let Some(var_426) = &input.ac3_settings {
        let mut object_427 = object.key("ac3Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_ac3_settings(&mut object_427, var_426)?;
        object_427.finish();
    }
    if let Some(var_428) = &input.eac3_settings {
        let mut object_429 = object.key("eac3Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_eac3_settings(&mut object_429, var_428)?;
        object_429.finish();
    }
    if let Some(var_430) = &input.mp2_settings {
        let mut object_431 = object.key("mp2Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_mp2_settings(&mut object_431, var_430)?;
        object_431.finish();
    }
    if let Some(var_432) = &input.pass_through_settings {
        let mut object_433 = object.key("passThroughSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_pass_through_settings(
            &mut object_433,
            var_432,
        )?;
        object_433.finish();
    }
    if let Some(var_434) = &input.wav_settings {
        let mut object_435 = object.key("wavSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_wav_settings(&mut object_435, var_434)?;
        object_435.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_436) = &input.channel_mappings {
        let mut array_437 = object.key("channelMappings").start_array();
        for item_438 in var_436 {
            {
                let mut object_439 = array_437.value().start_object();
                crate::json_ser::serialize_structure_crate_model_audio_channel_mapping(
                    &mut object_439,
                    item_438,
                )?;
                object_439.finish();
            }
        }
        array_437.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_440) = &input.password_param {
        object.key("passwordParam").string(var_440.as_str());
    }
    if let Some(var_441) = &input.uri {
        object.key("uri").string(var_441.as_str());
    }
    if let Some(var_442) = &input.username {
        object.key("username").string(var_442.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_443) = &input.scte35_splice_insert {
        let mut object_444 = object.key("scte35SpliceInsert").start_object();
        crate::json_ser::serialize_structure_crate_model_scte35_splice_insert(
            &mut object_444,
            var_443,
        )?;
        object_444.finish();
    }
    if let Some(var_445) = &input.scte35_time_signal_apos {
        let mut object_446 = object.key("scte35TimeSignalApos").start_object();
        crate::json_ser::serialize_structure_crate_model_scte35_time_signal_apos(
            &mut object_446,
            var_445,
        )?;
        object_446.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_447) = &input.arib_destination_settings {
        let mut object_448 = object.key("aribDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_arib_destination_settings(
            &mut object_448,
            var_447,
        )?;
        object_448.finish();
    }
    if let Some(var_449) = &input.burn_in_destination_settings {
        let mut object_450 = object.key("burnInDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_burn_in_destination_settings(
            &mut object_450,
            var_449,
        )?;
        object_450.finish();
    }
    if let Some(var_451) = &input.dvb_sub_destination_settings {
        let mut object_452 = object.key("dvbSubDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_dvb_sub_destination_settings(
            &mut object_452,
            var_451,
        )?;
        object_452.finish();
    }
    if let Some(var_453) = &input.ebu_tt_d_destination_settings {
        let mut object_454 = object.key("ebuTtDDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_ebu_tt_d_destination_settings(
            &mut object_454,
            var_453,
        )?;
        object_454.finish();
    }
    if let Some(var_455) = &input.embedded_destination_settings {
        let mut object_456 = object.key("embeddedDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_embedded_destination_settings(
            &mut object_456,
            var_455,
        )?;
        object_456.finish();
    }
    if let Some(var_457) = &input.embedded_plus_scte20_destination_settings {
        let mut object_458 = object
            .key("embeddedPlusScte20DestinationSettings")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_embedded_plus_scte20_destination_settings(
            &mut object_458,
            var_457,
        )?;
        object_458.finish();
    }
    if let Some(var_459) = &input.rtmp_caption_info_destination_settings {
        let mut object_460 = object
            .key("rtmpCaptionInfoDestinationSettings")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_rtmp_caption_info_destination_settings(
            &mut object_460,
            var_459,
        )?;
        object_460.finish();
    }
    if let Some(var_461) = &input.scte20_plus_embedded_destination_settings {
        let mut object_462 = object
            .key("scte20PlusEmbeddedDestinationSettings")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_scte20_plus_embedded_destination_settings(
            &mut object_462,
            var_461,
        )?;
        object_462.finish();
    }
    if let Some(var_463) = &input.scte27_destination_settings {
        let mut object_464 = object.key("scte27DestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_scte27_destination_settings(
            &mut object_464,
            var_463,
        )?;
        object_464.finish();
    }
    if let Some(var_465) = &input.smpte_tt_destination_settings {
        let mut object_466 = object.key("smpteTtDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_smpte_tt_destination_settings(
            &mut object_466,
            var_465,
        )?;
        object_466.finish();
    }
    if let Some(var_467) = &input.teletext_destination_settings {
        let mut object_468 = object.key("teletextDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_teletext_destination_settings(
            &mut object_468,
            var_467,
        )?;
        object_468.finish();
    }
    if let Some(var_469) = &input.ttml_destination_settings {
        let mut object_470 = object.key("ttmlDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_ttml_destination_settings(
            &mut object_470,
            var_469,
        )?;
        object_470.finish();
    }
    if let Some(var_471) = &input.webvtt_destination_settings {
        let mut object_472 = object.key("webvttDestinationSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_webvtt_destination_settings(
            &mut object_472,
            var_471,
        )?;
        object_472.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_473) = &input.input_loss_image_color {
        object.key("inputLossImageColor").string(var_473.as_str());
    }
    if let Some(var_474) = &input.input_loss_image_slate {
        let mut object_475 = object.key("inputLossImageSlate").start_object();
        crate::json_ser::serialize_structure_crate_model_input_location(&mut object_475, var_474)?;
        object_475.finish();
    }
    if let Some(var_476) = &input.input_loss_image_type {
        object.key("inputLossImageType").string(var_476.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_477) = &input.html_motion_graphics_settings {
        let mut object_478 = object.key("htmlMotionGraphicsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_html_motion_graphics_settings(
            &mut object_478,
            var_477,
        )?;
        object_478.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_479) = &input.archive_group_settings {
        let mut object_480 = object.key("archiveGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_archive_group_settings(
            &mut object_480,
            var_479,
        )?;
        object_480.finish();
    }
    if let Some(var_481) = &input.frame_capture_group_settings {
        let mut object_482 = object.key("frameCaptureGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_frame_capture_group_settings(
            &mut object_482,
            var_481,
        )?;
        object_482.finish();
    }
    if let Some(var_483) = &input.hls_group_settings {
        let mut object_484 = object.key("hlsGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_group_settings(
            &mut object_484,
            var_483,
        )?;
        object_484.finish();
    }
    if let Some(var_485) = &input.media_package_group_settings {
        let mut object_486 = object.key("mediaPackageGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_media_package_group_settings(
            &mut object_486,
            var_485,
        )?;
        object_486.finish();
    }
    if let Some(var_487) = &input.ms_smooth_group_settings {
        let mut object_488 = object.key("msSmoothGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_ms_smooth_group_settings(
            &mut object_488,
            var_487,
        )?;
        object_488.finish();
    }
    if let Some(var_489) = &input.multiplex_group_settings {
        let mut object_490 = object.key("multiplexGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_group_settings(
            &mut object_490,
            var_489,
        )?;
        object_490.finish();
    }
    if let Some(var_491) = &input.rtmp_group_settings {
        let mut object_492 = object.key("rtmpGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_rtmp_group_settings(
            &mut object_492,
            var_491,
        )?;
        object_492.finish();
    }
    if let Some(var_493) = &input.udp_group_settings {
        let mut object_494 = object.key("udpGroupSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_udp_group_settings(
            &mut object_494,
            var_493,
        )?;
        object_494.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_495) = &input.audio_description_names {
        let mut array_496 = object.key("audioDescriptionNames").start_array();
        for item_497 in var_495 {
            {
                array_496.value().string(item_497.as_str());
            }
        }
        array_496.finish();
    }
    if let Some(var_498) = &input.caption_description_names {
        let mut array_499 = object.key("captionDescriptionNames").start_array();
        for item_500 in var_498 {
            {
                array_499.value().string(item_500.as_str());
            }
        }
        array_499.finish();
    }
    if let Some(var_501) = &input.output_name {
        object.key("outputName").string(var_501.as_str());
    }
    if let Some(var_502) = &input.output_settings {
        let mut object_503 = object.key("outputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_output_settings(&mut object_503, var_502)?;
        object_503.finish();
    }
    if let Some(var_504) = &input.video_description_name {
        object.key("videoDescriptionName").string(var_504.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_505) = &input.frame_capture_settings {
        let mut object_506 = object.key("frameCaptureSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_frame_capture_settings(
            &mut object_506,
            var_505,
        )?;
        object_506.finish();
    }
    if let Some(var_507) = &input.h264_settings {
        let mut object_508 = object.key("h264Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_h264_settings(&mut object_508, var_507)?;
        object_508.finish();
    }
    if let Some(var_509) = &input.h265_settings {
        let mut object_510 = object.key("h265Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_h265_settings(&mut object_510, var_509)?;
        object_510.finish();
    }
    if let Some(var_511) = &input.mpeg2_settings {
        let mut object_512 = object.key("mpeg2Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_mpeg2_settings(&mut object_512, var_511)?;
        object_512.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_513) = &input.failover_condition_settings {
        let mut object_514 = object.key("failoverConditionSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_failover_condition_settings(
            &mut object_514,
            var_513,
        )?;
        object_514.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_515) = &input.name {
        object.key("name").string(var_515.as_str());
    }
    if let Some(var_516) = &input.selector_settings {
        let mut object_517 = object.key("selectorSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_selector_settings(
            &mut object_517,
            var_516,
        )?;
        object_517.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_518) = &input.language_code {
        object.key("languageCode").string(var_518.as_str());
    }
    if let Some(var_519) = &input.name {
        object.key("name").string(var_519.as_str());
    }
    if let Some(var_520) = &input.selector_settings {
        let mut object_521 = object.key("selectorSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_caption_selector_settings(
            &mut object_521,
            var_520,
        )?;
        object_521.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_522) = &input.hls_input_settings {
        let mut object_523 = object.key("hlsInputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_input_settings(
            &mut object_523,
            var_522,
        )?;
        object_523.finish();
    }
    if let Some(var_524) = &input.server_validation {
        object.key("serverValidation").string(var_524.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_525) = &input.color_space {
        object.key("colorSpace").string(var_525.as_str());
    }
    if let Some(var_526) = &input.color_space_settings {
        let mut object_527 = object.key("colorSpaceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_video_selector_color_space_settings(
            &mut object_527,
            var_526,
        )?;
        object_527.finish();
    }
    if let Some(var_528) = &input.color_space_usage {
        object.key("colorSpaceUsage").string(var_528.as_str());
    }
    if let Some(var_529) = &input.selector_settings {
        let mut object_530 = object.key("selectorSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_video_selector_settings(
            &mut object_530,
            var_529,
        )?;
        object_530.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_531) = &input.tag {
        object.key("tag").string(var_531.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_532) = &input.id3 {
        object.key("id3").string(var_532.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_533) = &input.input_attachment_name_reference {
        object
            .key("inputAttachmentNameReference")
            .string(var_533.as_str());
    }
    if let Some(var_534) = &input.input_clipping_settings {
        let mut object_535 = object.key("inputClippingSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_input_clipping_settings(
            &mut object_535,
            var_534,
        )?;
        object_535.finish();
    }
    if let Some(var_536) = &input.url_path {
        let mut array_537 = object.key("urlPath").start_array();
        for item_538 in var_536 {
            {
                array_537.value().string(item_538.as_str());
            }
        }
        array_537.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_539) = &input.input_attachment_name_reference {
        object
            .key("inputAttachmentNameReference")
            .string(var_539.as_str());
    }
    if let Some(var_540) = &input.input_clipping_settings {
        let mut object_541 = object.key("inputClippingSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_input_clipping_settings(
            &mut object_541,
            var_540,
        )?;
        object_541.finish();
    }
    if let Some(var_542) = &input.url_path {
        let mut array_543 = object.key("urlPath").start_array();
        for item_544 in var_542 {
            {
                array_543.value().string(item_544.as_str());
            }
        }
        array_543.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_545) = &input.password_param {
        object.key("passwordParam").string(var_545.as_str());
    }
    if let Some(var_546) = &input.url {
        object.key("url").string(var_546.as_str());
    }
    if let Some(var_547) = &input.username {
        object.key("username").string(var_547.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_548) = &input.pipelines {
        let mut array_549 = object.key("pipelines").start_array();
        for item_550 in var_548 {
            {
                let mut object_551 = array_549.value().start_object();
                crate::json_ser::serialize_structure_crate_model_pipeline_pause_state_settings(
                    &mut object_551,
                    item_550,
                )?;
                object_551.finish();
            }
        }
        array_549.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_552) = &input.scte35_descriptors {
        let mut array_553 = object.key("scte35Descriptors").start_array();
        for item_554 in var_552 {
            {
                let mut object_555 = array_553.value().start_object();
                crate::json_ser::serialize_structure_crate_model_scte35_descriptor(
                    &mut object_555,
                    item_554,
                )?;
                object_555.finish();
            }
        }
        array_553.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_556) = &input.image {
        let mut object_557 = object.key("image").start_object();
        crate::json_ser::serialize_structure_crate_model_input_location(&mut object_557, var_556)?;
        object_557.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_558) = &input.time {
        object.key("time").string(var_558.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_559) = &input.follow_point {
        object.key("followPoint").string(var_559.as_str());
    }
    if let Some(var_560) = &input.reference_action_name {
        object.key("referenceActionName").string(var_560.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_561) = &input.nielsen_cbet_settings {
        let mut object_562 = object.key("nielsenCbetSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_nielsen_cbet(&mut object_562, var_561)?;
        object_562.finish();
    }
    if let Some(var_563) = &input.nielsen_distribution_type {
        object
            .key("nielsenDistributionType")
            .string(var_563.as_str());
    }
    if let Some(var_564) = &input.nielsen_naes_ii_nw_settings {
        let mut object_565 = object.key("nielsenNaesIiNwSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_nielsen_naes_ii_nw(
            &mut object_565,
            var_564,
        )?;
        object_565.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_566) = &input.coding_mode {
        object.key("codingMode").string(var_566.as_str());
    }
    if let Some(var_567) = &input.input_type {
        object.key("inputType").string(var_567.as_str());
    }
    if let Some(var_568) = &input.profile {
        object.key("profile").string(var_568.as_str());
    }
    if let Some(var_569) = &input.rate_control_mode {
        object.key("rateControlMode").string(var_569.as_str());
    }
    if let Some(var_570) = &input.raw_format {
        object.key("rawFormat").string(var_570.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_571) = &input.spec {
        object.key("spec").string(var_571.as_str());
    }
    if let Some(var_572) = &input.vbr_quality {
        object.key("vbrQuality").string(var_572.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_573) = &input.bitstream_mode {
        object.key("bitstreamMode").string(var_573.as_str());
    }
    if let Some(var_574) = &input.coding_mode {
        object.key("codingMode").string(var_574.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_575) = &input.drc_profile {
        object.key("drcProfile").string(var_575.as_str());
    }
    if let Some(var_576) = &input.lfe_filter {
        object.key("lfeFilter").string(var_576.as_str());
    }
    if let Some(var_577) = &input.metadata_control {
        object.key("metadataControl").string(var_577.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_578) = &input.attenuation_control {
        object.key("attenuationControl").string(var_578.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_579) = &input.bitstream_mode {
        object.key("bitstreamMode").string(var_579.as_str());
    }
    if let Some(var_580) = &input.coding_mode {
        object.key("codingMode").string(var_580.as_str());
    }
    if let Some(var_581) = &input.dc_filter {
        object.key("dcFilter").string(var_581.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_582) = &input.drc_line {
        object.key("drcLine").string(var_582.as_str());
    }
    if let Some(var_583) = &input.drc_rf {
        object.key("drcRf").string(var_583.as_str());
    }
    if let Some(var_584) = &input.lfe_control {
        object.key("lfeControl").string(var_584.as_str());
    }
    if let Some(var_585) = &input.lfe_filter {
        object.key("lfeFilter").string(var_585.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_586) = &input.metadata_control {
        object.key("metadataControl").string(var_586.as_str());
    }
    if let Some(var_587) = &input.passthrough_control {
        object.key("passthroughControl").string(var_587.as_str());
    }
    if let Some(var_588) = &input.phase_control {
        object.key("phaseControl").string(var_588.as_str());
    }
    if let Some(var_589) = &input.stereo_downmix {
        object.key("stereoDownmix").string(var_589.as_str());
    }
    if let Some(var_590) = &input.surround_ex_mode {
        object.key("surroundExMode").string(var_590.as_str());
    }
    if let Some(var_591) = &input.surround_mode {
        object.key("surroundMode").string(var_591.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_592) = &input.coding_mode {
        object.key("codingMode").string(var_592.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_593) = &input.coding_mode {
        object.key("codingMode").string(var_593.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_594) = &input.input_channel_levels {
        let mut array_595 = object.key("inputChannelLevels").start_array();
        for item_596 in var_594 {
            {
                let mut object_597 = array_595.value().start_object();
                crate::json_ser::serialize_structure_crate_model_input_channel_level(
                    &mut object_597,
                    item_596,
                )?;
                object_597.finish();
            }
        }
        array_595.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_598) = &input.no_regional_blackout_flag {
        object
            .key("noRegionalBlackoutFlag")
            .string(var_598.as_str());
    }
    if let Some(var_599) = &input.web_delivery_allowed_flag {
        object
            .key("webDeliveryAllowedFlag")
            .string(var_599.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_600) = &input.no_regional_blackout_flag {
        object
            .key("noRegionalBlackoutFlag")
            .string(var_600.as_str());
    }
    if let Some(var_601) = &input.web_delivery_allowed_flag {
        object
            .key("webDeliveryAllowedFlag")
            .string(var_601.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_602) = &input.alignment {
        object.key("alignment").string(var_602.as_str());
    }
    if let Some(var_603) = &input.background_color {
        object.key("backgroundColor").string(var_603.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_604) = &input.font {
        let mut object_605 = object.key("font").start_object();
        crate::json_ser::serialize_structure_crate_model_input_location(&mut object_605, var_604)?;
        object_605.finish();
    }
    if let Some(var_606) = &input.font_color {
        object.key("fontColor").string(var_606.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_607) = &input.font_size {
        object.key("fontSize").string(var_607.as_str());
    }
    if let Some(var_608) = &input.outline_color {
        object.key("outlineColor").string(var_608.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_609) = &input.shadow_color {
        object.key("shadowColor").string(var_609.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_610) = &input.teletext_grid_control {
        object.key("teletextGridControl").string(var_610.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_611) = &input.alignment {
        object.key("alignment").string(var_611.as_str());
    }
    if let Some(var_612) = &input.background_color {
        object.key("backgroundColor").string(var_612.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_613) = &input.font {
        let mut object_614 = object.key("font").start_object();
        crate::json_ser::serialize_structure_crate_model_input_location(&mut object_614, var_613)?;
        object_614.finish();
    }
    if let Some(var_615) = &input.font_color {
        object.key("fontColor").string(var_615.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_616) = &input.font_size {
        object.key("fontSize").string(var_616.as_str());
    }
    if let Some(var_617) = &input.outline_color {
        object.key("outlineColor").string(var_617.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_618) = &input.shadow_color {
        object.key("shadowColor").string(var_618.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_619) = &input.teletext_grid_control {
        object.key("teletextGridControl").string(var_619.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_620) = &input.copyright_holder {
        object.key("copyrightHolder").string(var_620.as_str());
    }
    if let Some(var_621) = &input.fill_line_gap {
        object.key("fillLineGap").string(var_621.as_str());
    }
    if let Some(var_622) = &input.font_family {
        object.key("fontFamily").string(var_622.as_str());
    }
    if let Some(var_623) = &input.style_control {
        object.key("styleControl").string(var_623.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_624) = &input.style_control {
        object.key("styleControl").string(var_624.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_625) = &input.style_control {
        object.key("styleControl").string(var_625.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_626) = &input.archive_cdn_settings {
        let mut object_627 = object.key("archiveCdnSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_archive_cdn_settings(
            &mut object_627,
            var_626,
        )?;
        object_627.finish();
    }
    if let Some(var_628) = &input.destination {
        let mut object_629 = object.key("destination").start_object();
        crate::json_ser::serialize_structure_crate_model_output_location_ref(
            &mut object_629,
            var_628,
        )?;
        object_629.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_630) = &input.destination {
        let mut object_631 = object.key("destination").start_object();
        crate::json_ser::serialize_structure_crate_model_output_location_ref(
            &mut object_631,
            var_630,
        )?;
        object_631.finish();
    }
    if let Some(var_632) = &input.frame_capture_cdn_settings {
        let mut object_633 = object.key("frameCaptureCdnSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_frame_capture_cdn_settings(
            &mut object_633,
            var_632,
        )?;
        object_633.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_634) = &input.ad_markers {
        let mut array_635 = object.key("adMarkers").start_array();
        for item_636 in var_634 {
            {
                array_635.value().string(item_636.as_str());
            }
        }
        array_635.finish();
    }
    if let Some(var_637) = &input.base_url_content {
        object.key("baseUrlContent").string(var_637.as_str());
    }
    if let Some(var_638) = &input.base_url_content1 {
        object.key("baseUrlContent1").string(var_638.as_str());
    }
    if let Some(var_639) = &input.base_url_manifest {
        object.key("baseUrlManifest").string(var_639.as_str());
    }
    if let Some(var_640) = &input.base_url_manifest1 {
        object.key("baseUrlManifest1").string(var_640.as_str());
    }
    if let Some(var_641) = &input.caption_language_mappings {
        let mut array_642 = object.key("captionLanguageMappings").start_array();
        for item_643 in var_641 {
            {
                let mut object_644 = array_642.value().start_object();
                crate::json_ser::serialize_structure_crate_model_caption_language_mapping(
                    &mut object_644,
                    item_643,
                )?;
                object_644.finish();
            }
        }
        array_642.finish();
    }
    if let Some(var_645) = &input.caption_language_setting {
        object
            .key("captionLanguageSetting")
            .string(var_645.as_str());
    }
    if let Some(var_646) = &input.client_cache {
        object.key("clientCache").string(var_646.as_str());
    }
    if let Some(var_647) = &input.codec_specification {
        object.key("codecSpecification").string(var_647.as_str());
    }
    if let Some(var_648) = &input.constant_iv {
        object.key("constantIv").string(var_648.as_str());
    }
    if let Some(var_649) = &input.destination {
        let mut object_650 = object.key("destination").start_object();
        crate::json_ser::serialize_structure_crate_model_output_location_ref(
            &mut object_650,
            var_649,
        )?;
        object_650.finish();
    }
    if let Some(var_651) = &input.directory_structure {
        object.key("directoryStructure").string(var_651.as_str());
    }
    if let Some(var_652) = &input.discontinuity_tags {
        object.key("discontinuityTags").string(var_652.as_str());
    }
    if let Some(var_653) = &input.encryption_type {
        object.key("encryptionType").string(var_653.as_str());
    }
    if let Some(var_654) = &input.hls_cdn_settings {
        let mut object_655 = object.key("hlsCdnSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_cdn_settings(
            &mut object_655,
            var_654,
        )?;
        object_655.finish();
    }
    if let Some(var_656) = &input.hls_id3_segment_tagging {
        object.key("hlsId3SegmentTagging").string(var_656.as_str());
    }
    if let Some(var_657) = &input.i_frame_only_playlists {
        object.key("iFrameOnlyPlaylists").string(var_657.as_str());
    }
    if let Some(var_658) = &input.incomplete_segment_behavior {
        object
            .key("incompleteSegmentBehavior")
            .string(var_658.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_659) = &input.input_loss_action {
        object.key("inputLossAction").string(var_659.as_str());
    }
    if let Some(var_660) = &input.iv_in_manifest {
        object.key("ivInManifest").string(var_660.as_str());
    }
    if let Some(var_661) = &input.iv_source {
        object.key("ivSource").string(var_661.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_662) = &input.key_format {
        object.key("keyFormat").string(var_662.as_str());
    }
    if let Some(var_663) = &input.key_format_versions {
        object.key("keyFormatVersions").string(var_663.as_str());
    }
    if let Some(var_664) = &input.key_provider_settings {
        let mut object_665 = object.key("keyProviderSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_key_provider_settings(
            &mut object_665,
            var_664,
        )?;
        object_665.finish();
    }
    if let Some(var_666) = &input.manifest_compression {
        object.key("manifestCompression").string(var_666.as_str());
    }
    if let Some(var_667) = &input.manifest_duration_format {
        object
            .key("manifestDurationFormat")
            .string(var_667.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_668) = &input.mode {
        object.key("mode").string(var_668.as_str());
    }
    if let Some(var_669) = &input.output_selection {
        object.key("outputSelection").string(var_669.as_str());
    }
    if let Some(var_670) = &input.program_date_time {
        object.key("programDateTime").string(var_670.as_str());
    }
    if let Some(var_671) = &input.program_date_time_clock {
        object.key("programDateTimeClock").string(var_671.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_672) = &input.redundant_manifest {
        object.key("redundantManifest").string(var_672.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_673) = &input.segmentation_mode {
        object.key("segmentationMode").string(var_673.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_674) = &input.stream_inf_resolution {
        object.key("streamInfResolution").string(var_674.as_str());
    }
    if let Some(var_675) = &input.timed_metadata_id3_frame {
        object.key("timedMetadataId3Frame").string(var_675.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_676) = &input.ts_file_mode {
        object.key("tsFileMode").string(var_676.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_677) = &input.destination {
        let mut object_678 = object.key("destination").start_object();
        crate::json_ser::serialize_structure_crate_model_output_location_ref(
            &mut object_678,
            var_677,
        )?;
        object_678.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_679) = &input.acquisition_point_id {
        object.key("acquisitionPointId").string(var_679.as_str());
    }
    if let Some(var_680) = &input.audio_only_timecode_control {
        object
            .key("audioOnlyTimecodeControl")
            .string(var_680.as_str());
    }
    if let Some(var_681) = &input.certificate_mode {
        object.key("certificateMode").string(var_681.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_682) = &input.destination {
        let mut object_683 = object.key("destination").start_object();
        crate::json_ser::serialize_structure_crate_model_output_location_ref(
            &mut object_683,
            var_682,
        )?;
        object_683.finish();
    }
    if let Some(var_684) = &input.event_id {
        object.key("eventId").string(var_684.as_str());
    }
    if let Some(var_685) = &input.event_id_mode {
        object.key("eventIdMode").string(var_685.as_str());
    }
    if let Some(var_686) = &input.event_stop_behavior {
        object.key("eventStopBehavior").string(var_686.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_687) = &input.input_loss_action {
        object.key("inputLossAction").string(var_687.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_688) = &input.segmentation_mode {
        object.key("segmentationMode").string(var_688.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_689) = &input.sparse_track_type {
        object.key("sparseTrackType").string(var_689.as_str());
    }
    if let Some(var_690) = &input.stream_manifest_behavior {
        object
            .key("streamManifestBehavior")
            .string(var_690.as_str());
    }
    if let Some(var_691) = &input.timestamp_offset {
        object.key("timestampOffset").string(var_691.as_str());
    }
    if let Some(var_692) = &input.timestamp_offset_mode {
        object.key("timestampOffsetMode").string(var_692.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_693) = &input.ad_markers {
        let mut array_694 = object.key("adMarkers").start_array();
        for item_695 in var_693 {
            {
                array_694.value().string(item_695.as_str());
            }
        }
        array_694.finish();
    }
    if let Some(var_696) = &input.authentication_scheme {
        object.key("authenticationScheme").string(var_696.as_str());
    }
    if let Some(var_697) = &input.cache_full_behavior {
        object.key("cacheFullBehavior").string(var_697.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_698) = &input.caption_data {
        object.key("captionData").string(var_698.as_str());
    }
    if let Some(var_699) = &input.input_loss_action {
        object.key("inputLossAction").string(var_699.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_700) = &input.input_loss_action {
        object.key("inputLossAction").string(var_700.as_str());
    }
    if let Some(var_701) = &input.timed_metadata_id3_frame {
        object.key("timedMetadataId3Frame").string(var_701.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_702) = &input.archive_output_settings {
        let mut object_703 = object.key("archiveOutputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_archive_output_settings(
            &mut object_703,
            var_702,
        )?;
        object_703.finish();
    }
    if let Some(var_704) = &input.frame_capture_output_settings {
        let mut object_705 = object.key("frameCaptureOutputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_frame_capture_output_settings(
            &mut object_705,
            var_704,
        )?;
        object_705.finish();
    }
    if let Some(var_706) = &input.hls_output_settings {
        let mut object_707 = object.key("hlsOutputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_output_settings(
            &mut object_707,
            var_706,
        )?;
        object_707.finish();
    }
    if let Some(var_708) = &input.media_package_output_settings {
        let mut object_709 = object.key("mediaPackageOutputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_media_package_output_settings(
            &mut object_709,
            var_708,
        )?;
        object_709.finish();
    }
    if let Some(var_710) = &input.ms_smooth_output_settings {
        let mut object_711 = object.key("msSmoothOutputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_ms_smooth_output_settings(
            &mut object_711,
            var_710,
        )?;
        object_711.finish();
    }
    if let Some(var_712) = &input.multiplex_output_settings {
        let mut object_713 = object.key("multiplexOutputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_multiplex_output_settings(
            &mut object_713,
            var_712,
        )?;
        object_713.finish();
    }
    if let Some(var_714) = &input.rtmp_output_settings {
        let mut object_715 = object.key("rtmpOutputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_rtmp_output_settings(
            &mut object_715,
            var_714,
        )?;
        object_715.finish();
    }
    if let Some(var_716) = &input.udp_output_settings {
        let mut object_717 = object.key("udpOutputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_udp_output_settings(
            &mut object_717,
            var_716,
        )?;
        object_717.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_718) = &input.capture_interval_units {
        object.key("captureIntervalUnits").string(var_718.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_719) = &input.adaptive_quantization {
        object.key("adaptiveQuantization").string(var_719.as_str());
    }
    if let Some(var_720) = &input.afd_signaling {
        object.key("afdSignaling").string(var_720.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_721) = &input.color_metadata {
        object.key("colorMetadata").string(var_721.as_str());
    }
    if let Some(var_722) = &input.color_space_settings {
        let mut object_723 = object.key("colorSpaceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_h264_color_space_settings(
            &mut object_723,
            var_722,
        )?;
        object_723.finish();
    }
    if let Some(var_724) = &input.entropy_encoding {
        object.key("entropyEncoding").string(var_724.as_str());
    }
    if let Some(var_725) = &input.filter_settings {
        let mut object_726 = object.key("filterSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_h264_filter_settings(
            &mut object_726,
            var_725,
        )?;
        object_726.finish();
    }
    if let Some(var_727) = &input.fixed_afd {
        object.key("fixedAfd").string(var_727.as_str());
    }
    if let Some(var_728) = &input.flicker_aq {
        object.key("flickerAq").string(var_728.as_str());
    }
    if let Some(var_729) = &input.force_field_pictures {
        object.key("forceFieldPictures").string(var_729.as_str());
    }
    if let Some(var_730) = &input.framerate_control {
        object.key("framerateControl").string(var_730.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_731) = &input.gop_b_reference {
        object.key("gopBReference").string(var_731.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_732) = &input.gop_size_units {
        object.key("gopSizeUnits").string(var_732.as_str());
    }
    if let Some(var_733) = &input.level {
        object.key("level").string(var_733.as_str());
    }
    if let Some(var_734) = &input.look_ahead_rate_control {
        object.key("lookAheadRateControl").string(var_734.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_735) = &input.par_control {
        object.key("parControl").string(var_735.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_736) = &input.profile {
        object.key("profile").string(var_736.as_str());
    }
    if let Some(var_737) = &input.quality_level {
        object.key("qualityLevel").string(var_737.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_738) = &input.rate_control_mode {
        object.key("rateControlMode").string(var_738.as_str());
    }
    if let Some(var_739) = &input.scan_type {
        object.key("scanType").string(var_739.as_str());
    }
    if let Some(var_740) = &input.scene_change_detect {
        object.key("sceneChangeDetect").string(var_740.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_741) = &input.spatial_aq {
        object.key("spatialAq").string(var_741.as_str());
    }
    if let Some(var_742) = &input.subgop_length {
        object.key("subgopLength").string(var_742.as_str());
    }
    if let Some(var_743) = &input.syntax {
        object.key("syntax").string(var_743.as_str());
    }
    if let Some(var_744) = &input.temporal_aq {
        object.key("temporalAq").string(var_744.as_str());
    }
    if let Some(var_745) = &input.timecode_insertion {
        object.key("timecodeInsertion").string(var_745.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_746) = &input.adaptive_quantization {
        object.key("adaptiveQuantization").string(var_746.as_str());
    }
    if let Some(var_747) = &input.afd_signaling {
        object.key("afdSignaling").string(var_747.as_str());
    }
    if let Some(var_748) = &input.alternative_transfer_function {
        object
            .key("alternativeTransferFunction")
            .string(var_748.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_749) = &input.color_metadata {
        object.key("colorMetadata").string(var_749.as_str());
    }
    if let Some(var_750) = &input.color_space_settings {
        let mut object_751 = object.key("colorSpaceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_h265_color_space_settings(
            &mut object_751,
            var_750,
        )?;
        object_751.finish();
    }
    if let Some(var_752) = &input.filter_settings {
        let mut object_753 = object.key("filterSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_h265_filter_settings(
            &mut object_753,
            var_752,
        )?;
        object_753.finish();
    }
    if let Some(var_754) = &input.fixed_afd {
        object.key("fixedAfd").string(var_754.as_str());
    }
    if let Some(var_755) = &input.flicker_aq {
        object.key("flickerAq").string(var_755.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_756) = &input.gop_size_units {
        object.key("gopSizeUnits").string(var_756.as_str());
    }
    if let Some(var_757) = &input.level {
        object.key("level").string(var_757.as_str());
    }
    if let Some(var_758) = &input.look_ahead_rate_control {
        object.key("lookAheadRateControl").string(var_758.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_759) = &input.profile {
        object.key("profile").string(var_759.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_760) = &input.rate_control_mode {
        object.key("rateControlMode").string(var_760.as_str());
    }
    if let Some(var_761) = &input.scan_type {
        object.key("scanType").string(var_761.as_str());
    }
    if let Some(var_762) = &input.scene_change_detect {
        object.key("sceneChangeDetect").string(var_762.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_763) = &input.tier {
        object.key("tier").string(var_763.as_str());
    }
    if let Some(var_764) = &input.timecode_insertion {
        object.key("timecodeInsertion").string(var_764.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_765) = &input.adaptive_quantization {
        object.key("adaptiveQuantization").string(var_765.as_str());
    }
    if let Some(var_766) = &input.afd_signaling {
        object.key("afdSignaling").string(var_766.as_str());
    }
    if let Some(var_767) = &input.color_metadata {
        object.key("colorMetadata").string(var_767.as_str());
    }
    if let Some(var_768) = &input.color_space {
        object.key("colorSpace").string(var_768.as_str());
    }
    if let Some(var_769) = &input.display_aspect_ratio {
        object.key("displayAspectRatio").string(var_769.as_str());
    }
    if let Some(var_770) = &input.filter_settings {
        let mut object_771 = object.key("filterSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_mpeg2_filter_settings(
            &mut object_771,
            var_770,
        )?;
        object_771.finish();
    }
    if let Some(var_772) = &input.fixed_afd {
        object.key("fixedAfd").string(var_772.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_773) = &input.gop_size_units {
        object.key("gopSizeUnits").string(var_773.as_str());
    }
    if let Some(var_774) = &input.scan_type {
        object.key("scanType").string(var_774.as_str());
    }
    if let Some(var_775) = &input.subgop_length {
        object.key("subgopLength").string(var_775.as_str());
    }
    if let Some(var_776) = &input.timecode_insertion {
        object.key("timecodeInsertion").string(var_776.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_777) = &input.audio_silence_settings {
        let mut object_778 = object.key("audioSilenceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_silence_failover_settings(
            &mut object_778,
            var_777,
        )?;
        object_778.finish();
    }
    if let Some(var_779) = &input.input_loss_settings {
        let mut object_780 = object.key("inputLossSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_input_loss_failover_settings(
            &mut object_780,
            var_779,
        )?;
        object_780.finish();
    }
    if let Some(var_781) = &input.video_black_settings {
        let mut object_782 = object.key("videoBlackSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_video_black_failover_settings(
            &mut object_782,
            var_781,
        )?;
        object_782.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_783) = &input.audio_hls_rendition_selection {
        let mut object_784 = object.key("audioHlsRenditionSelection").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_hls_rendition_selection(
            &mut object_784,
            var_783,
        )?;
        object_784.finish();
    }
    if let Some(var_785) = &input.audio_language_selection {
        let mut object_786 = object.key("audioLanguageSelection").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_language_selection(
            &mut object_786,
            var_785,
        )?;
        object_786.finish();
    }
    if let Some(var_787) = &input.audio_pid_selection {
        let mut object_788 = object.key("audioPidSelection").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_pid_selection(
            &mut object_788,
            var_787,
        )?;
        object_788.finish();
    }
    if let Some(var_789) = &input.audio_track_selection {
        let mut object_790 = object.key("audioTrackSelection").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_track_selection(
            &mut object_790,
            var_789,
        )?;
        object_790.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_791) = &input.ancillary_source_settings {
        let mut object_792 = object.key("ancillarySourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_ancillary_source_settings(
            &mut object_792,
            var_791,
        )?;
        object_792.finish();
    }
    if let Some(var_793) = &input.arib_source_settings {
        let mut object_794 = object.key("aribSourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_arib_source_settings(
            &mut object_794,
            var_793,
        )?;
        object_794.finish();
    }
    if let Some(var_795) = &input.dvb_sub_source_settings {
        let mut object_796 = object.key("dvbSubSourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_dvb_sub_source_settings(
            &mut object_796,
            var_795,
        )?;
        object_796.finish();
    }
    if let Some(var_797) = &input.embedded_source_settings {
        let mut object_798 = object.key("embeddedSourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_embedded_source_settings(
            &mut object_798,
            var_797,
        )?;
        object_798.finish();
    }
    if let Some(var_799) = &input.scte20_source_settings {
        let mut object_800 = object.key("scte20SourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_scte20_source_settings(
            &mut object_800,
            var_799,
        )?;
        object_800.finish();
    }
    if let Some(var_801) = &input.scte27_source_settings {
        let mut object_802 = object.key("scte27SourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_scte27_source_settings(
            &mut object_802,
            var_801,
        )?;
        object_802.finish();
    }
    if let Some(var_803) = &input.teletext_source_settings {
        let mut object_804 = object.key("teletextSourceSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_teletext_source_settings(
            &mut object_804,
            var_803,
        )?;
        object_804.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_805) = &input.scte35_source {
        object.key("scte35Source").string(var_805.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_806) = &input.hdr10_settings {
        let mut object_807 = object.key("hdr10Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_hdr10_settings(&mut object_807, var_806)?;
        object_807.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_808) = &input.video_selector_pid {
        let mut object_809 = object.key("videoSelectorPid").start_object();
        crate::json_ser::serialize_structure_crate_model_video_selector_pid(
            &mut object_809,
            var_808,
        )?;
        object_809.finish();
    }
    if let Some(var_810) = &input.video_selector_program_id {
        let mut object_811 = object.key("videoSelectorProgramId").start_object();
        crate::json_ser::serialize_structure_crate_model_video_selector_program_id(
            &mut object_811,
            var_810,
        )?;
        object_811.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_812) = &input.input_timecode_source {
        object.key("inputTimecodeSource").string(var_812.as_str());
    }
    if let Some(var_813) = &input.start_timecode {
        let mut object_814 = object.key("startTimecode").start_object();
        crate::json_ser::serialize_structure_crate_model_start_timecode(&mut object_814, var_813)?;
        object_814.finish();
    }
    if let Some(var_815) = &input.stop_timecode {
        let mut object_816 = object.key("stopTimecode").start_object();
        crate::json_ser::serialize_structure_crate_model_stop_timecode(&mut object_816, var_815)?;
        object_816.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_817) = &input.pipeline_id {
        object.key("pipelineId").string(var_817.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_818) = &input.scte35_descriptor_settings {
        let mut object_819 = object.key("scte35DescriptorSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_scte35_descriptor_settings(
            &mut object_819,
            var_818,
        )?;
        object_819.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_820) = &input.cbet_check_digit_string {
        object.key("cbetCheckDigitString").string(var_820.as_str());
    }
    if let Some(var_821) = &input.cbet_stepaside {
        object.key("cbetStepaside").string(var_821.as_str());
    }
    if let Some(var_822) = &input.csid {
        object.key("csid").string(var_822.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_823) = &input.check_digit_string {
        object.key("checkDigitString").string(var_823.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_824) = &input.archive_s3_settings {
        let mut object_825 = object.key("archiveS3Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_archive_s3_settings(
            &mut object_825,
            var_824,
        )?;
        object_825.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_826) = &input.destination_ref_id {
        object.key("destinationRefId").string(var_826.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_827) = &input.frame_capture_s3_settings {
        let mut object_828 = object.key("frameCaptureS3Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_frame_capture_s3_settings(
            &mut object_828,
            var_827,
        )?;
        object_828.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_829) = &input.language_code {
        object.key("languageCode").string(var_829.as_str());
    }
    if let Some(var_830) = &input.language_description {
        object.key("languageDescription").string(var_830.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_831) = &input.hls_akamai_settings {
        let mut object_832 = object.key("hlsAkamaiSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_akamai_settings(
            &mut object_832,
            var_831,
        )?;
        object_832.finish();
    }
    if let Some(var_833) = &input.hls_basic_put_settings {
        let mut object_834 = object.key("hlsBasicPutSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_basic_put_settings(
            &mut object_834,
            var_833,
        )?;
        object_834.finish();
    }
    if let Some(var_835) = &input.hls_media_store_settings {
        let mut object_836 = object.key("hlsMediaStoreSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_media_store_settings(
            &mut object_836,
            var_835,
        )?;
        object_836.finish();
    }
    if let Some(var_837) = &input.hls_s3_settings {
        let mut object_838 = object.key("hlsS3Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_s3_settings(&mut object_838, var_837)?;
        object_838.finish();
    }
    if let Some(var_839) = &input.hls_webdav_settings {
        let mut object_840 = object.key("hlsWebdavSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_webdav_settings(
            &mut object_840,
            var_839,
        )?;
        object_840.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_841) = &input.static_key_settings {
        let mut object_842 = object.key("staticKeySettings").start_object();
        crate::json_ser::serialize_structure_crate_model_static_key_settings(
            &mut object_842,
            var_841,
        )?;
        object_842.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_843) = &input.container_settings {
        let mut object_844 = object.key("containerSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_archive_container_settings(
            &mut object_844,
            var_843,
        )?;
        object_844.finish();
    }
    if let Some(var_845) = &input.extension {
        object.key("extension").string(var_845.as_str());
    }
    if let Some(var_846) = &input.name_modifier {
        object.key("nameModifier").string(var_846.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_847) = &input.name_modifier {
        object.key("nameModifier").string(var_847.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_848) = &input.h265_packaging_type {
        object.key("h265PackagingType").string(var_848.as_str());
    }
    if let Some(var_849) = &input.hls_settings {
        let mut object_850 = object.key("hlsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_hls_settings(&mut object_850, var_849)?;
        object_850.finish();
    }
    if let Some(var_851) = &input.name_modifier {
        object.key("nameModifier").string(var_851.as_str());
    }
    if let Some(var_852) = &input.segment_modifier {
        object.key("segmentModifier").string(var_852.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_853) = &input.h265_packaging_type {
        object.key("h265PackagingType").string(var_853.as_str());
    }
    if let Some(var_854) = &input.name_modifier {
        object.key("nameModifier").string(var_854.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_855) = &input.destination {
        let mut object_856 = object.key("destination").start_object();
        crate::json_ser::serialize_structure_crate_model_output_location_ref(
            &mut object_856,
            var_855,
        )?;
        object_856.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_857) = &input.certificate_mode {
        object.key("certificateMode").string(var_857.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_858) = &input.destination {
        let mut object_859 = object.key("destination").start_object();
        crate::json_ser::serialize_structure_crate_model_output_location_ref(
            &mut object_859,
            var_858,
        )?;
        object_859.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_860) = &input.container_settings {
        let mut object_861 = object.key("containerSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_udp_container_settings(
            &mut object_861,
            var_860,
        )?;
        object_861.finish();
    }
    if let Some(var_862) = &input.destination {
        let mut object_863 = object.key("destination").start_object();
        crate::json_ser::serialize_structure_crate_model_output_location_ref(
            &mut object_863,
            var_862,
        )?;
        object_863.finish();
    }
    if let Some(var_864) = &input.fec_output_settings {
        let mut object_865 = object.key("fecOutputSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_fec_output_settings(
            &mut object_865,
            var_864,
        )?;
        object_865.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_866) = &input.color_space_passthrough_settings {
        let mut object_867 = object.key("colorSpacePassthroughSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_color_space_passthrough_settings(
            &mut object_867,
            var_866,
        )?;
        object_867.finish();
    }
    if let Some(var_868) = &input.rec601_settings {
        let mut object_869 = object.key("rec601Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_rec601_settings(&mut object_869, var_868)?;
        object_869.finish();
    }
    if let Some(var_870) = &input.rec709_settings {
        let mut object_871 = object.key("rec709Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_rec709_settings(&mut object_871, var_870)?;
        object_871.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_872) = &input.temporal_filter_settings {
        let mut object_873 = object.key("temporalFilterSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_temporal_filter_settings(
            &mut object_873,
            var_872,
        )?;
        object_873.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_874) = &input.color_space_passthrough_settings {
        let mut object_875 = object.key("colorSpacePassthroughSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_color_space_passthrough_settings(
            &mut object_875,
            var_874,
        )?;
        object_875.finish();
    }
    if let Some(var_876) = &input.hdr10_settings {
        let mut object_877 = object.key("hdr10Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_hdr10_settings(&mut object_877, var_876)?;
        object_877.finish();
    }
    if let Some(var_878) = &input.rec601_settings {
        let mut object_879 = object.key("rec601Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_rec601_settings(&mut object_879, var_878)?;
        object_879.finish();
    }
    if let Some(var_880) = &input.rec709_settings {
        let mut object_881 = object.key("rec709Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_rec709_settings(&mut object_881, var_880)?;
        object_881.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_882) = &input.temporal_filter_settings {
        let mut object_883 = object.key("temporalFilterSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_temporal_filter_settings(
            &mut object_883,
            var_882,
        )?;
        object_883.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_884) = &input.temporal_filter_settings {
        let mut object_885 = object.key("temporalFilterSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_temporal_filter_settings(
            &mut object_885,
            var_884,
        )?;
        object_885.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_886) = &input.audio_selector_name {
        object.key("audioSelectorName").string(var_886.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_887) = &input.group_id {
        object.key("groupId").string(var_887.as_str());
    }
    if let Some(var_888) = &input.name {
        object.key("name").string(var_888.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_889) = &input.language_code {
        object.key("languageCode").string(var_889.as_str());
    }
    if let Some(var_890) = &input.language_selection_policy {
        object
            .key("languageSelectionPolicy")
            .string(var_890.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_891) = &input.tracks {
        let mut array_892 = object.key("tracks").start_array();
        for item_893 in var_891 {
            {
                let mut object_894 = array_892.value().start_object();
                crate::json_ser::serialize_structure_crate_model_audio_track(
                    &mut object_894,
                    item_893,
                )?;
                object_894.finish();
            }
        }
        array_892.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_895) = &input.ocr_language {
        object.key("ocrLanguage").string(var_895.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_896) = &input.convert608_to708 {
        object.key("convert608To708").string(var_896.as_str());
    }
    if let Some(var_897) = &input.scte20_detection {
        object.key("scte20Detection").string(var_897.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_898) = &input.convert608_to708 {
        object.key("convert608To708").string(var_898.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_899) = &input.ocr_language {
        object.key("ocrLanguage").string(var_899.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_900) = &input.output_rectangle {
        let mut object_901 = object.key("outputRectangle").start_object();
        crate::json_ser::serialize_structure_crate_model_caption_rectangle(
            &mut object_901,
            var_900,
        )?;
        object_901.finish();
    }
    if let Some(var_902) = &input.page_number {
        object.key("pageNumber").string(var_902.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_903) = &input.timecode {
        object.key("timecode").string(var_903.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_904) = &input.last_frame_clipping_behavior {
        object
            .key("lastFrameClippingBehavior")
            .string(var_904.as_str());
    }
    if let Some(var_905) = &input.timecode {
        object.key("timecode").string(var_905.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_906) = &input.segmentation_descriptor_scte35_descriptor_settings {
        let mut object_907 = object
            .key("segmentationDescriptorScte35DescriptorSettings")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_scte35_segmentation_descriptor(
            &mut object_907,
            var_906,
        )?;
        object_907.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_908) = &input.canned_acl {
        object.key("cannedAcl").string(var_908.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_909) = &input.canned_acl {
        object.key("cannedAcl").string(var_909.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_910) = &input.http_transfer_mode {
        object.key("httpTransferMode").string(var_910.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_911) = &input.salt {
        object.key("salt").string(var_911.as_str());
    }
    if let Some(var_912) = &input.token {
        object.key("token").string(var_912.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_913) = &input.media_store_storage_class {
        object
            .key("mediaStoreStorageClass")
            .string(var_913.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_914) = &input.canned_acl {
        object.key("cannedAcl").string(var_914.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_915) = &input.http_transfer_mode {
        object.key("httpTransferMode").string(var_915.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_916) = &input.key_provider_server {
        let mut object_917 = object.key("keyProviderServer").start_object();
        crate::json_ser::serialize_structure_crate_model_input_location(&mut object_917, var_916)?;
        object_917.finish();
    }
    if let Some(var_918) = &input.static_key_value {
        object.key("staticKeyValue").string(var_918.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_919) = &input.m2ts_settings {
        let mut object_920 = object.key("m2tsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_m2ts_settings(&mut object_920, var_919)?;
        object_920.finish();
    }
    if let Some(var_921) = &input.raw_settings {
        let mut object_922 = object.key("rawSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_raw_settings(&mut object_922, var_921)?;
        object_922.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_923) = &input.audio_only_hls_settings {
        let mut object_924 = object.key("audioOnlyHlsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_audio_only_hls_settings(
            &mut object_924,
            var_923,
        )?;
        object_924.finish();
    }
    if let Some(var_925) = &input.fmp4_hls_settings {
        let mut object_926 = object.key("fmp4HlsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_fmp4_hls_settings(
            &mut object_926,
            var_925,
        )?;
        object_926.finish();
    }
    if let Some(var_927) = &input.frame_capture_hls_settings {
        let mut object_928 = object.key("frameCaptureHlsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_frame_capture_hls_settings(
            &mut object_928,
            var_927,
        )?;
        object_928.finish();
    }
    if let Some(var_929) = &input.standard_hls_settings {
        let mut object_930 = object.key("standardHlsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_standard_hls_settings(
            &mut object_930,
            var_929,
        )?;
        object_930.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_931) = &input.m2ts_settings {
        let mut object_932 = object.key("m2tsSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_m2ts_settings(&mut object_932, var_931)?;
        object_932.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_933) = &input.include_fec {
        object.key("includeFec").string(var_933.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_934) = &input.post_filter_sharpening {
        object.key("postFilterSharpening").string(var_934.as_str());
    }
    if let Some(var_935) = &input.strength {
        object.key("strength").string(var_935.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_936) = &input.delivery_restrictions {
        let mut object_937 = object.key("deliveryRestrictions").start_object();
        crate::json_ser::serialize_structure_crate_model_scte35_delivery_restrictions(
            &mut object_937,
            var_936,
        )?;
        object_937.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_938) = &input.segmentation_cancel_indicator {
        object
            .key("segmentationCancelIndicator")
            .string(var_938.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_939) = &input.segmentation_upid {
        object.key("segmentationUpid").string(var_939.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_940) = &input.absent_input_audio_behavior {
        object
            .key("absentInputAudioBehavior")
            .string(var_940.as_str());
    }
    if let Some(var_941) = &input.arib {
        object.key("arib").string(var_941.as_str());
    }
    if let Some(var_942) = &input.arib_captions_pid {
        object.key("aribCaptionsPid").string(var_942.as_str());
    }
    if let Some(var_943) = &input.arib_captions_pid_control {
        object
            .key("aribCaptionsPidControl")
            .string(var_943.as_str());
    }
    if let Some(var_944) = &input.audio_buffer_model {
        object.key("audioBufferModel").string(var_944.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_945) = &input.audio_pids {
        object.key("audioPids").string(var_945.as_str());
    }
    if let Some(var_946) = &input.audio_stream_type {
        object.key("audioStreamType").string(var_946.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_947) = &input.buffer_model {
        object.key("bufferModel").string(var_947.as_str());
    }
    if let Some(var_948) = &input.cc_descriptor {
        object.key("ccDescriptor").string(var_948.as_str());
    }
    if let Some(var_949) = &input.dvb_nit_settings {
        let mut object_950 = object.key("dvbNitSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_dvb_nit_settings(
            &mut object_950,
            var_949,
        )?;
        object_950.finish();
    }
    if let Some(var_951) = &input.dvb_sdt_settings {
        let mut object_952 = object.key("dvbSdtSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_dvb_sdt_settings(
            &mut object_952,
            var_951,
        )?;
        object_952.finish();
    }
    if let Some(var_953) = &input.dvb_sub_pids {
        object.key("dvbSubPids").string(var_953.as_str());
    }
    if let Some(var_954) = &input.dvb_tdt_settings {
        let mut object_955 = object.key("dvbTdtSettings").start_object();
        crate::json_ser::serialize_structure_crate_model_dvb_tdt_settings(
            &mut object_955,
            var_954,
        )?;
        object_955.finish();
    }
    if let Some(var_956) = &input.dvb_teletext_pid {
        object.key("dvbTeletextPid").string(var_956.as_str());
    }
    if let Some(var_957) = &input.ebif {
        object.key("ebif").string(var_957.as_str());
    }
    if let Some(var_958) = &input.ebp_audio_interval {
        object.key("ebpAudioInterval").string(var_958.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_959) = &input.ebp_placement {
        object.key("ebpPlacement").string(var_959.as_str());
    }
    if let Some(var_960) = &input.ecm_pid {
        object.key("ecmPid").string(var_960.as_str());
    }
    if let Some(var_961) = &input.es_rate_in_pes {
        object.key("esRateInPes").string(var_961.as_str());
    }
    if let Some(var_962) = &input.etv_platform_pid {
        object.key("etvPlatformPid").string(var_962.as_str());
    }
    if let Some(var_963) = &input.etv_signal_pid {
        object.key("etvSignalPid").string(var_963.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_964) = &input.klv {
        object.key("klv").string(var_964.as_str());
    }
    if let Some(var_965) = &input.klv_data_pids {
        object.key("klvDataPids").string(var_965.as_str());
    }
    if let Some(var_966) = &input.nielsen_id3_behavior {
        object.key("nielsenId3Behavior").string(var_966.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_967) = &input.pcr_control {
        object.key("pcrControl").string(var_967.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_968) = &input.pcr_pid {
        object.key("pcrPid").string(var_968.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_969) = &input.pmt_pid {
        object.key("pmtPid").string(var_969.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_970) = &input.rate_mode {
        object.key("rateMode").string(var_970.as_str());
    }
    if let Some(var_971) = &input.scte27_pids {
        object.key("scte27Pids").string(var_971.as_str());
    }
    if let Some(var_972) = &input.scte35_control {
        object.key("scte35Control").string(var_972.as_str());
    }
    if let Some(var_973) = &input.scte35_pid {
        object.key("scte35Pid").string(var_973.as_str());
    }
    if let Some(var_974) = &input.segmentation_markers {
        object.key("segmentationMarkers").string(var_974.as_str());
    }
    if let Some(var_975) = &input.segmentation_style {
        object.key("segmentationStyle").string(var_975.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_976) = &input.timed_metadata_behavior {
        object.key("timedMetadataBehavior").string(var_976.as_str());
    }
    if let Some(var_977) = &input.timed_metadata_pid {
        object.key("timedMetadataPid").string(var_977.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_978) = &input.video_pid {
        object.key("videoPid").string(var_978.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_979) = &input.audio_group_id {
        object.key("audioGroupId").string(var_979.as_str());
    }
    if let Some(var_980) = &input.audio_only_image {
        let mut object_981 = object.key("audioOnlyImage").start_object();
        crate::json_ser::serialize_structure_crate_model_input_location(&mut object_981, var_980)?;
        object_981.finish();
    }
    if let Some(var_982) = &input.audio_track_type {
        object.key("audioTrackType").string(var_982.as_str());
    }
    if let Some(var_983) = &input.segment_type {
        object.key("segmentType").string(var_983.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_984) = &input.audio_rendition_sets {
        object.key("audioRenditionSets").string(var_984.as_str());
    }
    if let Some(var_985) = &input.nielsen_id3_behavior {
        object.key("nielsenId3Behavior").string(var_985.as_str());
    }
    if let Some(var_986) = &input.timed_metadata_behavior {
        object.key("timedMetadataBehavior").string(var_986.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_987) = &input.audio_rendition_sets {
        object.key("audioRenditionSets").string(var_987.as_str());
    }
    if let Some(var_988) = &input.m3u8_settings {
        let mut object_989 = object.key("m3u8Settings").start_object();
        crate::json_ser::serialize_structure_crate_model_m3u8_settings(&mut object_989, var_988)?;
        object_989.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_990) = &input.archive_allowed_flag {
        object.key("archiveAllowedFlag").string(var_990.as_str());
    }
    if let Some(var_991) = &input.device_restrictions {
        object.key("deviceRestrictions").string(var_991.as_str());
    }
    if let Some(var_992) = &input.no_regional_blackout_flag {
        object
            .key("noRegionalBlackoutFlag")
            .string(var_992.as_str());
    }
    if let Some(var_993) = &input.web_delivery_allowed_flag {
        object
            .key("webDeliveryAllowedFlag")
            .string(var_993.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_994) = &input.network_name {
        object.key("networkName").string(var_994.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_995) = &input.output_sdt {
        object.key("outputSdt").string(var_995.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_996) = &input.service_name {
        object.key("serviceName").string(var_996.as_str());
    }
    if let Some(var_997) = &input.service_provider_name {
        object.key("serviceProviderName").string(var_997.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_998) = &input.audio_pids {
        object.key("audioPids").string(var_998.as_str());
    }
    if let Some(var_999) = &input.ecm_pid {
        object.key("ecmPid").string(var_999.as_str());
    }
    if let Some(var_1000) = &input.nielsen_id3_behavior {
        object.key("nielsenId3Behavior").string(var_1000.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_1001) = &input.pcr_control {
        object.key("pcrControl").string(var_1001.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_1002) = &input.pcr_pid {
        object.key("pcrPid").string(var_1002.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_1003) = &input.pmt_pid {
        object.key("pmtPid").string(var_1003.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_1004) = &input.scte35_behavior {
        object.key("scte35Behavior").string(var_1004.as_str());
    }
    if let Some(var_1005) = &input.scte35_pid {
        object.key("scte35Pid").string(var_1005.as_str());
    }
    if let Some(var_1006) = &input.timed_metadata_behavior {
        object
            .key("timedMetadataBehavior")
            .string(var_1006.as_str());
    }
    if let Some(var_1007) = &input.timed_metadata_pid {
        object.key("timedMetadataPid").string(var_1007.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_1008) = &input.video_pid {
        object.key("videoPid").string(var_1008.as_str());
    }
    Ok(())
}