pub fn serialize_structure_crate_input_add_flow_media_streams_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddFlowMediaStreamsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_1) = &input.media_streams {
let mut array_2 = object.key("mediaStreams").start_array();
for item_3 in var_1 {
{
let mut object_4 = array_2.value().start_object();
crate::json_ser::serialize_structure_crate_model_add_media_stream_request(
&mut object_4,
item_3,
)?;
object_4.finish();
}
}
array_2.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_add_flow_outputs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddFlowOutputsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_5) = &input.outputs {
let mut array_6 = object.key("outputs").start_array();
for item_7 in var_5 {
{
let mut object_8 = array_6.value().start_object();
crate::json_ser::serialize_structure_crate_model_add_output_request(
&mut object_8,
item_7,
)?;
object_8.finish();
}
}
array_6.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_add_flow_sources_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddFlowSourcesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_9) = &input.sources {
let mut array_10 = object.key("sources").start_array();
for item_11 in var_9 {
{
let mut object_12 = array_10.value().start_object();
crate::json_ser::serialize_structure_crate_model_set_source_request(
&mut object_12,
item_11,
)?;
object_12.finish();
}
}
array_10.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_add_flow_vpc_interfaces_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddFlowVpcInterfacesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_13) = &input.vpc_interfaces {
let mut array_14 = object.key("vpcInterfaces").start_array();
for item_15 in var_13 {
{
let mut object_16 = array_14.value().start_object();
crate::json_ser::serialize_structure_crate_model_vpc_interface_request(
&mut object_16,
item_15,
)?;
object_16.finish();
}
}
array_14.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_flow_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFlowInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_17) = &input.availability_zone {
object.key("availabilityZone").string(var_17);
}
if let Some(var_18) = &input.entitlements {
let mut array_19 = object.key("entitlements").start_array();
for item_20 in var_18 {
{
let mut object_21 = array_19.value().start_object();
crate::json_ser::serialize_structure_crate_model_grant_entitlement_request(
&mut object_21,
item_20,
)?;
object_21.finish();
}
}
array_19.finish();
}
if let Some(var_22) = &input.media_streams {
let mut array_23 = object.key("mediaStreams").start_array();
for item_24 in var_22 {
{
let mut object_25 = array_23.value().start_object();
crate::json_ser::serialize_structure_crate_model_add_media_stream_request(
&mut object_25,
item_24,
)?;
object_25.finish();
}
}
array_23.finish();
}
if let Some(var_26) = &input.name {
object.key("name").string(var_26);
}
if let Some(var_27) = &input.outputs {
let mut array_28 = object.key("outputs").start_array();
for item_29 in var_27 {
{
let mut object_30 = array_28.value().start_object();
crate::json_ser::serialize_structure_crate_model_add_output_request(
&mut object_30,
item_29,
)?;
object_30.finish();
}
}
array_28.finish();
}
if let Some(var_31) = &input.source {
let mut object_32 = object.key("source").start_object();
crate::json_ser::serialize_structure_crate_model_set_source_request(
&mut object_32,
var_31,
)?;
object_32.finish();
}
if let Some(var_33) = &input.source_failover_config {
let mut object_34 = object.key("sourceFailoverConfig").start_object();
crate::json_ser::serialize_structure_crate_model_failover_config(&mut object_34, var_33)?;
object_34.finish();
}
if let Some(var_35) = &input.sources {
let mut array_36 = object.key("sources").start_array();
for item_37 in var_35 {
{
let mut object_38 = array_36.value().start_object();
crate::json_ser::serialize_structure_crate_model_set_source_request(
&mut object_38,
item_37,
)?;
object_38.finish();
}
}
array_36.finish();
}
if let Some(var_39) = &input.vpc_interfaces {
let mut array_40 = object.key("vpcInterfaces").start_array();
for item_41 in var_39 {
{
let mut object_42 = array_40.value().start_object();
crate::json_ser::serialize_structure_crate_model_vpc_interface_request(
&mut object_42,
item_41,
)?;
object_42.finish();
}
}
array_40.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_grant_flow_entitlements_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GrantFlowEntitlementsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_43) = &input.entitlements {
let mut array_44 = object.key("entitlements").start_array();
for item_45 in var_43 {
{
let mut object_46 = array_44.value().start_object();
crate::json_ser::serialize_structure_crate_model_grant_entitlement_request(
&mut object_46,
item_45,
)?;
object_46.finish();
}
}
array_44.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_purchase_offering_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PurchaseOfferingInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_47) = &input.reservation_name {
object.key("reservationName").string(var_47);
}
if let Some(var_48) = &input.start {
object.key("start").string(var_48);
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_49) = &input.tags {
let mut object_50 = object.key("tags").start_object();
for (key_51, value_52) in var_49 {
{
object_50.key(key_51).string(value_52);
}
}
object_50.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_flow_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFlowInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_53) = &input.source_failover_config {
let mut object_54 = object.key("sourceFailoverConfig").start_object();
crate::json_ser::serialize_structure_crate_model_update_failover_config(
&mut object_54,
var_53,
)?;
object_54.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_flow_entitlement_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFlowEntitlementInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_55) = &input.description {
object.key("description").string(var_55);
}
if let Some(var_56) = &input.encryption {
let mut object_57 = object.key("encryption").start_object();
crate::json_ser::serialize_structure_crate_model_update_encryption(&mut object_57, var_56)?;
object_57.finish();
}
if let Some(var_58) = &input.entitlement_status {
object.key("entitlementStatus").string(var_58.as_str());
}
if let Some(var_59) = &input.subscribers {
let mut array_60 = object.key("subscribers").start_array();
for item_61 in var_59 {
{
array_60.value().string(item_61);
}
}
array_60.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_flow_media_stream_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFlowMediaStreamInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_62) = &input.attributes {
let mut object_63 = object.key("attributes").start_object();
crate::json_ser::serialize_structure_crate_model_media_stream_attributes_request(
&mut object_63,
var_62,
)?;
object_63.finish();
}
if input.clock_rate != 0 {
object.key("clockRate").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.clock_rate).into()),
);
}
if let Some(var_64) = &input.description {
object.key("description").string(var_64);
}
if let Some(var_65) = &input.media_stream_type {
object.key("mediaStreamType").string(var_65.as_str());
}
if let Some(var_66) = &input.video_format {
object.key("videoFormat").string(var_66);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_flow_output_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFlowOutputInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_67) = &input.cidr_allow_list {
let mut array_68 = object.key("cidrAllowList").start_array();
for item_69 in var_67 {
{
array_68.value().string(item_69);
}
}
array_68.finish();
}
if let Some(var_70) = &input.description {
object.key("description").string(var_70);
}
if let Some(var_71) = &input.destination {
object.key("destination").string(var_71);
}
if let Some(var_72) = &input.encryption {
let mut object_73 = object.key("encryption").start_object();
crate::json_ser::serialize_structure_crate_model_update_encryption(&mut object_73, var_72)?;
object_73.finish();
}
if input.max_latency != 0 {
object.key("maxLatency").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_latency).into()),
);
}
if let Some(var_74) = &input.media_stream_output_configurations {
let mut array_75 = object.key("mediaStreamOutputConfigurations").start_array();
for item_76 in var_74 {
{
let mut object_77 = array_75.value().start_object();
crate::json_ser::serialize_structure_crate_model_media_stream_output_configuration_request(&mut object_77, item_76)?;
object_77.finish();
}
}
array_75.finish();
}
if input.min_latency != 0 {
object.key("minLatency").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.min_latency).into()),
);
}
if input.port != 0 {
object.key("port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_78) = &input.protocol {
object.key("protocol").string(var_78.as_str());
}
if let Some(var_79) = &input.remote_id {
object.key("remoteId").string(var_79);
}
if input.sender_control_port != 0 {
object.key("senderControlPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.sender_control_port).into()),
);
}
if let Some(var_80) = &input.sender_ip_address {
object.key("senderIpAddress").string(var_80);
}
if input.smoothing_latency != 0 {
object.key("smoothingLatency").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.smoothing_latency).into()),
);
}
if let Some(var_81) = &input.stream_id {
object.key("streamId").string(var_81);
}
if let Some(var_82) = &input.vpc_interface_attachment {
let mut object_83 = object.key("vpcInterfaceAttachment").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_interface_attachment(
&mut object_83,
var_82,
)?;
object_83.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_flow_source_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFlowSourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_84) = &input.decryption {
let mut object_85 = object.key("decryption").start_object();
crate::json_ser::serialize_structure_crate_model_update_encryption(&mut object_85, var_84)?;
object_85.finish();
}
if let Some(var_86) = &input.description {
object.key("description").string(var_86);
}
if let Some(var_87) = &input.entitlement_arn {
object.key("entitlementArn").string(var_87);
}
if input.ingest_port != 0 {
object.key("ingestPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.ingest_port).into()),
);
}
if input.max_bitrate != 0 {
object.key("maxBitrate").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_bitrate).into()),
);
}
if input.max_latency != 0 {
object.key("maxLatency").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_latency).into()),
);
}
if input.max_sync_buffer != 0 {
object.key("maxSyncBuffer").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_sync_buffer).into()),
);
}
if let Some(var_88) = &input.media_stream_source_configurations {
let mut array_89 = object.key("mediaStreamSourceConfigurations").start_array();
for item_90 in var_88 {
{
let mut object_91 = array_89.value().start_object();
crate::json_ser::serialize_structure_crate_model_media_stream_source_configuration_request(&mut object_91, item_90)?;
object_91.finish();
}
}
array_89.finish();
}
if input.min_latency != 0 {
object.key("minLatency").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.min_latency).into()),
);
}
if let Some(var_92) = &input.protocol {
object.key("protocol").string(var_92.as_str());
}
if input.sender_control_port != 0 {
object.key("senderControlPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.sender_control_port).into()),
);
}
if let Some(var_93) = &input.sender_ip_address {
object.key("senderIpAddress").string(var_93);
}
if let Some(var_94) = &input.stream_id {
object.key("streamId").string(var_94);
}
if let Some(var_95) = &input.vpc_interface_name {
object.key("vpcInterfaceName").string(var_95);
}
if let Some(var_96) = &input.whitelist_cidr {
object.key("whitelistCidr").string(var_96);
}
Ok(())
}
pub fn serialize_structure_crate_model_add_media_stream_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AddMediaStreamRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_97) = &input.attributes {
let mut object_98 = object.key("attributes").start_object();
crate::json_ser::serialize_structure_crate_model_media_stream_attributes_request(
&mut object_98,
var_97,
)?;
object_98.finish();
}
if input.clock_rate != 0 {
object.key("clockRate").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.clock_rate).into()),
);
}
if let Some(var_99) = &input.description {
object.key("description").string(var_99);
}
{
object.key("mediaStreamId").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.media_stream_id).into()),
);
}
if let Some(var_100) = &input.media_stream_name {
object.key("mediaStreamName").string(var_100);
}
if let Some(var_101) = &input.media_stream_type {
object.key("mediaStreamType").string(var_101.as_str());
}
if let Some(var_102) = &input.video_format {
object.key("videoFormat").string(var_102);
}
Ok(())
}
pub fn serialize_structure_crate_model_add_output_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AddOutputRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_103) = &input.cidr_allow_list {
let mut array_104 = object.key("cidrAllowList").start_array();
for item_105 in var_103 {
{
array_104.value().string(item_105);
}
}
array_104.finish();
}
if let Some(var_106) = &input.description {
object.key("description").string(var_106);
}
if let Some(var_107) = &input.destination {
object.key("destination").string(var_107);
}
if let Some(var_108) = &input.encryption {
let mut object_109 = object.key("encryption").start_object();
crate::json_ser::serialize_structure_crate_model_encryption(&mut object_109, var_108)?;
object_109.finish();
}
if input.max_latency != 0 {
object.key("maxLatency").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_latency).into()),
);
}
if let Some(var_110) = &input.media_stream_output_configurations {
let mut array_111 = object.key("mediaStreamOutputConfigurations").start_array();
for item_112 in var_110 {
{
let mut object_113 = array_111.value().start_object();
crate::json_ser::serialize_structure_crate_model_media_stream_output_configuration_request(&mut object_113, item_112)?;
object_113.finish();
}
}
array_111.finish();
}
if input.min_latency != 0 {
object.key("minLatency").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.min_latency).into()),
);
}
if let Some(var_114) = &input.name {
object.key("name").string(var_114);
}
if input.port != 0 {
object.key("port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_115) = &input.protocol {
object.key("protocol").string(var_115.as_str());
}
if let Some(var_116) = &input.remote_id {
object.key("remoteId").string(var_116);
}
if input.sender_control_port != 0 {
object.key("senderControlPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.sender_control_port).into()),
);
}
if input.smoothing_latency != 0 {
object.key("smoothingLatency").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.smoothing_latency).into()),
);
}
if let Some(var_117) = &input.stream_id {
object.key("streamId").string(var_117);
}
if let Some(var_118) = &input.vpc_interface_attachment {
let mut object_119 = object.key("vpcInterfaceAttachment").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_interface_attachment(
&mut object_119,
var_118,
)?;
object_119.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_set_source_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SetSourceRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_120) = &input.decryption {
let mut object_121 = object.key("decryption").start_object();
crate::json_ser::serialize_structure_crate_model_encryption(&mut object_121, var_120)?;
object_121.finish();
}
if let Some(var_122) = &input.description {
object.key("description").string(var_122);
}
if let Some(var_123) = &input.entitlement_arn {
object.key("entitlementArn").string(var_123);
}
if input.ingest_port != 0 {
object.key("ingestPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.ingest_port).into()),
);
}
if input.max_bitrate != 0 {
object.key("maxBitrate").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_bitrate).into()),
);
}
if input.max_latency != 0 {
object.key("maxLatency").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_latency).into()),
);
}
if input.max_sync_buffer != 0 {
object.key("maxSyncBuffer").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_sync_buffer).into()),
);
}
if let Some(var_124) = &input.media_stream_source_configurations {
let mut array_125 = object.key("mediaStreamSourceConfigurations").start_array();
for item_126 in var_124 {
{
let mut object_127 = array_125.value().start_object();
crate::json_ser::serialize_structure_crate_model_media_stream_source_configuration_request(&mut object_127, item_126)?;
object_127.finish();
}
}
array_125.finish();
}
if input.min_latency != 0 {
object.key("minLatency").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.min_latency).into()),
);
}
if let Some(var_128) = &input.name {
object.key("name").string(var_128);
}
if let Some(var_129) = &input.protocol {
object.key("protocol").string(var_129.as_str());
}
if input.sender_control_port != 0 {
object.key("senderControlPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.sender_control_port).into()),
);
}
if let Some(var_130) = &input.sender_ip_address {
object.key("senderIpAddress").string(var_130);
}
if let Some(var_131) = &input.stream_id {
object.key("streamId").string(var_131);
}
if let Some(var_132) = &input.vpc_interface_name {
object.key("vpcInterfaceName").string(var_132);
}
if let Some(var_133) = &input.whitelist_cidr {
object.key("whitelistCidr").string(var_133);
}
Ok(())
}
pub fn serialize_structure_crate_model_vpc_interface_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VpcInterfaceRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_134) = &input.name {
object.key("name").string(var_134);
}
if let Some(var_135) = &input.network_interface_type {
object.key("networkInterfaceType").string(var_135.as_str());
}
if let Some(var_136) = &input.role_arn {
object.key("roleArn").string(var_136);
}
if let Some(var_137) = &input.security_group_ids {
let mut array_138 = object.key("securityGroupIds").start_array();
for item_139 in var_137 {
{
array_138.value().string(item_139);
}
}
array_138.finish();
}
if let Some(var_140) = &input.subnet_id {
object.key("subnetId").string(var_140);
}
Ok(())
}
pub fn serialize_structure_crate_model_grant_entitlement_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GrantEntitlementRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if input.data_transfer_subscriber_fee_percent != 0 {
object.key("dataTransferSubscriberFeePercent").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.data_transfer_subscriber_fee_percent).into()),
);
}
if let Some(var_141) = &input.description {
object.key("description").string(var_141);
}
if let Some(var_142) = &input.encryption {
let mut object_143 = object.key("encryption").start_object();
crate::json_ser::serialize_structure_crate_model_encryption(&mut object_143, var_142)?;
object_143.finish();
}
if let Some(var_144) = &input.entitlement_status {
object.key("entitlementStatus").string(var_144.as_str());
}
if let Some(var_145) = &input.name {
object.key("name").string(var_145);
}
if let Some(var_146) = &input.subscribers {
let mut array_147 = object.key("subscribers").start_array();
for item_148 in var_146 {
{
array_147.value().string(item_148);
}
}
array_147.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_failover_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FailoverConfig,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_149) = &input.failover_mode {
object.key("failoverMode").string(var_149.as_str());
}
if input.recovery_window != 0 {
object.key("recoveryWindow").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.recovery_window).into()),
);
}
if let Some(var_150) = &input.source_priority {
let mut object_151 = object.key("sourcePriority").start_object();
crate::json_ser::serialize_structure_crate_model_source_priority(&mut object_151, var_150)?;
object_151.finish();
}
if let Some(var_152) = &input.state {
object.key("state").string(var_152.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_failover_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateFailoverConfig,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_153) = &input.failover_mode {
object.key("failoverMode").string(var_153.as_str());
}
if input.recovery_window != 0 {
object.key("recoveryWindow").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.recovery_window).into()),
);
}
if let Some(var_154) = &input.source_priority {
let mut object_155 = object.key("sourcePriority").start_object();
crate::json_ser::serialize_structure_crate_model_source_priority(&mut object_155, var_154)?;
object_155.finish();
}
if let Some(var_156) = &input.state {
object.key("state").string(var_156.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_encryption(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateEncryption,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_157) = &input.algorithm {
object.key("algorithm").string(var_157.as_str());
}
if let Some(var_158) = &input.constant_initialization_vector {
object.key("constantInitializationVector").string(var_158);
}
if let Some(var_159) = &input.device_id {
object.key("deviceId").string(var_159);
}
if let Some(var_160) = &input.key_type {
object.key("keyType").string(var_160.as_str());
}
if let Some(var_161) = &input.region {
object.key("region").string(var_161);
}
if let Some(var_162) = &input.resource_id {
object.key("resourceId").string(var_162);
}
if let Some(var_163) = &input.role_arn {
object.key("roleArn").string(var_163);
}
if let Some(var_164) = &input.secret_arn {
object.key("secretArn").string(var_164);
}
if let Some(var_165) = &input.url {
object.key("url").string(var_165);
}
Ok(())
}
pub fn serialize_structure_crate_model_media_stream_attributes_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MediaStreamAttributesRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_166) = &input.fmtp {
let mut object_167 = object.key("fmtp").start_object();
crate::json_ser::serialize_structure_crate_model_fmtp_request(&mut object_167, var_166)?;
object_167.finish();
}
if let Some(var_168) = &input.lang {
object.key("lang").string(var_168);
}
Ok(())
}
pub fn serialize_structure_crate_model_media_stream_output_configuration_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MediaStreamOutputConfigurationRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_169) = &input.destination_configurations {
let mut array_170 = object.key("destinationConfigurations").start_array();
for item_171 in var_169 {
{
let mut object_172 = array_170.value().start_object();
crate::json_ser::serialize_structure_crate_model_destination_configuration_request(
&mut object_172,
item_171,
)?;
object_172.finish();
}
}
array_170.finish();
}
if let Some(var_173) = &input.encoding_name {
object.key("encodingName").string(var_173.as_str());
}
if let Some(var_174) = &input.encoding_parameters {
let mut object_175 = object.key("encodingParameters").start_object();
crate::json_ser::serialize_structure_crate_model_encoding_parameters_request(
&mut object_175,
var_174,
)?;
object_175.finish();
}
if let Some(var_176) = &input.media_stream_name {
object.key("mediaStreamName").string(var_176);
}
Ok(())
}
pub fn serialize_structure_crate_model_vpc_interface_attachment(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VpcInterfaceAttachment,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_177) = &input.vpc_interface_name {
object.key("vpcInterfaceName").string(var_177);
}
Ok(())
}
pub fn serialize_structure_crate_model_media_stream_source_configuration_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MediaStreamSourceConfigurationRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_178) = &input.encoding_name {
object.key("encodingName").string(var_178.as_str());
}
if let Some(var_179) = &input.input_configurations {
let mut array_180 = object.key("inputConfigurations").start_array();
for item_181 in var_179 {
{
let mut object_182 = array_180.value().start_object();
crate::json_ser::serialize_structure_crate_model_input_configuration_request(
&mut object_182,
item_181,
)?;
object_182.finish();
}
}
array_180.finish();
}
if let Some(var_183) = &input.media_stream_name {
object.key("mediaStreamName").string(var_183);
}
Ok(())
}
pub fn serialize_structure_crate_model_encryption(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Encryption,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_184) = &input.algorithm {
object.key("algorithm").string(var_184.as_str());
}
if let Some(var_185) = &input.constant_initialization_vector {
object.key("constantInitializationVector").string(var_185);
}
if let Some(var_186) = &input.device_id {
object.key("deviceId").string(var_186);
}
if let Some(var_187) = &input.key_type {
object.key("keyType").string(var_187.as_str());
}
if let Some(var_188) = &input.region {
object.key("region").string(var_188);
}
if let Some(var_189) = &input.resource_id {
object.key("resourceId").string(var_189);
}
if let Some(var_190) = &input.role_arn {
object.key("roleArn").string(var_190);
}
if let Some(var_191) = &input.secret_arn {
object.key("secretArn").string(var_191);
}
if let Some(var_192) = &input.url {
object.key("url").string(var_192);
}
Ok(())
}
pub fn serialize_structure_crate_model_source_priority(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SourcePriority,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_193) = &input.primary_source {
object.key("primarySource").string(var_193);
}
Ok(())
}
pub fn serialize_structure_crate_model_fmtp_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FmtpRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_194) = &input.channel_order {
object.key("channelOrder").string(var_194);
}
if let Some(var_195) = &input.colorimetry {
object.key("colorimetry").string(var_195.as_str());
}
if let Some(var_196) = &input.exact_framerate {
object.key("exactFramerate").string(var_196);
}
if let Some(var_197) = &input.par {
object.key("par").string(var_197);
}
if let Some(var_198) = &input.range {
object.key("range").string(var_198.as_str());
}
if let Some(var_199) = &input.scan_mode {
object.key("scanMode").string(var_199.as_str());
}
if let Some(var_200) = &input.tcs {
object.key("tcs").string(var_200.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_destination_configuration_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DestinationConfigurationRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_201) = &input.destination_ip {
object.key("destinationIp").string(var_201);
}
{
object.key("destinationPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.destination_port).into()),
);
}
if let Some(var_202) = &input.interface {
let mut object_203 = object.key("interface").start_object();
crate::json_ser::serialize_structure_crate_model_interface_request(
&mut object_203,
var_202,
)?;
object_203.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_encoding_parameters_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EncodingParametersRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
{
object.key("compressionFactor").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.compression_factor).into()),
);
}
if let Some(var_204) = &input.encoder_profile {
object.key("encoderProfile").string(var_204.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_input_configuration_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InputConfigurationRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
{
object.key("inputPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.input_port).into()),
);
}
if let Some(var_205) = &input.interface {
let mut object_206 = object.key("interface").start_object();
crate::json_ser::serialize_structure_crate_model_interface_request(
&mut object_206,
var_205,
)?;
object_206.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_interface_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InterfaceRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_207) = &input.name {
object.key("name").string(var_207);
}
Ok(())
}