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::error::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::error::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::error::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::error::SerializationError> {
if let Some(var_25) = &input.creates {
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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::error::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::error::SerializationError> {
if let Some(var_30) = &input.cdi_input_specification {
#[allow(unused_mut)]
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 {
{
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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 {
{
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
let mut object_53 = object.key("tags").start_object();
for (key_54, value_55) in var_52 {
{
object_53.key(key_54.as_str()).string(value_55.as_str());
}
}
object_53.finish();
}
if let Some(var_56) = &input.vpc {
#[allow(unused_mut)]
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::error::SerializationError> {
if let Some(var_58) = &input.destinations {
let mut array_59 = object.key("destinations").start_array();
for item_60 in var_58 {
{
#[allow(unused_mut)]
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 {
{
#[allow(unused_mut)]
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 {
{
#[allow(unused_mut)]
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 {
{
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
let mut object_81 = object.key("tags").start_object();
for (key_82, value_83) in var_80 {
{
object_81.key(key_82.as_str()).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 {
#[allow(unused_mut)]
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::error::SerializationError> {
if let Some(var_87) = &input.tags {
#[allow(unused_mut)]
let mut object_88 = object.key("tags").start_object();
for (key_89, value_90) in var_87 {
{
object_88.key(key_89.as_str()).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 {
{
#[allow(unused_mut)]
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::error::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 {
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
let mut object_103 = object.key("tags").start_object();
for (key_104, value_105) in var_102 {
{
object_103.key(key_104.as_str()).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::error::SerializationError> {
if let Some(var_106) = &input.multiplex_program_settings {
#[allow(unused_mut)]
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::error::SerializationError> {
if let Some(var_110) = &input.request_id {
object.key("requestId").string(var_110.as_str());
}
if let Some(var_111) = &input.tags {
#[allow(unused_mut)]
let mut object_112 = object.key("tags").start_object();
for (key_113, value_114) in var_111 {
{
object_112.key(key_113.as_str()).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::error::SerializationError> {
if let Some(var_115) = &input.tags {
#[allow(unused_mut)]
let mut object_116 = object.key("tags").start_object();
for (key_117, value_118) in var_115 {
{
object_116.key(key_117.as_str()).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::error::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 {
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
let mut object_125 = object.key("tags").start_object();
for (key_126, value_127) in var_124 {
{
object_125.key(key_126.as_str()).string(value_127.as_str());
}
}
object_125.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_reboot_input_device_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RebootInputDeviceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_128) = &input.force {
object.key("force").string(var_128.as_str());
}
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::error::SerializationError> {
if let Some(var_129) = &input.target_customer_id {
object.key("targetCustomerId").string(var_129.as_str());
}
if let Some(var_130) = &input.target_region {
object.key("targetRegion").string(var_130.as_str());
}
if let Some(var_131) = &input.transfer_message {
object.key("transferMessage").string(var_131.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::error::SerializationError> {
if let Some(var_132) = &input.cdi_input_specification {
#[allow(unused_mut)]
let mut object_133 = object.key("cdiInputSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_cdi_input_specification(
&mut object_133,
var_132,
)?;
object_133.finish();
}
if let Some(var_134) = &input.destinations {
let mut array_135 = object.key("destinations").start_array();
for item_136 in var_134 {
{
#[allow(unused_mut)]
let mut object_137 = array_135.value().start_object();
crate::json_ser::serialize_structure_crate_model_output_destination(
&mut object_137,
item_136,
)?;
object_137.finish();
}
}
array_135.finish();
}
if let Some(var_138) = &input.encoder_settings {
#[allow(unused_mut)]
let mut object_139 = object.key("encoderSettings").start_object();
crate::json_ser::serialize_structure_crate_model_encoder_settings(
&mut object_139,
var_138,
)?;
object_139.finish();
}
if let Some(var_140) = &input.input_attachments {
let mut array_141 = object.key("inputAttachments").start_array();
for item_142 in var_140 {
{
#[allow(unused_mut)]
let mut object_143 = array_141.value().start_object();
crate::json_ser::serialize_structure_crate_model_input_attachment(
&mut object_143,
item_142,
)?;
object_143.finish();
}
}
array_141.finish();
}
if let Some(var_144) = &input.input_specification {
#[allow(unused_mut)]
let mut object_145 = object.key("inputSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_input_specification(
&mut object_145,
var_144,
)?;
object_145.finish();
}
if let Some(var_146) = &input.log_level {
object.key("logLevel").string(var_146.as_str());
}
if let Some(var_147) = &input.maintenance {
#[allow(unused_mut)]
let mut object_148 = object.key("maintenance").start_object();
crate::json_ser::serialize_structure_crate_model_maintenance_update_settings(
&mut object_148,
var_147,
)?;
object_148.finish();
}
if let Some(var_149) = &input.name {
object.key("name").string(var_149.as_str());
}
if let Some(var_150) = &input.role_arn {
object.key("roleArn").string(var_150.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::error::SerializationError> {
if let Some(var_151) = &input.channel_class {
object.key("channelClass").string(var_151.as_str());
}
if let Some(var_152) = &input.destinations {
let mut array_153 = object.key("destinations").start_array();
for item_154 in var_152 {
{
#[allow(unused_mut)]
let mut object_155 = array_153.value().start_object();
crate::json_ser::serialize_structure_crate_model_output_destination(
&mut object_155,
item_154,
)?;
object_155.finish();
}
}
array_153.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::error::SerializationError> {
if let Some(var_156) = &input.destinations {
let mut array_157 = object.key("destinations").start_array();
for item_158 in var_156 {
{
#[allow(unused_mut)]
let mut object_159 = array_157.value().start_object();
crate::json_ser::serialize_structure_crate_model_input_destination_request(
&mut object_159,
item_158,
)?;
object_159.finish();
}
}
array_157.finish();
}
if let Some(var_160) = &input.input_devices {
let mut array_161 = object.key("inputDevices").start_array();
for item_162 in var_160 {
{
#[allow(unused_mut)]
let mut object_163 = array_161.value().start_object();
crate::json_ser::serialize_structure_crate_model_input_device_request(
&mut object_163,
item_162,
)?;
object_163.finish();
}
}
array_161.finish();
}
if let Some(var_164) = &input.input_security_groups {
let mut array_165 = object.key("inputSecurityGroups").start_array();
for item_166 in var_164 {
{
array_165.value().string(item_166.as_str());
}
}
array_165.finish();
}
if let Some(var_167) = &input.media_connect_flows {
let mut array_168 = object.key("mediaConnectFlows").start_array();
for item_169 in var_167 {
{
#[allow(unused_mut)]
let mut object_170 = array_168.value().start_object();
crate::json_ser::serialize_structure_crate_model_media_connect_flow_request(
&mut object_170,
item_169,
)?;
object_170.finish();
}
}
array_168.finish();
}
if let Some(var_171) = &input.name {
object.key("name").string(var_171.as_str());
}
if let Some(var_172) = &input.role_arn {
object.key("roleArn").string(var_172.as_str());
}
if let Some(var_173) = &input.sources {
let mut array_174 = object.key("sources").start_array();
for item_175 in var_173 {
{
#[allow(unused_mut)]
let mut object_176 = array_174.value().start_object();
crate::json_ser::serialize_structure_crate_model_input_source_request(
&mut object_176,
item_175,
)?;
object_176.finish();
}
}
array_174.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::error::SerializationError> {
if let Some(var_177) = &input.hd_device_settings {
#[allow(unused_mut)]
let mut object_178 = object.key("hdDeviceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_input_device_configurable_settings(
&mut object_178,
var_177,
)?;
object_178.finish();
}
if let Some(var_179) = &input.name {
object.key("name").string(var_179.as_str());
}
if let Some(var_180) = &input.uhd_device_settings {
#[allow(unused_mut)]
let mut object_181 = object.key("uhdDeviceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_input_device_configurable_settings(
&mut object_181,
var_180,
)?;
object_181.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::error::SerializationError> {
if let Some(var_182) = &input.tags {
#[allow(unused_mut)]
let mut object_183 = object.key("tags").start_object();
for (key_184, value_185) in var_182 {
{
object_183.key(key_184.as_str()).string(value_185.as_str());
}
}
object_183.finish();
}
if let Some(var_186) = &input.whitelist_rules {
let mut array_187 = object.key("whitelistRules").start_array();
for item_188 in var_186 {
{
#[allow(unused_mut)]
let mut object_189 = array_187.value().start_object();
crate::json_ser::serialize_structure_crate_model_input_whitelist_rule_cidr(
&mut object_189,
item_188,
)?;
object_189.finish();
}
}
array_187.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::error::SerializationError> {
if let Some(var_190) = &input.multiplex_settings {
#[allow(unused_mut)]
let mut object_191 = object.key("multiplexSettings").start_object();
crate::json_ser::serialize_structure_crate_model_multiplex_settings(
&mut object_191,
var_190,
)?;
object_191.finish();
}
if let Some(var_192) = &input.name {
object.key("name").string(var_192.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::error::SerializationError> {
if let Some(var_193) = &input.multiplex_program_settings {
#[allow(unused_mut)]
let mut object_194 = object.key("multiplexProgramSettings").start_object();
crate::json_ser::serialize_structure_crate_model_multiplex_program_settings(
&mut object_194,
var_193,
)?;
object_194.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::error::SerializationError> {
if let Some(var_195) = &input.name {
object.key("name").string(var_195.as_str());
}
if let Some(var_196) = &input.renewal_settings {
#[allow(unused_mut)]
let mut object_197 = object.key("renewalSettings").start_object();
crate::json_ser::serialize_structure_crate_model_renewal_settings(
&mut object_197,
var_196,
)?;
object_197.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::error::SerializationError> {
if let Some(var_198) = &input.schedule_actions {
let mut array_199 = object.key("scheduleActions").start_array();
for item_200 in var_198 {
{
#[allow(unused_mut)]
let mut object_201 = array_199.value().start_object();
crate::json_ser::serialize_structure_crate_model_schedule_action(
&mut object_201,
item_200,
)?;
object_201.finish();
}
}
array_199.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::error::SerializationError> {
if let Some(var_202) = &input.action_names {
let mut array_203 = object.key("actionNames").start_array();
for item_204 in var_202 {
{
array_203.value().string(item_204.as_str());
}
}
array_203.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::error::SerializationError> {
if let Some(var_205) = &input.resolution {
object.key("resolution").string(var_205.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::error::SerializationError> {
if let Some(var_206) = &input.id {
object.key("id").string(var_206.as_str());
}
if let Some(var_207) = &input.media_package_settings {
let mut array_208 = object.key("mediaPackageSettings").start_array();
for item_209 in var_207 {
{
#[allow(unused_mut)]
let mut object_210 = array_208.value().start_object();
crate::json_ser::serialize_structure_crate_model_media_package_output_destination_settings(&mut object_210, item_209)?;
object_210.finish();
}
}
array_208.finish();
}
if let Some(var_211) = &input.multiplex_settings {
#[allow(unused_mut)]
let mut object_212 = object.key("multiplexSettings").start_object();
crate::json_ser::serialize_structure_crate_model_multiplex_program_channel_destination_settings(&mut object_212, var_211)?;
object_212.finish();
}
if let Some(var_213) = &input.settings {
let mut array_214 = object.key("settings").start_array();
for item_215 in var_213 {
{
#[allow(unused_mut)]
let mut object_216 = array_214.value().start_object();
crate::json_ser::serialize_structure_crate_model_output_destination_settings(
&mut object_216,
item_215,
)?;
object_216.finish();
}
}
array_214.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::error::SerializationError> {
if let Some(var_217) = &input.audio_descriptions {
let mut array_218 = object.key("audioDescriptions").start_array();
for item_219 in var_217 {
{
#[allow(unused_mut)]
let mut object_220 = array_218.value().start_object();
crate::json_ser::serialize_structure_crate_model_audio_description(
&mut object_220,
item_219,
)?;
object_220.finish();
}
}
array_218.finish();
}
if let Some(var_221) = &input.avail_blanking {
#[allow(unused_mut)]
let mut object_222 = object.key("availBlanking").start_object();
crate::json_ser::serialize_structure_crate_model_avail_blanking(&mut object_222, var_221)?;
object_222.finish();
}
if let Some(var_223) = &input.avail_configuration {
#[allow(unused_mut)]
let mut object_224 = object.key("availConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_avail_configuration(
&mut object_224,
var_223,
)?;
object_224.finish();
}
if let Some(var_225) = &input.blackout_slate {
#[allow(unused_mut)]
let mut object_226 = object.key("blackoutSlate").start_object();
crate::json_ser::serialize_structure_crate_model_blackout_slate(&mut object_226, var_225)?;
object_226.finish();
}
if let Some(var_227) = &input.caption_descriptions {
let mut array_228 = object.key("captionDescriptions").start_array();
for item_229 in var_227 {
{
#[allow(unused_mut)]
let mut object_230 = array_228.value().start_object();
crate::json_ser::serialize_structure_crate_model_caption_description(
&mut object_230,
item_229,
)?;
object_230.finish();
}
}
array_228.finish();
}
if let Some(var_231) = &input.feature_activations {
#[allow(unused_mut)]
let mut object_232 = object.key("featureActivations").start_object();
crate::json_ser::serialize_structure_crate_model_feature_activations(
&mut object_232,
var_231,
)?;
object_232.finish();
}
if let Some(var_233) = &input.global_configuration {
#[allow(unused_mut)]
let mut object_234 = object.key("globalConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_global_configuration(
&mut object_234,
var_233,
)?;
object_234.finish();
}
if let Some(var_235) = &input.motion_graphics_configuration {
#[allow(unused_mut)]
let mut object_236 = object.key("motionGraphicsConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_motion_graphics_configuration(
&mut object_236,
var_235,
)?;
object_236.finish();
}
if let Some(var_237) = &input.nielsen_configuration {
#[allow(unused_mut)]
let mut object_238 = object.key("nielsenConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_nielsen_configuration(
&mut object_238,
var_237,
)?;
object_238.finish();
}
if let Some(var_239) = &input.output_groups {
let mut array_240 = object.key("outputGroups").start_array();
for item_241 in var_239 {
{
#[allow(unused_mut)]
let mut object_242 = array_240.value().start_object();
crate::json_ser::serialize_structure_crate_model_output_group(
&mut object_242,
item_241,
)?;
object_242.finish();
}
}
array_240.finish();
}
if let Some(var_243) = &input.timecode_config {
#[allow(unused_mut)]
let mut object_244 = object.key("timecodeConfig").start_object();
crate::json_ser::serialize_structure_crate_model_timecode_config(&mut object_244, var_243)?;
object_244.finish();
}
if let Some(var_245) = &input.video_descriptions {
let mut array_246 = object.key("videoDescriptions").start_array();
for item_247 in var_245 {
{
#[allow(unused_mut)]
let mut object_248 = array_246.value().start_object();
crate::json_ser::serialize_structure_crate_model_video_description(
&mut object_248,
item_247,
)?;
object_248.finish();
}
}
array_246.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::error::SerializationError> {
if let Some(var_249) = &input.automatic_input_failover_settings {
#[allow(unused_mut)]
let mut object_250 = object.key("automaticInputFailoverSettings").start_object();
crate::json_ser::serialize_structure_crate_model_automatic_input_failover_settings(
&mut object_250,
var_249,
)?;
object_250.finish();
}
if let Some(var_251) = &input.input_attachment_name {
object.key("inputAttachmentName").string(var_251.as_str());
}
if let Some(var_252) = &input.input_id {
object.key("inputId").string(var_252.as_str());
}
if let Some(var_253) = &input.input_settings {
#[allow(unused_mut)]
let mut object_254 = object.key("inputSettings").start_object();
crate::json_ser::serialize_structure_crate_model_input_settings(&mut object_254, var_253)?;
object_254.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::error::SerializationError> {
if let Some(var_255) = &input.codec {
object.key("codec").string(var_255.as_str());
}
if let Some(var_256) = &input.maximum_bitrate {
object.key("maximumBitrate").string(var_256.as_str());
}
if let Some(var_257) = &input.resolution {
object.key("resolution").string(var_257.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::error::SerializationError> {
if let Some(var_258) = &input.maintenance_day {
object.key("maintenanceDay").string(var_258.as_str());
}
if let Some(var_259) = &input.maintenance_start_time {
object.key("maintenanceStartTime").string(var_259.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::error::SerializationError> {
if let Some(var_260) = &input.public_address_allocation_ids {
let mut array_261 = object.key("publicAddressAllocationIds").start_array();
for item_262 in var_260 {
{
array_261.value().string(item_262.as_str());
}
}
array_261.finish();
}
if let Some(var_263) = &input.security_group_ids {
let mut array_264 = object.key("securityGroupIds").start_array();
for item_265 in var_263 {
{
array_264.value().string(item_265.as_str());
}
}
array_264.finish();
}
if let Some(var_266) = &input.subnet_ids {
let mut array_267 = object.key("subnetIds").start_array();
for item_268 in var_266 {
{
array_267.value().string(item_268.as_str());
}
}
array_267.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::error::SerializationError> {
if let Some(var_269) = &input.stream_name {
object.key("streamName").string(var_269.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::error::SerializationError> {
if let Some(var_270) = &input.id {
object.key("id").string(var_270.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::error::SerializationError> {
if let Some(var_271) = &input.flow_arn {
object.key("flowArn").string(var_271.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::error::SerializationError> {
if let Some(var_272) = &input.password_param {
object.key("passwordParam").string(var_272.as_str());
}
if let Some(var_273) = &input.url {
object.key("url").string(var_273.as_str());
}
if let Some(var_274) = &input.username {
object.key("username").string(var_274.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::error::SerializationError> {
if let Some(var_275) = &input.security_group_ids {
let mut array_276 = object.key("securityGroupIds").start_array();
for item_277 in var_275 {
{
array_276.value().string(item_277.as_str());
}
}
array_276.finish();
}
if let Some(var_278) = &input.subnet_ids {
let mut array_279 = object.key("subnetIds").start_array();
for item_280 in var_278 {
{
array_279.value().string(item_280.as_str());
}
}
array_279.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::error::SerializationError> {
if let Some(var_281) = &input.cidr {
object.key("cidr").string(var_281.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::error::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::error::SerializationError> {
if let Some(var_282) = &input.preferred_channel_pipeline {
object
.key("preferredChannelPipeline")
.string(var_282.as_str());
}
{
object.key("programNumber").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.program_number).into()),
);
}
if let Some(var_283) = &input.service_descriptor {
#[allow(unused_mut)]
let mut object_284 = object.key("serviceDescriptor").start_object();
crate::json_ser::serialize_structure_crate_model_multiplex_program_service_descriptor(
&mut object_284,
var_283,
)?;
object_284.finish();
}
if let Some(var_285) = &input.video_settings {
#[allow(unused_mut)]
let mut object_286 = object.key("videoSettings").start_object();
crate::json_ser::serialize_structure_crate_model_multiplex_video_settings(
&mut object_286,
var_285,
)?;
object_286.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::error::SerializationError> {
if let Some(var_287) = &input.automatic_renewal {
object.key("automaticRenewal").string(var_287.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::error::SerializationError> {
if let Some(var_288) = &input.maintenance_day {
object.key("maintenanceDay").string(var_288.as_str());
}
if let Some(var_289) = &input.maintenance_scheduled_date {
object
.key("maintenanceScheduledDate")
.string(var_289.as_str());
}
if let Some(var_290) = &input.maintenance_start_time {
object.key("maintenanceStartTime").string(var_290.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::error::SerializationError> {
if let Some(var_291) = &input.id {
object.key("id").string(var_291.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::error::SerializationError> {
if let Some(var_292) = &input.configured_input {
object.key("configuredInput").string(var_292.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.latency_ms != 0 {
object.key("latencyMs").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.latency_ms).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::error::SerializationError> {
if let Some(var_293) = &input.action_name {
object.key("actionName").string(var_293.as_str());
}
if let Some(var_294) = &input.schedule_action_settings {
#[allow(unused_mut)]
let mut object_295 = object.key("scheduleActionSettings").start_object();
crate::json_ser::serialize_structure_crate_model_schedule_action_settings(
&mut object_295,
var_294,
)?;
object_295.finish();
}
if let Some(var_296) = &input.schedule_action_start_settings {
#[allow(unused_mut)]
let mut object_297 = object.key("scheduleActionStartSettings").start_object();
crate::json_ser::serialize_structure_crate_model_schedule_action_start_settings(
&mut object_297,
var_296,
)?;
object_297.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::error::SerializationError> {
if let Some(var_298) = &input.channel_id {
object.key("channelId").string(var_298.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::error::SerializationError> {
if let Some(var_299) = &input.multiplex_id {
object.key("multiplexId").string(var_299.as_str());
}
if let Some(var_300) = &input.program_name {
object.key("programName").string(var_300.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::error::SerializationError> {
if let Some(var_301) = &input.password_param {
object.key("passwordParam").string(var_301.as_str());
}
if let Some(var_302) = &input.stream_name {
object.key("streamName").string(var_302.as_str());
}
if let Some(var_303) = &input.url {
object.key("url").string(var_303.as_str());
}
if let Some(var_304) = &input.username {
object.key("username").string(var_304.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::error::SerializationError> {
if let Some(var_305) = &input.audio_normalization_settings {
#[allow(unused_mut)]
let mut object_306 = object.key("audioNormalizationSettings").start_object();
crate::json_ser::serialize_structure_crate_model_audio_normalization_settings(
&mut object_306,
var_305,
)?;
object_306.finish();
}
if let Some(var_307) = &input.audio_selector_name {
object.key("audioSelectorName").string(var_307.as_str());
}
if let Some(var_308) = &input.audio_type {
object.key("audioType").string(var_308.as_str());
}
if let Some(var_309) = &input.audio_type_control {
object.key("audioTypeControl").string(var_309.as_str());
}
if let Some(var_310) = &input.audio_watermarking_settings {
#[allow(unused_mut)]
let mut object_311 = object.key("audioWatermarkingSettings").start_object();
crate::json_ser::serialize_structure_crate_model_audio_watermark_settings(
&mut object_311,
var_310,
)?;
object_311.finish();
}
if let Some(var_312) = &input.codec_settings {
#[allow(unused_mut)]
let mut object_313 = object.key("codecSettings").start_object();
crate::json_ser::serialize_structure_crate_model_audio_codec_settings(
&mut object_313,
var_312,
)?;
object_313.finish();
}
if let Some(var_314) = &input.language_code {
object.key("languageCode").string(var_314.as_str());
}
if let Some(var_315) = &input.language_code_control {
object.key("languageCodeControl").string(var_315.as_str());
}
if let Some(var_316) = &input.name {
object.key("name").string(var_316.as_str());
}
if let Some(var_317) = &input.remix_settings {
#[allow(unused_mut)]
let mut object_318 = object.key("remixSettings").start_object();
crate::json_ser::serialize_structure_crate_model_remix_settings(&mut object_318, var_317)?;
object_318.finish();
}
if let Some(var_319) = &input.stream_name {
object.key("streamName").string(var_319.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::error::SerializationError> {
if let Some(var_320) = &input.avail_blanking_image {
#[allow(unused_mut)]
let mut object_321 = object.key("availBlankingImage").start_object();
crate::json_ser::serialize_structure_crate_model_input_location(&mut object_321, var_320)?;
object_321.finish();
}
if let Some(var_322) = &input.state {
object.key("state").string(var_322.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::error::SerializationError> {
if let Some(var_323) = &input.avail_settings {
#[allow(unused_mut)]
let mut object_324 = object.key("availSettings").start_object();
crate::json_ser::serialize_structure_crate_model_avail_settings(&mut object_324, var_323)?;
object_324.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::error::SerializationError> {
if let Some(var_325) = &input.blackout_slate_image {
#[allow(unused_mut)]
let mut object_326 = object.key("blackoutSlateImage").start_object();
crate::json_ser::serialize_structure_crate_model_input_location(&mut object_326, var_325)?;
object_326.finish();
}
if let Some(var_327) = &input.network_end_blackout {
object.key("networkEndBlackout").string(var_327.as_str());
}
if let Some(var_328) = &input.network_end_blackout_image {
#[allow(unused_mut)]
let mut object_329 = object.key("networkEndBlackoutImage").start_object();
crate::json_ser::serialize_structure_crate_model_input_location(&mut object_329, var_328)?;
object_329.finish();
}
if let Some(var_330) = &input.network_id {
object.key("networkId").string(var_330.as_str());
}
if let Some(var_331) = &input.state {
object.key("state").string(var_331.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::error::SerializationError> {
if let Some(var_332) = &input.accessibility {
object.key("accessibility").string(var_332.as_str());
}
if let Some(var_333) = &input.caption_selector_name {
object.key("captionSelectorName").string(var_333.as_str());
}
if let Some(var_334) = &input.destination_settings {
#[allow(unused_mut)]
let mut object_335 = object.key("destinationSettings").start_object();
crate::json_ser::serialize_structure_crate_model_caption_destination_settings(
&mut object_335,
var_334,
)?;
object_335.finish();
}
if let Some(var_336) = &input.language_code {
object.key("languageCode").string(var_336.as_str());
}
if let Some(var_337) = &input.language_description {
object.key("languageDescription").string(var_337.as_str());
}
if let Some(var_338) = &input.name {
object.key("name").string(var_338.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::error::SerializationError> {
if let Some(var_339) = &input.input_prepare_schedule_actions {
object
.key("inputPrepareScheduleActions")
.string(var_339.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::error::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_340) = &input.input_end_action {
object.key("inputEndAction").string(var_340.as_str());
}
if let Some(var_341) = &input.input_loss_behavior {
#[allow(unused_mut)]
let mut object_342 = object.key("inputLossBehavior").start_object();
crate::json_ser::serialize_structure_crate_model_input_loss_behavior(
&mut object_342,
var_341,
)?;
object_342.finish();
}
if let Some(var_343) = &input.output_locking_mode {
object.key("outputLockingMode").string(var_343.as_str());
}
if let Some(var_344) = &input.output_timing_source {
object.key("outputTimingSource").string(var_344.as_str());
}
if let Some(var_345) = &input.support_low_framerate_inputs {
object
.key("supportLowFramerateInputs")
.string(var_345.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::error::SerializationError> {
if let Some(var_346) = &input.motion_graphics_insertion {
object
.key("motionGraphicsInsertion")
.string(var_346.as_str());
}
if let Some(var_347) = &input.motion_graphics_settings {
#[allow(unused_mut)]
let mut object_348 = object.key("motionGraphicsSettings").start_object();
crate::json_ser::serialize_structure_crate_model_motion_graphics_settings(
&mut object_348,
var_347,
)?;
object_348.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::error::SerializationError> {
if let Some(var_349) = &input.distributor_id {
object.key("distributorId").string(var_349.as_str());
}
if let Some(var_350) = &input.nielsen_pcm_to_id3_tagging {
object
.key("nielsenPcmToId3Tagging")
.string(var_350.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::error::SerializationError> {
if let Some(var_351) = &input.name {
object.key("name").string(var_351.as_str());
}
if let Some(var_352) = &input.output_group_settings {
#[allow(unused_mut)]
let mut object_353 = object.key("outputGroupSettings").start_object();
crate::json_ser::serialize_structure_crate_model_output_group_settings(
&mut object_353,
var_352,
)?;
object_353.finish();
}
if let Some(var_354) = &input.outputs {
let mut array_355 = object.key("outputs").start_array();
for item_356 in var_354 {
{
#[allow(unused_mut)]
let mut object_357 = array_355.value().start_object();
crate::json_ser::serialize_structure_crate_model_output(&mut object_357, item_356)?;
object_357.finish();
}
}
array_355.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::error::SerializationError> {
if let Some(var_358) = &input.source {
object.key("source").string(var_358.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::error::SerializationError> {
if let Some(var_359) = &input.codec_settings {
#[allow(unused_mut)]
let mut object_360 = object.key("codecSettings").start_object();
crate::json_ser::serialize_structure_crate_model_video_codec_settings(
&mut object_360,
var_359,
)?;
object_360.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_361) = &input.name {
object.key("name").string(var_361.as_str());
}
if let Some(var_362) = &input.respond_to_afd {
object.key("respondToAfd").string(var_362.as_str());
}
if let Some(var_363) = &input.scaling_behavior {
object.key("scalingBehavior").string(var_363.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::error::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_364) = &input.failover_conditions {
let mut array_365 = object.key("failoverConditions").start_array();
for item_366 in var_364 {
{
#[allow(unused_mut)]
let mut object_367 = array_365.value().start_object();
crate::json_ser::serialize_structure_crate_model_failover_condition(
&mut object_367,
item_366,
)?;
object_367.finish();
}
}
array_365.finish();
}
if let Some(var_368) = &input.input_preference {
object.key("inputPreference").string(var_368.as_str());
}
if let Some(var_369) = &input.secondary_input_id {
object.key("secondaryInputId").string(var_369.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::error::SerializationError> {
if let Some(var_370) = &input.audio_selectors {
let mut array_371 = object.key("audioSelectors").start_array();
for item_372 in var_370 {
{
#[allow(unused_mut)]
let mut object_373 = array_371.value().start_object();
crate::json_ser::serialize_structure_crate_model_audio_selector(
&mut object_373,
item_372,
)?;
object_373.finish();
}
}
array_371.finish();
}
if let Some(var_374) = &input.caption_selectors {
let mut array_375 = object.key("captionSelectors").start_array();
for item_376 in var_374 {
{
#[allow(unused_mut)]
let mut object_377 = array_375.value().start_object();
crate::json_ser::serialize_structure_crate_model_caption_selector(
&mut object_377,
item_376,
)?;
object_377.finish();
}
}
array_375.finish();
}
if let Some(var_378) = &input.deblock_filter {
object.key("deblockFilter").string(var_378.as_str());
}
if let Some(var_379) = &input.denoise_filter {
object.key("denoiseFilter").string(var_379.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_380) = &input.input_filter {
object.key("inputFilter").string(var_380.as_str());
}
if let Some(var_381) = &input.network_input_settings {
#[allow(unused_mut)]
let mut object_382 = object.key("networkInputSettings").start_object();
crate::json_ser::serialize_structure_crate_model_network_input_settings(
&mut object_382,
var_381,
)?;
object_382.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_383) = &input.smpte2038_data_preference {
object
.key("smpte2038DataPreference")
.string(var_383.as_str());
}
if let Some(var_384) = &input.source_end_behavior {
object.key("sourceEndBehavior").string(var_384.as_str());
}
if let Some(var_385) = &input.video_selector {
#[allow(unused_mut)]
let mut object_386 = object.key("videoSelector").start_object();
crate::json_ser::serialize_structure_crate_model_video_selector(&mut object_386, var_385)?;
object_386.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::error::SerializationError> {
if let Some(var_387) = &input.provider_name {
object.key("providerName").string(var_387.as_str());
}
if let Some(var_388) = &input.service_name {
object.key("serviceName").string(var_388.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::error::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_389) = &input.statmux_settings {
#[allow(unused_mut)]
let mut object_390 = object.key("statmuxSettings").start_object();
crate::json_ser::serialize_structure_crate_model_multiplex_statmux_video_settings(
&mut object_390,
var_389,
)?;
object_390.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::error::SerializationError> {
if let Some(var_391) = &input.hls_id3_segment_tagging_settings {
#[allow(unused_mut)]
let mut object_392 = object.key("hlsId3SegmentTaggingSettings").start_object();
crate::json_ser::serialize_structure_crate_model_hls_id3_segment_tagging_schedule_action_settings(&mut object_392, var_391)?;
object_392.finish();
}
if let Some(var_393) = &input.hls_timed_metadata_settings {
#[allow(unused_mut)]
let mut object_394 = object.key("hlsTimedMetadataSettings").start_object();
crate::json_ser::serialize_structure_crate_model_hls_timed_metadata_schedule_action_settings(&mut object_394, var_393)?;
object_394.finish();
}
if let Some(var_395) = &input.input_prepare_settings {
#[allow(unused_mut)]
let mut object_396 = object.key("inputPrepareSettings").start_object();
crate::json_ser::serialize_structure_crate_model_input_prepare_schedule_action_settings(
&mut object_396,
var_395,
)?;
object_396.finish();
}
if let Some(var_397) = &input.input_switch_settings {
#[allow(unused_mut)]
let mut object_398 = object.key("inputSwitchSettings").start_object();
crate::json_ser::serialize_structure_crate_model_input_switch_schedule_action_settings(
&mut object_398,
var_397,
)?;
object_398.finish();
}
if let Some(var_399) = &input.motion_graphics_image_activate_settings {
#[allow(unused_mut)]
let mut object_400 = object
.key("motionGraphicsImageActivateSettings")
.start_object();
crate::json_ser::serialize_structure_crate_model_motion_graphics_activate_schedule_action_settings(&mut object_400, var_399)?;
object_400.finish();
}
if let Some(var_401) = &input.motion_graphics_image_deactivate_settings {
#[allow(unused_mut)]
let mut object_402 = object
.key("motionGraphicsImageDeactivateSettings")
.start_object();
crate::json_ser::serialize_structure_crate_model_motion_graphics_deactivate_schedule_action_settings(&mut object_402, var_401)?;
object_402.finish();
}
if let Some(var_403) = &input.pause_state_settings {
#[allow(unused_mut)]
let mut object_404 = object.key("pauseStateSettings").start_object();
crate::json_ser::serialize_structure_crate_model_pause_state_schedule_action_settings(
&mut object_404,
var_403,
)?;
object_404.finish();
}
if let Some(var_405) = &input.scte35_input_settings {
#[allow(unused_mut)]
let mut object_406 = object.key("scte35InputSettings").start_object();
crate::json_ser::serialize_structure_crate_model_scte35_input_schedule_action_settings(
&mut object_406,
var_405,
)?;
object_406.finish();
}
if let Some(var_407) = &input.scte35_return_to_network_settings {
#[allow(unused_mut)]
let mut object_408 = object.key("scte35ReturnToNetworkSettings").start_object();
crate::json_ser::serialize_structure_crate_model_scte35_return_to_network_schedule_action_settings(&mut object_408, var_407)?;
object_408.finish();
}
if let Some(var_409) = &input.scte35_splice_insert_settings {
#[allow(unused_mut)]
let mut object_410 = object.key("scte35SpliceInsertSettings").start_object();
crate::json_ser::serialize_structure_crate_model_scte35_splice_insert_schedule_action_settings(&mut object_410, var_409)?;
object_410.finish();
}
if let Some(var_411) = &input.scte35_time_signal_settings {
#[allow(unused_mut)]
let mut object_412 = object.key("scte35TimeSignalSettings").start_object();
crate::json_ser::serialize_structure_crate_model_scte35_time_signal_schedule_action_settings(&mut object_412, var_411)?;
object_412.finish();
}
if let Some(var_413) = &input.static_image_activate_settings {
#[allow(unused_mut)]
let mut object_414 = object.key("staticImageActivateSettings").start_object();
crate::json_ser::serialize_structure_crate_model_static_image_activate_schedule_action_settings(&mut object_414, var_413)?;
object_414.finish();
}
if let Some(var_415) = &input.static_image_deactivate_settings {
#[allow(unused_mut)]
let mut object_416 = object.key("staticImageDeactivateSettings").start_object();
crate::json_ser::serialize_structure_crate_model_static_image_deactivate_schedule_action_settings(&mut object_416, var_415)?;
object_416.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::error::SerializationError> {
if let Some(var_417) = &input.fixed_mode_schedule_action_start_settings {
#[allow(unused_mut)]
let mut object_418 = object
.key("fixedModeScheduleActionStartSettings")
.start_object();
crate::json_ser::serialize_structure_crate_model_fixed_mode_schedule_action_start_settings(
&mut object_418,
var_417,
)?;
object_418.finish();
}
if let Some(var_419) = &input.follow_mode_schedule_action_start_settings {
#[allow(unused_mut)]
let mut object_420 = object
.key("followModeScheduleActionStartSettings")
.start_object();
crate::json_ser::serialize_structure_crate_model_follow_mode_schedule_action_start_settings(&mut object_420, var_419)?;
object_420.finish();
}
if let Some(var_421) = &input.immediate_mode_schedule_action_start_settings {
#[allow(unused_mut)]
let mut object_422 = object
.key("immediateModeScheduleActionStartSettings")
.start_object();
crate::json_ser::serialize_structure_crate_model_immediate_mode_schedule_action_start_settings(&mut object_422, var_421)?;
object_422.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::error::SerializationError> {
if let Some(var_423) = &input.algorithm {
object.key("algorithm").string(var_423.as_str());
}
if let Some(var_424) = &input.algorithm_control {
object.key("algorithmControl").string(var_424.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::error::SerializationError> {
if let Some(var_425) = &input.nielsen_watermarks_settings {
#[allow(unused_mut)]
let mut object_426 = object.key("nielsenWatermarksSettings").start_object();
crate::json_ser::serialize_structure_crate_model_nielsen_watermarks_settings(
&mut object_426,
var_425,
)?;
object_426.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::error::SerializationError> {
if let Some(var_427) = &input.aac_settings {
#[allow(unused_mut)]
let mut object_428 = object.key("aacSettings").start_object();
crate::json_ser::serialize_structure_crate_model_aac_settings(&mut object_428, var_427)?;
object_428.finish();
}
if let Some(var_429) = &input.ac3_settings {
#[allow(unused_mut)]
let mut object_430 = object.key("ac3Settings").start_object();
crate::json_ser::serialize_structure_crate_model_ac3_settings(&mut object_430, var_429)?;
object_430.finish();
}
if let Some(var_431) = &input.eac3_atmos_settings {
#[allow(unused_mut)]
let mut object_432 = object.key("eac3AtmosSettings").start_object();
crate::json_ser::serialize_structure_crate_model_eac3_atmos_settings(
&mut object_432,
var_431,
)?;
object_432.finish();
}
if let Some(var_433) = &input.eac3_settings {
#[allow(unused_mut)]
let mut object_434 = object.key("eac3Settings").start_object();
crate::json_ser::serialize_structure_crate_model_eac3_settings(&mut object_434, var_433)?;
object_434.finish();
}
if let Some(var_435) = &input.mp2_settings {
#[allow(unused_mut)]
let mut object_436 = object.key("mp2Settings").start_object();
crate::json_ser::serialize_structure_crate_model_mp2_settings(&mut object_436, var_435)?;
object_436.finish();
}
if let Some(var_437) = &input.pass_through_settings {
#[allow(unused_mut)]
let mut object_438 = object.key("passThroughSettings").start_object();
crate::json_ser::serialize_structure_crate_model_pass_through_settings(
&mut object_438,
var_437,
)?;
object_438.finish();
}
if let Some(var_439) = &input.wav_settings {
#[allow(unused_mut)]
let mut object_440 = object.key("wavSettings").start_object();
crate::json_ser::serialize_structure_crate_model_wav_settings(&mut object_440, var_439)?;
object_440.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::error::SerializationError> {
if let Some(var_441) = &input.channel_mappings {
let mut array_442 = object.key("channelMappings").start_array();
for item_443 in var_441 {
{
#[allow(unused_mut)]
let mut object_444 = array_442.value().start_object();
crate::json_ser::serialize_structure_crate_model_audio_channel_mapping(
&mut object_444,
item_443,
)?;
object_444.finish();
}
}
array_442.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::error::SerializationError> {
if let Some(var_445) = &input.password_param {
object.key("passwordParam").string(var_445.as_str());
}
if let Some(var_446) = &input.uri {
object.key("uri").string(var_446.as_str());
}
if let Some(var_447) = &input.username {
object.key("username").string(var_447.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::error::SerializationError> {
if let Some(var_448) = &input.esam {
#[allow(unused_mut)]
let mut object_449 = object.key("esam").start_object();
crate::json_ser::serialize_structure_crate_model_esam(&mut object_449, var_448)?;
object_449.finish();
}
if let Some(var_450) = &input.scte35_splice_insert {
#[allow(unused_mut)]
let mut object_451 = object.key("scte35SpliceInsert").start_object();
crate::json_ser::serialize_structure_crate_model_scte35_splice_insert(
&mut object_451,
var_450,
)?;
object_451.finish();
}
if let Some(var_452) = &input.scte35_time_signal_apos {
#[allow(unused_mut)]
let mut object_453 = object.key("scte35TimeSignalApos").start_object();
crate::json_ser::serialize_structure_crate_model_scte35_time_signal_apos(
&mut object_453,
var_452,
)?;
object_453.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::error::SerializationError> {
if let Some(var_454) = &input.arib_destination_settings {
#[allow(unused_mut)]
let mut object_455 = object.key("aribDestinationSettings").start_object();
crate::json_ser::serialize_structure_crate_model_arib_destination_settings(
&mut object_455,
var_454,
)?;
object_455.finish();
}
if let Some(var_456) = &input.burn_in_destination_settings {
#[allow(unused_mut)]
let mut object_457 = object.key("burnInDestinationSettings").start_object();
crate::json_ser::serialize_structure_crate_model_burn_in_destination_settings(
&mut object_457,
var_456,
)?;
object_457.finish();
}
if let Some(var_458) = &input.dvb_sub_destination_settings {
#[allow(unused_mut)]
let mut object_459 = object.key("dvbSubDestinationSettings").start_object();
crate::json_ser::serialize_structure_crate_model_dvb_sub_destination_settings(
&mut object_459,
var_458,
)?;
object_459.finish();
}
if let Some(var_460) = &input.ebu_tt_d_destination_settings {
#[allow(unused_mut)]
let mut object_461 = object.key("ebuTtDDestinationSettings").start_object();
crate::json_ser::serialize_structure_crate_model_ebu_tt_d_destination_settings(
&mut object_461,
var_460,
)?;
object_461.finish();
}
if let Some(var_462) = &input.embedded_destination_settings {
#[allow(unused_mut)]
let mut object_463 = object.key("embeddedDestinationSettings").start_object();
crate::json_ser::serialize_structure_crate_model_embedded_destination_settings(
&mut object_463,
var_462,
)?;
object_463.finish();
}
if let Some(var_464) = &input.embedded_plus_scte20_destination_settings {
#[allow(unused_mut)]
let mut object_465 = object
.key("embeddedPlusScte20DestinationSettings")
.start_object();
crate::json_ser::serialize_structure_crate_model_embedded_plus_scte20_destination_settings(
&mut object_465,
var_464,
)?;
object_465.finish();
}
if let Some(var_466) = &input.rtmp_caption_info_destination_settings {
#[allow(unused_mut)]
let mut object_467 = object
.key("rtmpCaptionInfoDestinationSettings")
.start_object();
crate::json_ser::serialize_structure_crate_model_rtmp_caption_info_destination_settings(
&mut object_467,
var_466,
)?;
object_467.finish();
}
if let Some(var_468) = &input.scte20_plus_embedded_destination_settings {
#[allow(unused_mut)]
let mut object_469 = object
.key("scte20PlusEmbeddedDestinationSettings")
.start_object();
crate::json_ser::serialize_structure_crate_model_scte20_plus_embedded_destination_settings(
&mut object_469,
var_468,
)?;
object_469.finish();
}
if let Some(var_470) = &input.scte27_destination_settings {
#[allow(unused_mut)]
let mut object_471 = object.key("scte27DestinationSettings").start_object();
crate::json_ser::serialize_structure_crate_model_scte27_destination_settings(
&mut object_471,
var_470,
)?;
object_471.finish();
}
if let Some(var_472) = &input.smpte_tt_destination_settings {
#[allow(unused_mut)]
let mut object_473 = object.key("smpteTtDestinationSettings").start_object();
crate::json_ser::serialize_structure_crate_model_smpte_tt_destination_settings(
&mut object_473,
var_472,
)?;
object_473.finish();
}
if let Some(var_474) = &input.teletext_destination_settings {
#[allow(unused_mut)]
let mut object_475 = object.key("teletextDestinationSettings").start_object();
crate::json_ser::serialize_structure_crate_model_teletext_destination_settings(
&mut object_475,
var_474,
)?;
object_475.finish();
}
if let Some(var_476) = &input.ttml_destination_settings {
#[allow(unused_mut)]
let mut object_477 = object.key("ttmlDestinationSettings").start_object();
crate::json_ser::serialize_structure_crate_model_ttml_destination_settings(
&mut object_477,
var_476,
)?;
object_477.finish();
}
if let Some(var_478) = &input.webvtt_destination_settings {
#[allow(unused_mut)]
let mut object_479 = object.key("webvttDestinationSettings").start_object();
crate::json_ser::serialize_structure_crate_model_webvtt_destination_settings(
&mut object_479,
var_478,
)?;
object_479.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::error::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_480) = &input.input_loss_image_color {
object.key("inputLossImageColor").string(var_480.as_str());
}
if let Some(var_481) = &input.input_loss_image_slate {
#[allow(unused_mut)]
let mut object_482 = object.key("inputLossImageSlate").start_object();
crate::json_ser::serialize_structure_crate_model_input_location(&mut object_482, var_481)?;
object_482.finish();
}
if let Some(var_483) = &input.input_loss_image_type {
object.key("inputLossImageType").string(var_483.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::error::SerializationError> {
if let Some(var_484) = &input.html_motion_graphics_settings {
#[allow(unused_mut)]
let mut object_485 = object.key("htmlMotionGraphicsSettings").start_object();
crate::json_ser::serialize_structure_crate_model_html_motion_graphics_settings(
&mut object_485,
var_484,
)?;
object_485.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::error::SerializationError> {
if let Some(var_486) = &input.archive_group_settings {
#[allow(unused_mut)]
let mut object_487 = object.key("archiveGroupSettings").start_object();
crate::json_ser::serialize_structure_crate_model_archive_group_settings(
&mut object_487,
var_486,
)?;
object_487.finish();
}
if let Some(var_488) = &input.frame_capture_group_settings {
#[allow(unused_mut)]
let mut object_489 = object.key("frameCaptureGroupSettings").start_object();
crate::json_ser::serialize_structure_crate_model_frame_capture_group_settings(
&mut object_489,
var_488,
)?;
object_489.finish();
}
if let Some(var_490) = &input.hls_group_settings {
#[allow(unused_mut)]
let mut object_491 = object.key("hlsGroupSettings").start_object();
crate::json_ser::serialize_structure_crate_model_hls_group_settings(
&mut object_491,
var_490,
)?;
object_491.finish();
}
if let Some(var_492) = &input.media_package_group_settings {
#[allow(unused_mut)]
let mut object_493 = object.key("mediaPackageGroupSettings").start_object();
crate::json_ser::serialize_structure_crate_model_media_package_group_settings(
&mut object_493,
var_492,
)?;
object_493.finish();
}
if let Some(var_494) = &input.ms_smooth_group_settings {
#[allow(unused_mut)]
let mut object_495 = object.key("msSmoothGroupSettings").start_object();
crate::json_ser::serialize_structure_crate_model_ms_smooth_group_settings(
&mut object_495,
var_494,
)?;
object_495.finish();
}
if let Some(var_496) = &input.multiplex_group_settings {
#[allow(unused_mut)]
let mut object_497 = object.key("multiplexGroupSettings").start_object();
crate::json_ser::serialize_structure_crate_model_multiplex_group_settings(
&mut object_497,
var_496,
)?;
object_497.finish();
}
if let Some(var_498) = &input.rtmp_group_settings {
#[allow(unused_mut)]
let mut object_499 = object.key("rtmpGroupSettings").start_object();
crate::json_ser::serialize_structure_crate_model_rtmp_group_settings(
&mut object_499,
var_498,
)?;
object_499.finish();
}
if let Some(var_500) = &input.udp_group_settings {
#[allow(unused_mut)]
let mut object_501 = object.key("udpGroupSettings").start_object();
crate::json_ser::serialize_structure_crate_model_udp_group_settings(
&mut object_501,
var_500,
)?;
object_501.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::error::SerializationError> {
if let Some(var_502) = &input.audio_description_names {
let mut array_503 = object.key("audioDescriptionNames").start_array();
for item_504 in var_502 {
{
array_503.value().string(item_504.as_str());
}
}
array_503.finish();
}
if let Some(var_505) = &input.caption_description_names {
let mut array_506 = object.key("captionDescriptionNames").start_array();
for item_507 in var_505 {
{
array_506.value().string(item_507.as_str());
}
}
array_506.finish();
}
if let Some(var_508) = &input.output_name {
object.key("outputName").string(var_508.as_str());
}
if let Some(var_509) = &input.output_settings {
#[allow(unused_mut)]
let mut object_510 = object.key("outputSettings").start_object();
crate::json_ser::serialize_structure_crate_model_output_settings(&mut object_510, var_509)?;
object_510.finish();
}
if let Some(var_511) = &input.video_description_name {
object.key("videoDescriptionName").string(var_511.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::error::SerializationError> {
if let Some(var_512) = &input.frame_capture_settings {
#[allow(unused_mut)]
let mut object_513 = object.key("frameCaptureSettings").start_object();
crate::json_ser::serialize_structure_crate_model_frame_capture_settings(
&mut object_513,
var_512,
)?;
object_513.finish();
}
if let Some(var_514) = &input.h264_settings {
#[allow(unused_mut)]
let mut object_515 = object.key("h264Settings").start_object();
crate::json_ser::serialize_structure_crate_model_h264_settings(&mut object_515, var_514)?;
object_515.finish();
}
if let Some(var_516) = &input.h265_settings {
#[allow(unused_mut)]
let mut object_517 = object.key("h265Settings").start_object();
crate::json_ser::serialize_structure_crate_model_h265_settings(&mut object_517, var_516)?;
object_517.finish();
}
if let Some(var_518) = &input.mpeg2_settings {
#[allow(unused_mut)]
let mut object_519 = object.key("mpeg2Settings").start_object();
crate::json_ser::serialize_structure_crate_model_mpeg2_settings(&mut object_519, var_518)?;
object_519.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::error::SerializationError> {
if let Some(var_520) = &input.failover_condition_settings {
#[allow(unused_mut)]
let mut object_521 = object.key("failoverConditionSettings").start_object();
crate::json_ser::serialize_structure_crate_model_failover_condition_settings(
&mut object_521,
var_520,
)?;
object_521.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::error::SerializationError> {
if let Some(var_522) = &input.name {
object.key("name").string(var_522.as_str());
}
if let Some(var_523) = &input.selector_settings {
#[allow(unused_mut)]
let mut object_524 = object.key("selectorSettings").start_object();
crate::json_ser::serialize_structure_crate_model_audio_selector_settings(
&mut object_524,
var_523,
)?;
object_524.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::error::SerializationError> {
if let Some(var_525) = &input.language_code {
object.key("languageCode").string(var_525.as_str());
}
if let Some(var_526) = &input.name {
object.key("name").string(var_526.as_str());
}
if let Some(var_527) = &input.selector_settings {
#[allow(unused_mut)]
let mut object_528 = object.key("selectorSettings").start_object();
crate::json_ser::serialize_structure_crate_model_caption_selector_settings(
&mut object_528,
var_527,
)?;
object_528.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::error::SerializationError> {
if let Some(var_529) = &input.hls_input_settings {
#[allow(unused_mut)]
let mut object_530 = object.key("hlsInputSettings").start_object();
crate::json_ser::serialize_structure_crate_model_hls_input_settings(
&mut object_530,
var_529,
)?;
object_530.finish();
}
if let Some(var_531) = &input.server_validation {
object.key("serverValidation").string(var_531.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::error::SerializationError> {
if let Some(var_532) = &input.color_space {
object.key("colorSpace").string(var_532.as_str());
}
if let Some(var_533) = &input.color_space_settings {
#[allow(unused_mut)]
let mut object_534 = object.key("colorSpaceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_video_selector_color_space_settings(
&mut object_534,
var_533,
)?;
object_534.finish();
}
if let Some(var_535) = &input.color_space_usage {
object.key("colorSpaceUsage").string(var_535.as_str());
}
if let Some(var_536) = &input.selector_settings {
#[allow(unused_mut)]
let mut object_537 = object.key("selectorSettings").start_object();
crate::json_ser::serialize_structure_crate_model_video_selector_settings(
&mut object_537,
var_536,
)?;
object_537.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::error::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::error::SerializationError> {
if let Some(var_538) = &input.tag {
object.key("tag").string(var_538.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::error::SerializationError> {
if let Some(var_539) = &input.id3 {
object.key("id3").string(var_539.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::error::SerializationError> {
if let Some(var_540) = &input.input_attachment_name_reference {
object
.key("inputAttachmentNameReference")
.string(var_540.as_str());
}
if let Some(var_541) = &input.input_clipping_settings {
#[allow(unused_mut)]
let mut object_542 = object.key("inputClippingSettings").start_object();
crate::json_ser::serialize_structure_crate_model_input_clipping_settings(
&mut object_542,
var_541,
)?;
object_542.finish();
}
if let Some(var_543) = &input.url_path {
let mut array_544 = object.key("urlPath").start_array();
for item_545 in var_543 {
{
array_544.value().string(item_545.as_str());
}
}
array_544.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::error::SerializationError> {
if let Some(var_546) = &input.input_attachment_name_reference {
object
.key("inputAttachmentNameReference")
.string(var_546.as_str());
}
if let Some(var_547) = &input.input_clipping_settings {
#[allow(unused_mut)]
let mut object_548 = object.key("inputClippingSettings").start_object();
crate::json_ser::serialize_structure_crate_model_input_clipping_settings(
&mut object_548,
var_547,
)?;
object_548.finish();
}
if let Some(var_549) = &input.url_path {
let mut array_550 = object.key("urlPath").start_array();
for item_551 in var_549 {
{
array_550.value().string(item_551.as_str());
}
}
array_550.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::error::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_552) = &input.password_param {
object.key("passwordParam").string(var_552.as_str());
}
if let Some(var_553) = &input.url {
object.key("url").string(var_553.as_str());
}
if let Some(var_554) = &input.username {
object.key("username").string(var_554.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::error::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::error::SerializationError> {
if let Some(var_555) = &input.pipelines {
let mut array_556 = object.key("pipelines").start_array();
for item_557 in var_555 {
{
#[allow(unused_mut)]
let mut object_558 = array_556.value().start_object();
crate::json_ser::serialize_structure_crate_model_pipeline_pause_state_settings(
&mut object_558,
item_557,
)?;
object_558.finish();
}
}
array_556.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_scte35_input_schedule_action_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Scte35InputScheduleActionSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_559) = &input.input_attachment_name_reference {
object
.key("inputAttachmentNameReference")
.string(var_559.as_str());
}
if let Some(var_560) = &input.mode {
object.key("mode").string(var_560.as_str());
}
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::error::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::error::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::error::SerializationError> {
if let Some(var_561) = &input.scte35_descriptors {
let mut array_562 = object.key("scte35Descriptors").start_array();
for item_563 in var_561 {
{
#[allow(unused_mut)]
let mut object_564 = array_562.value().start_object();
crate::json_ser::serialize_structure_crate_model_scte35_descriptor(
&mut object_564,
item_563,
)?;
object_564.finish();
}
}
array_562.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::error::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_565) = &input.image {
#[allow(unused_mut)]
let mut object_566 = object.key("image").start_object();
crate::json_ser::serialize_structure_crate_model_input_location(&mut object_566, var_565)?;
object_566.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::error::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::error::SerializationError> {
if let Some(var_567) = &input.time {
object.key("time").string(var_567.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::error::SerializationError> {
if let Some(var_568) = &input.follow_point {
object.key("followPoint").string(var_568.as_str());
}
if let Some(var_569) = &input.reference_action_name {
object.key("referenceActionName").string(var_569.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::error::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::error::SerializationError> {
if let Some(var_570) = &input.nielsen_cbet_settings {
#[allow(unused_mut)]
let mut object_571 = object.key("nielsenCbetSettings").start_object();
crate::json_ser::serialize_structure_crate_model_nielsen_cbet(&mut object_571, var_570)?;
object_571.finish();
}
if let Some(var_572) = &input.nielsen_distribution_type {
object
.key("nielsenDistributionType")
.string(var_572.as_str());
}
if let Some(var_573) = &input.nielsen_naes_ii_nw_settings {
#[allow(unused_mut)]
let mut object_574 = object.key("nielsenNaesIiNwSettings").start_object();
crate::json_ser::serialize_structure_crate_model_nielsen_naes_ii_nw(
&mut object_574,
var_573,
)?;
object_574.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::error::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_575) = &input.coding_mode {
object.key("codingMode").string(var_575.as_str());
}
if let Some(var_576) = &input.input_type {
object.key("inputType").string(var_576.as_str());
}
if let Some(var_577) = &input.profile {
object.key("profile").string(var_577.as_str());
}
if let Some(var_578) = &input.rate_control_mode {
object.key("rateControlMode").string(var_578.as_str());
}
if let Some(var_579) = &input.raw_format {
object.key("rawFormat").string(var_579.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_580) = &input.spec {
object.key("spec").string(var_580.as_str());
}
if let Some(var_581) = &input.vbr_quality {
object.key("vbrQuality").string(var_581.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::error::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_582) = &input.bitstream_mode {
object.key("bitstreamMode").string(var_582.as_str());
}
if let Some(var_583) = &input.coding_mode {
object.key("codingMode").string(var_583.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_584) = &input.drc_profile {
object.key("drcProfile").string(var_584.as_str());
}
if let Some(var_585) = &input.lfe_filter {
object.key("lfeFilter").string(var_585.as_str());
}
if let Some(var_586) = &input.metadata_control {
object.key("metadataControl").string(var_586.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_eac3_atmos_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Eac3AtmosSettings,
) -> Result<(), aws_smithy_http::operation::error::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_587) = &input.coding_mode {
object.key("codingMode").string(var_587.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_588) = &input.drc_line {
object.key("drcLine").string(var_588.as_str());
}
if let Some(var_589) = &input.drc_rf {
object.key("drcRf").string(var_589.as_str());
}
if input.height_trim != 0.0 {
object.key("heightTrim").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.height_trim).into()),
);
}
if input.surround_trim != 0.0 {
object.key("surroundTrim").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.surround_trim).into()),
);
}
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::error::SerializationError> {
if let Some(var_590) = &input.attenuation_control {
object.key("attenuationControl").string(var_590.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_591) = &input.bitstream_mode {
object.key("bitstreamMode").string(var_591.as_str());
}
if let Some(var_592) = &input.coding_mode {
object.key("codingMode").string(var_592.as_str());
}
if let Some(var_593) = &input.dc_filter {
object.key("dcFilter").string(var_593.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_594) = &input.drc_line {
object.key("drcLine").string(var_594.as_str());
}
if let Some(var_595) = &input.drc_rf {
object.key("drcRf").string(var_595.as_str());
}
if let Some(var_596) = &input.lfe_control {
object.key("lfeControl").string(var_596.as_str());
}
if let Some(var_597) = &input.lfe_filter {
object.key("lfeFilter").string(var_597.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_598) = &input.metadata_control {
object.key("metadataControl").string(var_598.as_str());
}
if let Some(var_599) = &input.passthrough_control {
object.key("passthroughControl").string(var_599.as_str());
}
if let Some(var_600) = &input.phase_control {
object.key("phaseControl").string(var_600.as_str());
}
if let Some(var_601) = &input.stereo_downmix {
object.key("stereoDownmix").string(var_601.as_str());
}
if let Some(var_602) = &input.surround_ex_mode {
object.key("surroundExMode").string(var_602.as_str());
}
if let Some(var_603) = &input.surround_mode {
object.key("surroundMode").string(var_603.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::error::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_604) = &input.coding_mode {
object.key("codingMode").string(var_604.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::error::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::error::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_605) = &input.coding_mode {
object.key("codingMode").string(var_605.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::error::SerializationError> {
if let Some(var_606) = &input.input_channel_levels {
let mut array_607 = object.key("inputChannelLevels").start_array();
for item_608 in var_606 {
{
#[allow(unused_mut)]
let mut object_609 = array_607.value().start_object();
crate::json_ser::serialize_structure_crate_model_input_channel_level(
&mut object_609,
item_608,
)?;
object_609.finish();
}
}
array_607.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_esam(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Esam,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_610) = &input.acquisition_point_id {
object.key("acquisitionPointId").string(var_610.as_str());
}
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_611) = &input.password_param {
object.key("passwordParam").string(var_611.as_str());
}
if let Some(var_612) = &input.pois_endpoint {
object.key("poisEndpoint").string(var_612.as_str());
}
if let Some(var_613) = &input.username {
object.key("username").string(var_613.as_str());
}
if let Some(var_614) = &input.zone_identity {
object.key("zoneIdentity").string(var_614.as_str());
}
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::error::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_615) = &input.no_regional_blackout_flag {
object
.key("noRegionalBlackoutFlag")
.string(var_615.as_str());
}
if let Some(var_616) = &input.web_delivery_allowed_flag {
object
.key("webDeliveryAllowedFlag")
.string(var_616.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::error::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_617) = &input.no_regional_blackout_flag {
object
.key("noRegionalBlackoutFlag")
.string(var_617.as_str());
}
if let Some(var_618) = &input.web_delivery_allowed_flag {
object
.key("webDeliveryAllowedFlag")
.string(var_618.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::error::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::error::SerializationError> {
if let Some(var_619) = &input.alignment {
object.key("alignment").string(var_619.as_str());
}
if let Some(var_620) = &input.background_color {
object.key("backgroundColor").string(var_620.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_621) = &input.font {
#[allow(unused_mut)]
let mut object_622 = object.key("font").start_object();
crate::json_ser::serialize_structure_crate_model_input_location(&mut object_622, var_621)?;
object_622.finish();
}
if let Some(var_623) = &input.font_color {
object.key("fontColor").string(var_623.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_624) = &input.font_size {
object.key("fontSize").string(var_624.as_str());
}
if let Some(var_625) = &input.outline_color {
object.key("outlineColor").string(var_625.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_626) = &input.shadow_color {
object.key("shadowColor").string(var_626.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_627) = &input.teletext_grid_control {
object.key("teletextGridControl").string(var_627.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::error::SerializationError> {
if let Some(var_628) = &input.alignment {
object.key("alignment").string(var_628.as_str());
}
if let Some(var_629) = &input.background_color {
object.key("backgroundColor").string(var_629.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_630) = &input.font {
#[allow(unused_mut)]
let mut object_631 = object.key("font").start_object();
crate::json_ser::serialize_structure_crate_model_input_location(&mut object_631, var_630)?;
object_631.finish();
}
if let Some(var_632) = &input.font_color {
object.key("fontColor").string(var_632.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_633) = &input.font_size {
object.key("fontSize").string(var_633.as_str());
}
if let Some(var_634) = &input.outline_color {
object.key("outlineColor").string(var_634.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_635) = &input.shadow_color {
object.key("shadowColor").string(var_635.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_636) = &input.teletext_grid_control {
object.key("teletextGridControl").string(var_636.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::error::SerializationError> {
if let Some(var_637) = &input.copyright_holder {
object.key("copyrightHolder").string(var_637.as_str());
}
if let Some(var_638) = &input.fill_line_gap {
object.key("fillLineGap").string(var_638.as_str());
}
if let Some(var_639) = &input.font_family {
object.key("fontFamily").string(var_639.as_str());
}
if let Some(var_640) = &input.style_control {
object.key("styleControl").string(var_640.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::error::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::error::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::error::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::error::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::error::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::error::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::error::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::error::SerializationError> {
if let Some(var_641) = &input.style_control {
object.key("styleControl").string(var_641.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::error::SerializationError> {
if let Some(var_642) = &input.style_control {
object.key("styleControl").string(var_642.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::error::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::error::SerializationError> {
if let Some(var_643) = &input.archive_cdn_settings {
#[allow(unused_mut)]
let mut object_644 = object.key("archiveCdnSettings").start_object();
crate::json_ser::serialize_structure_crate_model_archive_cdn_settings(
&mut object_644,
var_643,
)?;
object_644.finish();
}
if let Some(var_645) = &input.destination {
#[allow(unused_mut)]
let mut object_646 = object.key("destination").start_object();
crate::json_ser::serialize_structure_crate_model_output_location_ref(
&mut object_646,
var_645,
)?;
object_646.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::error::SerializationError> {
if let Some(var_647) = &input.destination {
#[allow(unused_mut)]
let mut object_648 = object.key("destination").start_object();
crate::json_ser::serialize_structure_crate_model_output_location_ref(
&mut object_648,
var_647,
)?;
object_648.finish();
}
if let Some(var_649) = &input.frame_capture_cdn_settings {
#[allow(unused_mut)]
let mut object_650 = object.key("frameCaptureCdnSettings").start_object();
crate::json_ser::serialize_structure_crate_model_frame_capture_cdn_settings(
&mut object_650,
var_649,
)?;
object_650.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::error::SerializationError> {
if let Some(var_651) = &input.ad_markers {
let mut array_652 = object.key("adMarkers").start_array();
for item_653 in var_651 {
{
array_652.value().string(item_653.as_str());
}
}
array_652.finish();
}
if let Some(var_654) = &input.base_url_content {
object.key("baseUrlContent").string(var_654.as_str());
}
if let Some(var_655) = &input.base_url_content1 {
object.key("baseUrlContent1").string(var_655.as_str());
}
if let Some(var_656) = &input.base_url_manifest {
object.key("baseUrlManifest").string(var_656.as_str());
}
if let Some(var_657) = &input.base_url_manifest1 {
object.key("baseUrlManifest1").string(var_657.as_str());
}
if let Some(var_658) = &input.caption_language_mappings {
let mut array_659 = object.key("captionLanguageMappings").start_array();
for item_660 in var_658 {
{
#[allow(unused_mut)]
let mut object_661 = array_659.value().start_object();
crate::json_ser::serialize_structure_crate_model_caption_language_mapping(
&mut object_661,
item_660,
)?;
object_661.finish();
}
}
array_659.finish();
}
if let Some(var_662) = &input.caption_language_setting {
object
.key("captionLanguageSetting")
.string(var_662.as_str());
}
if let Some(var_663) = &input.client_cache {
object.key("clientCache").string(var_663.as_str());
}
if let Some(var_664) = &input.codec_specification {
object.key("codecSpecification").string(var_664.as_str());
}
if let Some(var_665) = &input.constant_iv {
object.key("constantIv").string(var_665.as_str());
}
if let Some(var_666) = &input.destination {
#[allow(unused_mut)]
let mut object_667 = object.key("destination").start_object();
crate::json_ser::serialize_structure_crate_model_output_location_ref(
&mut object_667,
var_666,
)?;
object_667.finish();
}
if let Some(var_668) = &input.directory_structure {
object.key("directoryStructure").string(var_668.as_str());
}
if let Some(var_669) = &input.discontinuity_tags {
object.key("discontinuityTags").string(var_669.as_str());
}
if let Some(var_670) = &input.encryption_type {
object.key("encryptionType").string(var_670.as_str());
}
if let Some(var_671) = &input.hls_cdn_settings {
#[allow(unused_mut)]
let mut object_672 = object.key("hlsCdnSettings").start_object();
crate::json_ser::serialize_structure_crate_model_hls_cdn_settings(
&mut object_672,
var_671,
)?;
object_672.finish();
}
if let Some(var_673) = &input.hls_id3_segment_tagging {
object.key("hlsId3SegmentTagging").string(var_673.as_str());
}
if let Some(var_674) = &input.i_frame_only_playlists {
object.key("iFrameOnlyPlaylists").string(var_674.as_str());
}
if let Some(var_675) = &input.incomplete_segment_behavior {
object
.key("incompleteSegmentBehavior")
.string(var_675.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_676) = &input.input_loss_action {
object.key("inputLossAction").string(var_676.as_str());
}
if let Some(var_677) = &input.iv_in_manifest {
object.key("ivInManifest").string(var_677.as_str());
}
if let Some(var_678) = &input.iv_source {
object.key("ivSource").string(var_678.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_679) = &input.key_format {
object.key("keyFormat").string(var_679.as_str());
}
if let Some(var_680) = &input.key_format_versions {
object.key("keyFormatVersions").string(var_680.as_str());
}
if let Some(var_681) = &input.key_provider_settings {
#[allow(unused_mut)]
let mut object_682 = object.key("keyProviderSettings").start_object();
crate::json_ser::serialize_structure_crate_model_key_provider_settings(
&mut object_682,
var_681,
)?;
object_682.finish();
}
if let Some(var_683) = &input.manifest_compression {
object.key("manifestCompression").string(var_683.as_str());
}
if let Some(var_684) = &input.manifest_duration_format {
object
.key("manifestDurationFormat")
.string(var_684.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_685) = &input.mode {
object.key("mode").string(var_685.as_str());
}
if let Some(var_686) = &input.output_selection {
object.key("outputSelection").string(var_686.as_str());
}
if let Some(var_687) = &input.program_date_time {
object.key("programDateTime").string(var_687.as_str());
}
if let Some(var_688) = &input.program_date_time_clock {
object.key("programDateTimeClock").string(var_688.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_689) = &input.redundant_manifest {
object.key("redundantManifest").string(var_689.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_690) = &input.segmentation_mode {
object.key("segmentationMode").string(var_690.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_691) = &input.stream_inf_resolution {
object.key("streamInfResolution").string(var_691.as_str());
}
if let Some(var_692) = &input.timed_metadata_id3_frame {
object.key("timedMetadataId3Frame").string(var_692.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_693) = &input.ts_file_mode {
object.key("tsFileMode").string(var_693.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::error::SerializationError> {
if let Some(var_694) = &input.destination {
#[allow(unused_mut)]
let mut object_695 = object.key("destination").start_object();
crate::json_ser::serialize_structure_crate_model_output_location_ref(
&mut object_695,
var_694,
)?;
object_695.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::error::SerializationError> {
if let Some(var_696) = &input.acquisition_point_id {
object.key("acquisitionPointId").string(var_696.as_str());
}
if let Some(var_697) = &input.audio_only_timecode_control {
object
.key("audioOnlyTimecodeControl")
.string(var_697.as_str());
}
if let Some(var_698) = &input.certificate_mode {
object.key("certificateMode").string(var_698.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_699) = &input.destination {
#[allow(unused_mut)]
let mut object_700 = object.key("destination").start_object();
crate::json_ser::serialize_structure_crate_model_output_location_ref(
&mut object_700,
var_699,
)?;
object_700.finish();
}
if let Some(var_701) = &input.event_id {
object.key("eventId").string(var_701.as_str());
}
if let Some(var_702) = &input.event_id_mode {
object.key("eventIdMode").string(var_702.as_str());
}
if let Some(var_703) = &input.event_stop_behavior {
object.key("eventStopBehavior").string(var_703.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_704) = &input.input_loss_action {
object.key("inputLossAction").string(var_704.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_705) = &input.segmentation_mode {
object.key("segmentationMode").string(var_705.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_706) = &input.sparse_track_type {
object.key("sparseTrackType").string(var_706.as_str());
}
if let Some(var_707) = &input.stream_manifest_behavior {
object
.key("streamManifestBehavior")
.string(var_707.as_str());
}
if let Some(var_708) = &input.timestamp_offset {
object.key("timestampOffset").string(var_708.as_str());
}
if let Some(var_709) = &input.timestamp_offset_mode {
object.key("timestampOffsetMode").string(var_709.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::error::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::error::SerializationError> {
if let Some(var_710) = &input.ad_markers {
let mut array_711 = object.key("adMarkers").start_array();
for item_712 in var_710 {
{
array_711.value().string(item_712.as_str());
}
}
array_711.finish();
}
if let Some(var_713) = &input.authentication_scheme {
object.key("authenticationScheme").string(var_713.as_str());
}
if let Some(var_714) = &input.cache_full_behavior {
object.key("cacheFullBehavior").string(var_714.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_715) = &input.caption_data {
object.key("captionData").string(var_715.as_str());
}
if let Some(var_716) = &input.input_loss_action {
object.key("inputLossAction").string(var_716.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::error::SerializationError> {
if let Some(var_717) = &input.input_loss_action {
object.key("inputLossAction").string(var_717.as_str());
}
if let Some(var_718) = &input.timed_metadata_id3_frame {
object.key("timedMetadataId3Frame").string(var_718.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::error::SerializationError> {
if let Some(var_719) = &input.archive_output_settings {
#[allow(unused_mut)]
let mut object_720 = object.key("archiveOutputSettings").start_object();
crate::json_ser::serialize_structure_crate_model_archive_output_settings(
&mut object_720,
var_719,
)?;
object_720.finish();
}
if let Some(var_721) = &input.frame_capture_output_settings {
#[allow(unused_mut)]
let mut object_722 = object.key("frameCaptureOutputSettings").start_object();
crate::json_ser::serialize_structure_crate_model_frame_capture_output_settings(
&mut object_722,
var_721,
)?;
object_722.finish();
}
if let Some(var_723) = &input.hls_output_settings {
#[allow(unused_mut)]
let mut object_724 = object.key("hlsOutputSettings").start_object();
crate::json_ser::serialize_structure_crate_model_hls_output_settings(
&mut object_724,
var_723,
)?;
object_724.finish();
}
if let Some(var_725) = &input.media_package_output_settings {
#[allow(unused_mut)]
let mut object_726 = object.key("mediaPackageOutputSettings").start_object();
crate::json_ser::serialize_structure_crate_model_media_package_output_settings(
&mut object_726,
var_725,
)?;
object_726.finish();
}
if let Some(var_727) = &input.ms_smooth_output_settings {
#[allow(unused_mut)]
let mut object_728 = object.key("msSmoothOutputSettings").start_object();
crate::json_ser::serialize_structure_crate_model_ms_smooth_output_settings(
&mut object_728,
var_727,
)?;
object_728.finish();
}
if let Some(var_729) = &input.multiplex_output_settings {
#[allow(unused_mut)]
let mut object_730 = object.key("multiplexOutputSettings").start_object();
crate::json_ser::serialize_structure_crate_model_multiplex_output_settings(
&mut object_730,
var_729,
)?;
object_730.finish();
}
if let Some(var_731) = &input.rtmp_output_settings {
#[allow(unused_mut)]
let mut object_732 = object.key("rtmpOutputSettings").start_object();
crate::json_ser::serialize_structure_crate_model_rtmp_output_settings(
&mut object_732,
var_731,
)?;
object_732.finish();
}
if let Some(var_733) = &input.udp_output_settings {
#[allow(unused_mut)]
let mut object_734 = object.key("udpOutputSettings").start_object();
crate::json_ser::serialize_structure_crate_model_udp_output_settings(
&mut object_734,
var_733,
)?;
object_734.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::error::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_735) = &input.capture_interval_units {
object.key("captureIntervalUnits").string(var_735.as_str());
}
if let Some(var_736) = &input.timecode_burnin_settings {
#[allow(unused_mut)]
let mut object_737 = object.key("timecodeBurninSettings").start_object();
crate::json_ser::serialize_structure_crate_model_timecode_burnin_settings(
&mut object_737,
var_736,
)?;
object_737.finish();
}
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::error::SerializationError> {
if let Some(var_738) = &input.adaptive_quantization {
object.key("adaptiveQuantization").string(var_738.as_str());
}
if let Some(var_739) = &input.afd_signaling {
object.key("afdSignaling").string(var_739.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_740) = &input.color_metadata {
object.key("colorMetadata").string(var_740.as_str());
}
if let Some(var_741) = &input.color_space_settings {
#[allow(unused_mut)]
let mut object_742 = object.key("colorSpaceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_h264_color_space_settings(
&mut object_742,
var_741,
)?;
object_742.finish();
}
if let Some(var_743) = &input.entropy_encoding {
object.key("entropyEncoding").string(var_743.as_str());
}
if let Some(var_744) = &input.filter_settings {
#[allow(unused_mut)]
let mut object_745 = object.key("filterSettings").start_object();
crate::json_ser::serialize_structure_crate_model_h264_filter_settings(
&mut object_745,
var_744,
)?;
object_745.finish();
}
if let Some(var_746) = &input.fixed_afd {
object.key("fixedAfd").string(var_746.as_str());
}
if let Some(var_747) = &input.flicker_aq {
object.key("flickerAq").string(var_747.as_str());
}
if let Some(var_748) = &input.force_field_pictures {
object.key("forceFieldPictures").string(var_748.as_str());
}
if let Some(var_749) = &input.framerate_control {
object.key("framerateControl").string(var_749.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_750) = &input.gop_b_reference {
object.key("gopBReference").string(var_750.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_751) = &input.gop_size_units {
object.key("gopSizeUnits").string(var_751.as_str());
}
if let Some(var_752) = &input.level {
object.key("level").string(var_752.as_str());
}
if let Some(var_753) = &input.look_ahead_rate_control {
object.key("lookAheadRateControl").string(var_753.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_754) = &input.par_control {
object.key("parControl").string(var_754.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_755) = &input.profile {
object.key("profile").string(var_755.as_str());
}
if let Some(var_756) = &input.quality_level {
object.key("qualityLevel").string(var_756.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_757) = &input.rate_control_mode {
object.key("rateControlMode").string(var_757.as_str());
}
if let Some(var_758) = &input.scan_type {
object.key("scanType").string(var_758.as_str());
}
if let Some(var_759) = &input.scene_change_detect {
object.key("sceneChangeDetect").string(var_759.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_760) = &input.spatial_aq {
object.key("spatialAq").string(var_760.as_str());
}
if let Some(var_761) = &input.subgop_length {
object.key("subgopLength").string(var_761.as_str());
}
if let Some(var_762) = &input.syntax {
object.key("syntax").string(var_762.as_str());
}
if let Some(var_763) = &input.temporal_aq {
object.key("temporalAq").string(var_763.as_str());
}
if let Some(var_764) = &input.timecode_insertion {
object.key("timecodeInsertion").string(var_764.as_str());
}
if let Some(var_765) = &input.timecode_burnin_settings {
#[allow(unused_mut)]
let mut object_766 = object.key("timecodeBurninSettings").start_object();
crate::json_ser::serialize_structure_crate_model_timecode_burnin_settings(
&mut object_766,
var_765,
)?;
object_766.finish();
}
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::error::SerializationError> {
if let Some(var_767) = &input.adaptive_quantization {
object.key("adaptiveQuantization").string(var_767.as_str());
}
if let Some(var_768) = &input.afd_signaling {
object.key("afdSignaling").string(var_768.as_str());
}
if let Some(var_769) = &input.alternative_transfer_function {
object
.key("alternativeTransferFunction")
.string(var_769.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_770) = &input.color_metadata {
object.key("colorMetadata").string(var_770.as_str());
}
if let Some(var_771) = &input.color_space_settings {
#[allow(unused_mut)]
let mut object_772 = object.key("colorSpaceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_h265_color_space_settings(
&mut object_772,
var_771,
)?;
object_772.finish();
}
if let Some(var_773) = &input.filter_settings {
#[allow(unused_mut)]
let mut object_774 = object.key("filterSettings").start_object();
crate::json_ser::serialize_structure_crate_model_h265_filter_settings(
&mut object_774,
var_773,
)?;
object_774.finish();
}
if let Some(var_775) = &input.fixed_afd {
object.key("fixedAfd").string(var_775.as_str());
}
if let Some(var_776) = &input.flicker_aq {
object.key("flickerAq").string(var_776.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_777) = &input.gop_size_units {
object.key("gopSizeUnits").string(var_777.as_str());
}
if let Some(var_778) = &input.level {
object.key("level").string(var_778.as_str());
}
if let Some(var_779) = &input.look_ahead_rate_control {
object.key("lookAheadRateControl").string(var_779.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_780) = &input.profile {
object.key("profile").string(var_780.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_781) = &input.rate_control_mode {
object.key("rateControlMode").string(var_781.as_str());
}
if let Some(var_782) = &input.scan_type {
object.key("scanType").string(var_782.as_str());
}
if let Some(var_783) = &input.scene_change_detect {
object.key("sceneChangeDetect").string(var_783.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_784) = &input.tier {
object.key("tier").string(var_784.as_str());
}
if let Some(var_785) = &input.timecode_insertion {
object.key("timecodeInsertion").string(var_785.as_str());
}
if let Some(var_786) = &input.timecode_burnin_settings {
#[allow(unused_mut)]
let mut object_787 = object.key("timecodeBurninSettings").start_object();
crate::json_ser::serialize_structure_crate_model_timecode_burnin_settings(
&mut object_787,
var_786,
)?;
object_787.finish();
}
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::error::SerializationError> {
if let Some(var_788) = &input.adaptive_quantization {
object.key("adaptiveQuantization").string(var_788.as_str());
}
if let Some(var_789) = &input.afd_signaling {
object.key("afdSignaling").string(var_789.as_str());
}
if let Some(var_790) = &input.color_metadata {
object.key("colorMetadata").string(var_790.as_str());
}
if let Some(var_791) = &input.color_space {
object.key("colorSpace").string(var_791.as_str());
}
if let Some(var_792) = &input.display_aspect_ratio {
object.key("displayAspectRatio").string(var_792.as_str());
}
if let Some(var_793) = &input.filter_settings {
#[allow(unused_mut)]
let mut object_794 = object.key("filterSettings").start_object();
crate::json_ser::serialize_structure_crate_model_mpeg2_filter_settings(
&mut object_794,
var_793,
)?;
object_794.finish();
}
if let Some(var_795) = &input.fixed_afd {
object.key("fixedAfd").string(var_795.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_796) = &input.gop_size_units {
object.key("gopSizeUnits").string(var_796.as_str());
}
if let Some(var_797) = &input.scan_type {
object.key("scanType").string(var_797.as_str());
}
if let Some(var_798) = &input.subgop_length {
object.key("subgopLength").string(var_798.as_str());
}
if let Some(var_799) = &input.timecode_insertion {
object.key("timecodeInsertion").string(var_799.as_str());
}
if let Some(var_800) = &input.timecode_burnin_settings {
#[allow(unused_mut)]
let mut object_801 = object.key("timecodeBurninSettings").start_object();
crate::json_ser::serialize_structure_crate_model_timecode_burnin_settings(
&mut object_801,
var_800,
)?;
object_801.finish();
}
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::error::SerializationError> {
if let Some(var_802) = &input.audio_silence_settings {
#[allow(unused_mut)]
let mut object_803 = object.key("audioSilenceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_audio_silence_failover_settings(
&mut object_803,
var_802,
)?;
object_803.finish();
}
if let Some(var_804) = &input.input_loss_settings {
#[allow(unused_mut)]
let mut object_805 = object.key("inputLossSettings").start_object();
crate::json_ser::serialize_structure_crate_model_input_loss_failover_settings(
&mut object_805,
var_804,
)?;
object_805.finish();
}
if let Some(var_806) = &input.video_black_settings {
#[allow(unused_mut)]
let mut object_807 = object.key("videoBlackSettings").start_object();
crate::json_ser::serialize_structure_crate_model_video_black_failover_settings(
&mut object_807,
var_806,
)?;
object_807.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::error::SerializationError> {
if let Some(var_808) = &input.audio_hls_rendition_selection {
#[allow(unused_mut)]
let mut object_809 = object.key("audioHlsRenditionSelection").start_object();
crate::json_ser::serialize_structure_crate_model_audio_hls_rendition_selection(
&mut object_809,
var_808,
)?;
object_809.finish();
}
if let Some(var_810) = &input.audio_language_selection {
#[allow(unused_mut)]
let mut object_811 = object.key("audioLanguageSelection").start_object();
crate::json_ser::serialize_structure_crate_model_audio_language_selection(
&mut object_811,
var_810,
)?;
object_811.finish();
}
if let Some(var_812) = &input.audio_pid_selection {
#[allow(unused_mut)]
let mut object_813 = object.key("audioPidSelection").start_object();
crate::json_ser::serialize_structure_crate_model_audio_pid_selection(
&mut object_813,
var_812,
)?;
object_813.finish();
}
if let Some(var_814) = &input.audio_track_selection {
#[allow(unused_mut)]
let mut object_815 = object.key("audioTrackSelection").start_object();
crate::json_ser::serialize_structure_crate_model_audio_track_selection(
&mut object_815,
var_814,
)?;
object_815.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::error::SerializationError> {
if let Some(var_816) = &input.ancillary_source_settings {
#[allow(unused_mut)]
let mut object_817 = object.key("ancillarySourceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_ancillary_source_settings(
&mut object_817,
var_816,
)?;
object_817.finish();
}
if let Some(var_818) = &input.arib_source_settings {
#[allow(unused_mut)]
let mut object_819 = object.key("aribSourceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_arib_source_settings(
&mut object_819,
var_818,
)?;
object_819.finish();
}
if let Some(var_820) = &input.dvb_sub_source_settings {
#[allow(unused_mut)]
let mut object_821 = object.key("dvbSubSourceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_dvb_sub_source_settings(
&mut object_821,
var_820,
)?;
object_821.finish();
}
if let Some(var_822) = &input.embedded_source_settings {
#[allow(unused_mut)]
let mut object_823 = object.key("embeddedSourceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_embedded_source_settings(
&mut object_823,
var_822,
)?;
object_823.finish();
}
if let Some(var_824) = &input.scte20_source_settings {
#[allow(unused_mut)]
let mut object_825 = object.key("scte20SourceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_scte20_source_settings(
&mut object_825,
var_824,
)?;
object_825.finish();
}
if let Some(var_826) = &input.scte27_source_settings {
#[allow(unused_mut)]
let mut object_827 = object.key("scte27SourceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_scte27_source_settings(
&mut object_827,
var_826,
)?;
object_827.finish();
}
if let Some(var_828) = &input.teletext_source_settings {
#[allow(unused_mut)]
let mut object_829 = object.key("teletextSourceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_teletext_source_settings(
&mut object_829,
var_828,
)?;
object_829.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::error::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_830) = &input.scte35_source {
object.key("scte35Source").string(var_830.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::error::SerializationError> {
if let Some(var_831) = &input.hdr10_settings {
#[allow(unused_mut)]
let mut object_832 = object.key("hdr10Settings").start_object();
crate::json_ser::serialize_structure_crate_model_hdr10_settings(&mut object_832, var_831)?;
object_832.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::error::SerializationError> {
if let Some(var_833) = &input.video_selector_pid {
#[allow(unused_mut)]
let mut object_834 = object.key("videoSelectorPid").start_object();
crate::json_ser::serialize_structure_crate_model_video_selector_pid(
&mut object_834,
var_833,
)?;
object_834.finish();
}
if let Some(var_835) = &input.video_selector_program_id {
#[allow(unused_mut)]
let mut object_836 = object.key("videoSelectorProgramId").start_object();
crate::json_ser::serialize_structure_crate_model_video_selector_program_id(
&mut object_836,
var_835,
)?;
object_836.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::error::SerializationError> {
if let Some(var_837) = &input.input_timecode_source {
object.key("inputTimecodeSource").string(var_837.as_str());
}
if let Some(var_838) = &input.start_timecode {
#[allow(unused_mut)]
let mut object_839 = object.key("startTimecode").start_object();
crate::json_ser::serialize_structure_crate_model_start_timecode(&mut object_839, var_838)?;
object_839.finish();
}
if let Some(var_840) = &input.stop_timecode {
#[allow(unused_mut)]
let mut object_841 = object.key("stopTimecode").start_object();
crate::json_ser::serialize_structure_crate_model_stop_timecode(&mut object_841, var_840)?;
object_841.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::error::SerializationError> {
if let Some(var_842) = &input.pipeline_id {
object.key("pipelineId").string(var_842.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::error::SerializationError> {
if let Some(var_843) = &input.scte35_descriptor_settings {
#[allow(unused_mut)]
let mut object_844 = object.key("scte35DescriptorSettings").start_object();
crate::json_ser::serialize_structure_crate_model_scte35_descriptor_settings(
&mut object_844,
var_843,
)?;
object_844.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::error::SerializationError> {
if let Some(var_845) = &input.cbet_check_digit_string {
object.key("cbetCheckDigitString").string(var_845.as_str());
}
if let Some(var_846) = &input.cbet_stepaside {
object.key("cbetStepaside").string(var_846.as_str());
}
if let Some(var_847) = &input.csid {
object.key("csid").string(var_847.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::error::SerializationError> {
if let Some(var_848) = &input.check_digit_string {
object.key("checkDigitString").string(var_848.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::error::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::error::SerializationError> {
if let Some(var_849) = &input.archive_s3_settings {
#[allow(unused_mut)]
let mut object_850 = object.key("archiveS3Settings").start_object();
crate::json_ser::serialize_structure_crate_model_archive_s3_settings(
&mut object_850,
var_849,
)?;
object_850.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::error::SerializationError> {
if let Some(var_851) = &input.destination_ref_id {
object.key("destinationRefId").string(var_851.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::error::SerializationError> {
if let Some(var_852) = &input.frame_capture_s3_settings {
#[allow(unused_mut)]
let mut object_853 = object.key("frameCaptureS3Settings").start_object();
crate::json_ser::serialize_structure_crate_model_frame_capture_s3_settings(
&mut object_853,
var_852,
)?;
object_853.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::error::SerializationError> {
{
object.key("captionChannel").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.caption_channel).into()),
);
}
if let Some(var_854) = &input.language_code {
object.key("languageCode").string(var_854.as_str());
}
if let Some(var_855) = &input.language_description {
object.key("languageDescription").string(var_855.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::error::SerializationError> {
if let Some(var_856) = &input.hls_akamai_settings {
#[allow(unused_mut)]
let mut object_857 = object.key("hlsAkamaiSettings").start_object();
crate::json_ser::serialize_structure_crate_model_hls_akamai_settings(
&mut object_857,
var_856,
)?;
object_857.finish();
}
if let Some(var_858) = &input.hls_basic_put_settings {
#[allow(unused_mut)]
let mut object_859 = object.key("hlsBasicPutSettings").start_object();
crate::json_ser::serialize_structure_crate_model_hls_basic_put_settings(
&mut object_859,
var_858,
)?;
object_859.finish();
}
if let Some(var_860) = &input.hls_media_store_settings {
#[allow(unused_mut)]
let mut object_861 = object.key("hlsMediaStoreSettings").start_object();
crate::json_ser::serialize_structure_crate_model_hls_media_store_settings(
&mut object_861,
var_860,
)?;
object_861.finish();
}
if let Some(var_862) = &input.hls_s3_settings {
#[allow(unused_mut)]
let mut object_863 = object.key("hlsS3Settings").start_object();
crate::json_ser::serialize_structure_crate_model_hls_s3_settings(&mut object_863, var_862)?;
object_863.finish();
}
if let Some(var_864) = &input.hls_webdav_settings {
#[allow(unused_mut)]
let mut object_865 = object.key("hlsWebdavSettings").start_object();
crate::json_ser::serialize_structure_crate_model_hls_webdav_settings(
&mut object_865,
var_864,
)?;
object_865.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::error::SerializationError> {
if let Some(var_866) = &input.static_key_settings {
#[allow(unused_mut)]
let mut object_867 = object.key("staticKeySettings").start_object();
crate::json_ser::serialize_structure_crate_model_static_key_settings(
&mut object_867,
var_866,
)?;
object_867.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::error::SerializationError> {
if let Some(var_868) = &input.container_settings {
#[allow(unused_mut)]
let mut object_869 = object.key("containerSettings").start_object();
crate::json_ser::serialize_structure_crate_model_archive_container_settings(
&mut object_869,
var_868,
)?;
object_869.finish();
}
if let Some(var_870) = &input.extension {
object.key("extension").string(var_870.as_str());
}
if let Some(var_871) = &input.name_modifier {
object.key("nameModifier").string(var_871.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::error::SerializationError> {
if let Some(var_872) = &input.name_modifier {
object.key("nameModifier").string(var_872.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::error::SerializationError> {
if let Some(var_873) = &input.h265_packaging_type {
object.key("h265PackagingType").string(var_873.as_str());
}
if let Some(var_874) = &input.hls_settings {
#[allow(unused_mut)]
let mut object_875 = object.key("hlsSettings").start_object();
crate::json_ser::serialize_structure_crate_model_hls_settings(&mut object_875, var_874)?;
object_875.finish();
}
if let Some(var_876) = &input.name_modifier {
object.key("nameModifier").string(var_876.as_str());
}
if let Some(var_877) = &input.segment_modifier {
object.key("segmentModifier").string(var_877.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::error::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::error::SerializationError> {
if let Some(var_878) = &input.h265_packaging_type {
object.key("h265PackagingType").string(var_878.as_str());
}
if let Some(var_879) = &input.name_modifier {
object.key("nameModifier").string(var_879.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::error::SerializationError> {
if let Some(var_880) = &input.destination {
#[allow(unused_mut)]
let mut object_881 = object.key("destination").start_object();
crate::json_ser::serialize_structure_crate_model_output_location_ref(
&mut object_881,
var_880,
)?;
object_881.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::error::SerializationError> {
if let Some(var_882) = &input.certificate_mode {
object.key("certificateMode").string(var_882.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_883) = &input.destination {
#[allow(unused_mut)]
let mut object_884 = object.key("destination").start_object();
crate::json_ser::serialize_structure_crate_model_output_location_ref(
&mut object_884,
var_883,
)?;
object_884.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::error::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_885) = &input.container_settings {
#[allow(unused_mut)]
let mut object_886 = object.key("containerSettings").start_object();
crate::json_ser::serialize_structure_crate_model_udp_container_settings(
&mut object_886,
var_885,
)?;
object_886.finish();
}
if let Some(var_887) = &input.destination {
#[allow(unused_mut)]
let mut object_888 = object.key("destination").start_object();
crate::json_ser::serialize_structure_crate_model_output_location_ref(
&mut object_888,
var_887,
)?;
object_888.finish();
}
if let Some(var_889) = &input.fec_output_settings {
#[allow(unused_mut)]
let mut object_890 = object.key("fecOutputSettings").start_object();
crate::json_ser::serialize_structure_crate_model_fec_output_settings(
&mut object_890,
var_889,
)?;
object_890.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_timecode_burnin_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimecodeBurninSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_891) = &input.font_size {
object.key("fontSize").string(var_891.as_str());
}
if let Some(var_892) = &input.position {
object.key("position").string(var_892.as_str());
}
if let Some(var_893) = &input.prefix {
object.key("prefix").string(var_893.as_str());
}
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::error::SerializationError> {
if let Some(var_894) = &input.color_space_passthrough_settings {
#[allow(unused_mut)]
let mut object_895 = object.key("colorSpacePassthroughSettings").start_object();
crate::json_ser::serialize_structure_crate_model_color_space_passthrough_settings(
&mut object_895,
var_894,
)?;
object_895.finish();
}
if let Some(var_896) = &input.rec601_settings {
#[allow(unused_mut)]
let mut object_897 = object.key("rec601Settings").start_object();
crate::json_ser::serialize_structure_crate_model_rec601_settings(&mut object_897, var_896)?;
object_897.finish();
}
if let Some(var_898) = &input.rec709_settings {
#[allow(unused_mut)]
let mut object_899 = object.key("rec709Settings").start_object();
crate::json_ser::serialize_structure_crate_model_rec709_settings(&mut object_899, var_898)?;
object_899.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::error::SerializationError> {
if let Some(var_900) = &input.temporal_filter_settings {
#[allow(unused_mut)]
let mut object_901 = object.key("temporalFilterSettings").start_object();
crate::json_ser::serialize_structure_crate_model_temporal_filter_settings(
&mut object_901,
var_900,
)?;
object_901.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::error::SerializationError> {
if let Some(var_902) = &input.color_space_passthrough_settings {
#[allow(unused_mut)]
let mut object_903 = object.key("colorSpacePassthroughSettings").start_object();
crate::json_ser::serialize_structure_crate_model_color_space_passthrough_settings(
&mut object_903,
var_902,
)?;
object_903.finish();
}
if let Some(var_904) = &input.dolby_vision81_settings {
#[allow(unused_mut)]
let mut object_905 = object.key("dolbyVision81Settings").start_object();
crate::json_ser::serialize_structure_crate_model_dolby_vision81_settings(
&mut object_905,
var_904,
)?;
object_905.finish();
}
if let Some(var_906) = &input.hdr10_settings {
#[allow(unused_mut)]
let mut object_907 = object.key("hdr10Settings").start_object();
crate::json_ser::serialize_structure_crate_model_hdr10_settings(&mut object_907, var_906)?;
object_907.finish();
}
if let Some(var_908) = &input.rec601_settings {
#[allow(unused_mut)]
let mut object_909 = object.key("rec601Settings").start_object();
crate::json_ser::serialize_structure_crate_model_rec601_settings(&mut object_909, var_908)?;
object_909.finish();
}
if let Some(var_910) = &input.rec709_settings {
#[allow(unused_mut)]
let mut object_911 = object.key("rec709Settings").start_object();
crate::json_ser::serialize_structure_crate_model_rec709_settings(&mut object_911, var_910)?;
object_911.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::error::SerializationError> {
if let Some(var_912) = &input.temporal_filter_settings {
#[allow(unused_mut)]
let mut object_913 = object.key("temporalFilterSettings").start_object();
crate::json_ser::serialize_structure_crate_model_temporal_filter_settings(
&mut object_913,
var_912,
)?;
object_913.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::error::SerializationError> {
if let Some(var_914) = &input.temporal_filter_settings {
#[allow(unused_mut)]
let mut object_915 = object.key("temporalFilterSettings").start_object();
crate::json_ser::serialize_structure_crate_model_temporal_filter_settings(
&mut object_915,
var_914,
)?;
object_915.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::error::SerializationError> {
if let Some(var_916) = &input.audio_selector_name {
object.key("audioSelectorName").string(var_916.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::error::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::error::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::error::SerializationError> {
if let Some(var_917) = &input.group_id {
object.key("groupId").string(var_917.as_str());
}
if let Some(var_918) = &input.name {
object.key("name").string(var_918.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::error::SerializationError> {
if let Some(var_919) = &input.language_code {
object.key("languageCode").string(var_919.as_str());
}
if let Some(var_920) = &input.language_selection_policy {
object
.key("languageSelectionPolicy")
.string(var_920.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::error::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::error::SerializationError> {
if let Some(var_921) = &input.tracks {
let mut array_922 = object.key("tracks").start_array();
for item_923 in var_921 {
{
#[allow(unused_mut)]
let mut object_924 = array_922.value().start_object();
crate::json_ser::serialize_structure_crate_model_audio_track(
&mut object_924,
item_923,
)?;
object_924.finish();
}
}
array_922.finish();
}
if let Some(var_925) = &input.dolby_e_decode {
#[allow(unused_mut)]
let mut object_926 = object.key("dolbyEDecode").start_object();
crate::json_ser::serialize_structure_crate_model_audio_dolby_e_decode(
&mut object_926,
var_925,
)?;
object_926.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::error::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::error::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::error::SerializationError> {
if let Some(var_927) = &input.ocr_language {
object.key("ocrLanguage").string(var_927.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::error::SerializationError> {
if let Some(var_928) = &input.convert608_to708 {
object.key("convert608To708").string(var_928.as_str());
}
if let Some(var_929) = &input.scte20_detection {
object.key("scte20Detection").string(var_929.as_str());
}
if input.source608_channel_number != 0 {
object.key("source608ChannelNumber").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.source608_channel_number).into()),
);
}
if input.source608_track_number != 0 {
object.key("source608TrackNumber").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.source608_track_number).into()),
);
}
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::error::SerializationError> {
if let Some(var_930) = &input.convert608_to708 {
object.key("convert608To708").string(var_930.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::error::SerializationError> {
if let Some(var_931) = &input.ocr_language {
object.key("ocrLanguage").string(var_931.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::error::SerializationError> {
if let Some(var_932) = &input.output_rectangle {
#[allow(unused_mut)]
let mut object_933 = object.key("outputRectangle").start_object();
crate::json_ser::serialize_structure_crate_model_caption_rectangle(
&mut object_933,
var_932,
)?;
object_933.finish();
}
if let Some(var_934) = &input.page_number {
object.key("pageNumber").string(var_934.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::error::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::error::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::error::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::error::SerializationError> {
if let Some(var_935) = &input.timecode {
object.key("timecode").string(var_935.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::error::SerializationError> {
if let Some(var_936) = &input.last_frame_clipping_behavior {
object
.key("lastFrameClippingBehavior")
.string(var_936.as_str());
}
if let Some(var_937) = &input.timecode {
object.key("timecode").string(var_937.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::error::SerializationError> {
if let Some(var_938) = &input.segmentation_descriptor_scte35_descriptor_settings {
#[allow(unused_mut)]
let mut object_939 = object
.key("segmentationDescriptorScte35DescriptorSettings")
.start_object();
crate::json_ser::serialize_structure_crate_model_scte35_segmentation_descriptor(
&mut object_939,
var_938,
)?;
object_939.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::error::SerializationError> {
if let Some(var_940) = &input.canned_acl {
object.key("cannedAcl").string(var_940.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::error::SerializationError> {
if let Some(var_941) = &input.canned_acl {
object.key("cannedAcl").string(var_941.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::error::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_942) = &input.http_transfer_mode {
object.key("httpTransferMode").string(var_942.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_943) = &input.salt {
object.key("salt").string(var_943.as_str());
}
if let Some(var_944) = &input.token {
object.key("token").string(var_944.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::error::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::error::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_945) = &input.media_store_storage_class {
object
.key("mediaStoreStorageClass")
.string(var_945.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::error::SerializationError> {
if let Some(var_946) = &input.canned_acl {
object.key("cannedAcl").string(var_946.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::error::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_947) = &input.http_transfer_mode {
object.key("httpTransferMode").string(var_947.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::error::SerializationError> {
if let Some(var_948) = &input.key_provider_server {
#[allow(unused_mut)]
let mut object_949 = object.key("keyProviderServer").start_object();
crate::json_ser::serialize_structure_crate_model_input_location(&mut object_949, var_948)?;
object_949.finish();
}
if let Some(var_950) = &input.static_key_value {
object.key("staticKeyValue").string(var_950.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::error::SerializationError> {
if let Some(var_951) = &input.m2ts_settings {
#[allow(unused_mut)]
let mut object_952 = object.key("m2tsSettings").start_object();
crate::json_ser::serialize_structure_crate_model_m2ts_settings(&mut object_952, var_951)?;
object_952.finish();
}
if let Some(var_953) = &input.raw_settings {
#[allow(unused_mut)]
let mut object_954 = object.key("rawSettings").start_object();
crate::json_ser::serialize_structure_crate_model_raw_settings(&mut object_954, var_953)?;
object_954.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::error::SerializationError> {
if let Some(var_955) = &input.audio_only_hls_settings {
#[allow(unused_mut)]
let mut object_956 = object.key("audioOnlyHlsSettings").start_object();
crate::json_ser::serialize_structure_crate_model_audio_only_hls_settings(
&mut object_956,
var_955,
)?;
object_956.finish();
}
if let Some(var_957) = &input.fmp4_hls_settings {
#[allow(unused_mut)]
let mut object_958 = object.key("fmp4HlsSettings").start_object();
crate::json_ser::serialize_structure_crate_model_fmp4_hls_settings(
&mut object_958,
var_957,
)?;
object_958.finish();
}
if let Some(var_959) = &input.frame_capture_hls_settings {
#[allow(unused_mut)]
let mut object_960 = object.key("frameCaptureHlsSettings").start_object();
crate::json_ser::serialize_structure_crate_model_frame_capture_hls_settings(
&mut object_960,
var_959,
)?;
object_960.finish();
}
if let Some(var_961) = &input.standard_hls_settings {
#[allow(unused_mut)]
let mut object_962 = object.key("standardHlsSettings").start_object();
crate::json_ser::serialize_structure_crate_model_standard_hls_settings(
&mut object_962,
var_961,
)?;
object_962.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::error::SerializationError> {
if let Some(var_963) = &input.m2ts_settings {
#[allow(unused_mut)]
let mut object_964 = object.key("m2tsSettings").start_object();
crate::json_ser::serialize_structure_crate_model_m2ts_settings(&mut object_964, var_963)?;
object_964.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::error::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_965) = &input.include_fec {
object.key("includeFec").string(var_965.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::error::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::error::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::error::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::error::SerializationError> {
if let Some(var_966) = &input.post_filter_sharpening {
object.key("postFilterSharpening").string(var_966.as_str());
}
if let Some(var_967) = &input.strength {
object.key("strength").string(var_967.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dolby_vision81_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DolbyVision81Settings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
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::error::SerializationError> {
{
object.key("track").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.track).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_audio_dolby_e_decode(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AudioDolbyEDecode,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_968) = &input.program_selection {
object.key("programSelection").string(var_968.as_str());
}
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::error::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::error::SerializationError> {
if let Some(var_969) = &input.delivery_restrictions {
#[allow(unused_mut)]
let mut object_970 = object.key("deliveryRestrictions").start_object();
crate::json_ser::serialize_structure_crate_model_scte35_delivery_restrictions(
&mut object_970,
var_969,
)?;
object_970.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_971) = &input.segmentation_cancel_indicator {
object
.key("segmentationCancelIndicator")
.string(var_971.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_972) = &input.segmentation_upid {
object.key("segmentationUpid").string(var_972.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::error::SerializationError> {
if let Some(var_973) = &input.absent_input_audio_behavior {
object
.key("absentInputAudioBehavior")
.string(var_973.as_str());
}
if let Some(var_974) = &input.arib {
object.key("arib").string(var_974.as_str());
}
if let Some(var_975) = &input.arib_captions_pid {
object.key("aribCaptionsPid").string(var_975.as_str());
}
if let Some(var_976) = &input.arib_captions_pid_control {
object
.key("aribCaptionsPidControl")
.string(var_976.as_str());
}
if let Some(var_977) = &input.audio_buffer_model {
object.key("audioBufferModel").string(var_977.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_978) = &input.audio_pids {
object.key("audioPids").string(var_978.as_str());
}
if let Some(var_979) = &input.audio_stream_type {
object.key("audioStreamType").string(var_979.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_980) = &input.buffer_model {
object.key("bufferModel").string(var_980.as_str());
}
if let Some(var_981) = &input.cc_descriptor {
object.key("ccDescriptor").string(var_981.as_str());
}
if let Some(var_982) = &input.dvb_nit_settings {
#[allow(unused_mut)]
let mut object_983 = object.key("dvbNitSettings").start_object();
crate::json_ser::serialize_structure_crate_model_dvb_nit_settings(
&mut object_983,
var_982,
)?;
object_983.finish();
}
if let Some(var_984) = &input.dvb_sdt_settings {
#[allow(unused_mut)]
let mut object_985 = object.key("dvbSdtSettings").start_object();
crate::json_ser::serialize_structure_crate_model_dvb_sdt_settings(
&mut object_985,
var_984,
)?;
object_985.finish();
}
if let Some(var_986) = &input.dvb_sub_pids {
object.key("dvbSubPids").string(var_986.as_str());
}
if let Some(var_987) = &input.dvb_tdt_settings {
#[allow(unused_mut)]
let mut object_988 = object.key("dvbTdtSettings").start_object();
crate::json_ser::serialize_structure_crate_model_dvb_tdt_settings(
&mut object_988,
var_987,
)?;
object_988.finish();
}
if let Some(var_989) = &input.dvb_teletext_pid {
object.key("dvbTeletextPid").string(var_989.as_str());
}
if let Some(var_990) = &input.ebif {
object.key("ebif").string(var_990.as_str());
}
if let Some(var_991) = &input.ebp_audio_interval {
object.key("ebpAudioInterval").string(var_991.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_992) = &input.ebp_placement {
object.key("ebpPlacement").string(var_992.as_str());
}
if let Some(var_993) = &input.ecm_pid {
object.key("ecmPid").string(var_993.as_str());
}
if let Some(var_994) = &input.es_rate_in_pes {
object.key("esRateInPes").string(var_994.as_str());
}
if let Some(var_995) = &input.etv_platform_pid {
object.key("etvPlatformPid").string(var_995.as_str());
}
if let Some(var_996) = &input.etv_signal_pid {
object.key("etvSignalPid").string(var_996.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_997) = &input.klv {
object.key("klv").string(var_997.as_str());
}
if let Some(var_998) = &input.klv_data_pids {
object.key("klvDataPids").string(var_998.as_str());
}
if let Some(var_999) = &input.nielsen_id3_behavior {
object.key("nielsenId3Behavior").string(var_999.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_1000) = &input.pcr_control {
object.key("pcrControl").string(var_1000.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_1001) = &input.pcr_pid {
object.key("pcrPid").string(var_1001.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_1002) = &input.pmt_pid {
object.key("pmtPid").string(var_1002.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_1003) = &input.rate_mode {
object.key("rateMode").string(var_1003.as_str());
}
if let Some(var_1004) = &input.scte27_pids {
object.key("scte27Pids").string(var_1004.as_str());
}
if let Some(var_1005) = &input.scte35_control {
object.key("scte35Control").string(var_1005.as_str());
}
if let Some(var_1006) = &input.scte35_pid {
object.key("scte35Pid").string(var_1006.as_str());
}
if let Some(var_1007) = &input.segmentation_markers {
object.key("segmentationMarkers").string(var_1007.as_str());
}
if let Some(var_1008) = &input.segmentation_style {
object.key("segmentationStyle").string(var_1008.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_1009) = &input.timed_metadata_behavior {
object
.key("timedMetadataBehavior")
.string(var_1009.as_str());
}
if let Some(var_1010) = &input.timed_metadata_pid {
object.key("timedMetadataPid").string(var_1010.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_1011) = &input.video_pid {
object.key("videoPid").string(var_1011.as_str());
}
if input.scte35_preroll_pullup_milliseconds != 0.0 {
object.key("scte35PrerollPullupMilliseconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.scte35_preroll_pullup_milliseconds).into()),
);
}
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::error::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::error::SerializationError> {
if let Some(var_1012) = &input.audio_group_id {
object.key("audioGroupId").string(var_1012.as_str());
}
if let Some(var_1013) = &input.audio_only_image {
#[allow(unused_mut)]
let mut object_1014 = object.key("audioOnlyImage").start_object();
crate::json_ser::serialize_structure_crate_model_input_location(
&mut object_1014,
var_1013,
)?;
object_1014.finish();
}
if let Some(var_1015) = &input.audio_track_type {
object.key("audioTrackType").string(var_1015.as_str());
}
if let Some(var_1016) = &input.segment_type {
object.key("segmentType").string(var_1016.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::error::SerializationError> {
if let Some(var_1017) = &input.audio_rendition_sets {
object.key("audioRenditionSets").string(var_1017.as_str());
}
if let Some(var_1018) = &input.nielsen_id3_behavior {
object.key("nielsenId3Behavior").string(var_1018.as_str());
}
if let Some(var_1019) = &input.timed_metadata_behavior {
object
.key("timedMetadataBehavior")
.string(var_1019.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::error::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::error::SerializationError> {
if let Some(var_1020) = &input.audio_rendition_sets {
object.key("audioRenditionSets").string(var_1020.as_str());
}
if let Some(var_1021) = &input.m3u8_settings {
#[allow(unused_mut)]
let mut object_1022 = object.key("m3u8Settings").start_object();
crate::json_ser::serialize_structure_crate_model_m3u8_settings(&mut object_1022, var_1021)?;
object_1022.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::error::SerializationError> {
if let Some(var_1023) = &input.archive_allowed_flag {
object.key("archiveAllowedFlag").string(var_1023.as_str());
}
if let Some(var_1024) = &input.device_restrictions {
object.key("deviceRestrictions").string(var_1024.as_str());
}
if let Some(var_1025) = &input.no_regional_blackout_flag {
object
.key("noRegionalBlackoutFlag")
.string(var_1025.as_str());
}
if let Some(var_1026) = &input.web_delivery_allowed_flag {
object
.key("webDeliveryAllowedFlag")
.string(var_1026.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::error::SerializationError> {
{
object.key("networkId").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.network_id).into()),
);
}
if let Some(var_1027) = &input.network_name {
object.key("networkName").string(var_1027.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::error::SerializationError> {
if let Some(var_1028) = &input.output_sdt {
object.key("outputSdt").string(var_1028.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_1029) = &input.service_name {
object.key("serviceName").string(var_1029.as_str());
}
if let Some(var_1030) = &input.service_provider_name {
object.key("serviceProviderName").string(var_1030.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::error::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::error::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_1031) = &input.audio_pids {
object.key("audioPids").string(var_1031.as_str());
}
if let Some(var_1032) = &input.ecm_pid {
object.key("ecmPid").string(var_1032.as_str());
}
if let Some(var_1033) = &input.nielsen_id3_behavior {
object.key("nielsenId3Behavior").string(var_1033.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_1034) = &input.pcr_control {
object.key("pcrControl").string(var_1034.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_1035) = &input.pcr_pid {
object.key("pcrPid").string(var_1035.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_1036) = &input.pmt_pid {
object.key("pmtPid").string(var_1036.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_1037) = &input.scte35_behavior {
object.key("scte35Behavior").string(var_1037.as_str());
}
if let Some(var_1038) = &input.scte35_pid {
object.key("scte35Pid").string(var_1038.as_str());
}
if let Some(var_1039) = &input.timed_metadata_behavior {
object
.key("timedMetadataBehavior")
.string(var_1039.as_str());
}
if let Some(var_1040) = &input.timed_metadata_pid {
object.key("timedMetadataPid").string(var_1040.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_1041) = &input.video_pid {
object.key("videoPid").string(var_1041.as_str());
}
Ok(())
}