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::error::SerializationError> {
if let Some(var_1) = &input.media_streams {
let mut array_2 = object.key("mediaStreams").start_array();
for item_3 in var_1 {
{
#[allow(unused_mut)]
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::error::SerializationError> {
if let Some(var_5) = &input.outputs {
let mut array_6 = object.key("outputs").start_array();
for item_7 in var_5 {
{
#[allow(unused_mut)]
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::error::SerializationError> {
if let Some(var_9) = &input.sources {
let mut array_10 = object.key("sources").start_array();
for item_11 in var_9 {
{
#[allow(unused_mut)]
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::error::SerializationError> {
if let Some(var_13) = &input.vpc_interfaces {
let mut array_14 = object.key("vpcInterfaces").start_array();
for item_15 in var_13 {
{
#[allow(unused_mut)]
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::error::SerializationError> {
if let Some(var_17) = &input.availability_zone {
object.key("availabilityZone").string(var_17.as_str());
}
if let Some(var_18) = &input.entitlements {
let mut array_19 = object.key("entitlements").start_array();
for item_20 in var_18 {
{
#[allow(unused_mut)]
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.maintenance {
#[allow(unused_mut)]
let mut object_23 = object.key("maintenance").start_object();
crate::json_ser::serialize_structure_crate_model_add_maintenance(&mut object_23, var_22)?;
object_23.finish();
}
if let Some(var_24) = &input.media_streams {
let mut array_25 = object.key("mediaStreams").start_array();
for item_26 in var_24 {
{
#[allow(unused_mut)]
let mut object_27 = array_25.value().start_object();
crate::json_ser::serialize_structure_crate_model_add_media_stream_request(
&mut object_27,
item_26,
)?;
object_27.finish();
}
}
array_25.finish();
}
if let Some(var_28) = &input.name {
object.key("name").string(var_28.as_str());
}
if let Some(var_29) = &input.outputs {
let mut array_30 = object.key("outputs").start_array();
for item_31 in var_29 {
{
#[allow(unused_mut)]
let mut object_32 = array_30.value().start_object();
crate::json_ser::serialize_structure_crate_model_add_output_request(
&mut object_32,
item_31,
)?;
object_32.finish();
}
}
array_30.finish();
}
if let Some(var_33) = &input.source {
#[allow(unused_mut)]
let mut object_34 = object.key("source").start_object();
crate::json_ser::serialize_structure_crate_model_set_source_request(
&mut object_34,
var_33,
)?;
object_34.finish();
}
if let Some(var_35) = &input.source_failover_config {
#[allow(unused_mut)]
let mut object_36 = object.key("sourceFailoverConfig").start_object();
crate::json_ser::serialize_structure_crate_model_failover_config(&mut object_36, var_35)?;
object_36.finish();
}
if let Some(var_37) = &input.sources {
let mut array_38 = object.key("sources").start_array();
for item_39 in var_37 {
{
#[allow(unused_mut)]
let mut object_40 = array_38.value().start_object();
crate::json_ser::serialize_structure_crate_model_set_source_request(
&mut object_40,
item_39,
)?;
object_40.finish();
}
}
array_38.finish();
}
if let Some(var_41) = &input.vpc_interfaces {
let mut array_42 = object.key("vpcInterfaces").start_array();
for item_43 in var_41 {
{
#[allow(unused_mut)]
let mut object_44 = array_42.value().start_object();
crate::json_ser::serialize_structure_crate_model_vpc_interface_request(
&mut object_44,
item_43,
)?;
object_44.finish();
}
}
array_42.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::error::SerializationError> {
if let Some(var_45) = &input.entitlements {
let mut array_46 = object.key("entitlements").start_array();
for item_47 in var_45 {
{
#[allow(unused_mut)]
let mut object_48 = array_46.value().start_object();
crate::json_ser::serialize_structure_crate_model_grant_entitlement_request(
&mut object_48,
item_47,
)?;
object_48.finish();
}
}
array_46.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> {
if let Some(var_49) = &input.reservation_name {
object.key("reservationName").string(var_49.as_str());
}
if let Some(var_50) = &input.start {
object.key("start").string(var_50.as_str());
}
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::error::SerializationError> {
if let Some(var_51) = &input.tags {
#[allow(unused_mut)]
let mut object_52 = object.key("tags").start_object();
for (key_53, value_54) in var_51 {
{
object_52.key(key_53.as_str()).string(value_54.as_str());
}
}
object_52.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::error::SerializationError> {
if let Some(var_55) = &input.maintenance {
#[allow(unused_mut)]
let mut object_56 = object.key("maintenance").start_object();
crate::json_ser::serialize_structure_crate_model_update_maintenance(
&mut object_56,
var_55,
)?;
object_56.finish();
}
if let Some(var_57) = &input.source_failover_config {
#[allow(unused_mut)]
let mut object_58 = object.key("sourceFailoverConfig").start_object();
crate::json_ser::serialize_structure_crate_model_update_failover_config(
&mut object_58,
var_57,
)?;
object_58.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::error::SerializationError> {
if let Some(var_59) = &input.description {
object.key("description").string(var_59.as_str());
}
if let Some(var_60) = &input.encryption {
#[allow(unused_mut)]
let mut object_61 = object.key("encryption").start_object();
crate::json_ser::serialize_structure_crate_model_update_encryption(&mut object_61, var_60)?;
object_61.finish();
}
if let Some(var_62) = &input.entitlement_status {
object.key("entitlementStatus").string(var_62.as_str());
}
if let Some(var_63) = &input.subscribers {
let mut array_64 = object.key("subscribers").start_array();
for item_65 in var_63 {
{
array_64.value().string(item_65.as_str());
}
}
array_64.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::error::SerializationError> {
if let Some(var_66) = &input.attributes {
#[allow(unused_mut)]
let mut object_67 = object.key("attributes").start_object();
crate::json_ser::serialize_structure_crate_model_media_stream_attributes_request(
&mut object_67,
var_66,
)?;
object_67.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_68) = &input.description {
object.key("description").string(var_68.as_str());
}
if let Some(var_69) = &input.media_stream_type {
object.key("mediaStreamType").string(var_69.as_str());
}
if let Some(var_70) = &input.video_format {
object.key("videoFormat").string(var_70.as_str());
}
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::error::SerializationError> {
if let Some(var_71) = &input.cidr_allow_list {
let mut array_72 = object.key("cidrAllowList").start_array();
for item_73 in var_71 {
{
array_72.value().string(item_73.as_str());
}
}
array_72.finish();
}
if let Some(var_74) = &input.description {
object.key("description").string(var_74.as_str());
}
if let Some(var_75) = &input.destination {
object.key("destination").string(var_75.as_str());
}
if let Some(var_76) = &input.encryption {
#[allow(unused_mut)]
let mut object_77 = object.key("encryption").start_object();
crate::json_ser::serialize_structure_crate_model_update_encryption(&mut object_77, var_76)?;
object_77.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_78) = &input.media_stream_output_configurations {
let mut array_79 = object.key("mediaStreamOutputConfigurations").start_array();
for item_80 in var_78 {
{
#[allow(unused_mut)]
let mut object_81 = array_79.value().start_object();
crate::json_ser::serialize_structure_crate_model_media_stream_output_configuration_request(&mut object_81, item_80)?;
object_81.finish();
}
}
array_79.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_82) = &input.protocol {
object.key("protocol").string(var_82.as_str());
}
if let Some(var_83) = &input.remote_id {
object.key("remoteId").string(var_83.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_84) = &input.sender_ip_address {
object.key("senderIpAddress").string(var_84.as_str());
}
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_85) = &input.stream_id {
object.key("streamId").string(var_85.as_str());
}
if let Some(var_86) = &input.vpc_interface_attachment {
#[allow(unused_mut)]
let mut object_87 = object.key("vpcInterfaceAttachment").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_interface_attachment(
&mut object_87,
var_86,
)?;
object_87.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::error::SerializationError> {
if let Some(var_88) = &input.decryption {
#[allow(unused_mut)]
let mut object_89 = object.key("decryption").start_object();
crate::json_ser::serialize_structure_crate_model_update_encryption(&mut object_89, var_88)?;
object_89.finish();
}
if let Some(var_90) = &input.description {
object.key("description").string(var_90.as_str());
}
if let Some(var_91) = &input.entitlement_arn {
object.key("entitlementArn").string(var_91.as_str());
}
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_92) = &input.media_stream_source_configurations {
let mut array_93 = object.key("mediaStreamSourceConfigurations").start_array();
for item_94 in var_92 {
{
#[allow(unused_mut)]
let mut object_95 = array_93.value().start_object();
crate::json_ser::serialize_structure_crate_model_media_stream_source_configuration_request(&mut object_95, item_94)?;
object_95.finish();
}
}
array_93.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_96) = &input.protocol {
object.key("protocol").string(var_96.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_97) = &input.sender_ip_address {
object.key("senderIpAddress").string(var_97.as_str());
}
if let Some(var_98) = &input.source_listener_address {
object.key("sourceListenerAddress").string(var_98.as_str());
}
if input.source_listener_port != 0 {
object.key("sourceListenerPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.source_listener_port).into()),
);
}
if let Some(var_99) = &input.stream_id {
object.key("streamId").string(var_99.as_str());
}
if let Some(var_100) = &input.vpc_interface_name {
object.key("vpcInterfaceName").string(var_100.as_str());
}
if let Some(var_101) = &input.whitelist_cidr {
object.key("whitelistCidr").string(var_101.as_str());
}
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::error::SerializationError> {
if let Some(var_102) = &input.attributes {
#[allow(unused_mut)]
let mut object_103 = object.key("attributes").start_object();
crate::json_ser::serialize_structure_crate_model_media_stream_attributes_request(
&mut object_103,
var_102,
)?;
object_103.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_104) = &input.description {
object.key("description").string(var_104.as_str());
}
{
object.key("mediaStreamId").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.media_stream_id).into()),
);
}
if let Some(var_105) = &input.media_stream_name {
object.key("mediaStreamName").string(var_105.as_str());
}
if let Some(var_106) = &input.media_stream_type {
object.key("mediaStreamType").string(var_106.as_str());
}
if let Some(var_107) = &input.video_format {
object.key("videoFormat").string(var_107.as_str());
}
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::error::SerializationError> {
if let Some(var_108) = &input.cidr_allow_list {
let mut array_109 = object.key("cidrAllowList").start_array();
for item_110 in var_108 {
{
array_109.value().string(item_110.as_str());
}
}
array_109.finish();
}
if let Some(var_111) = &input.description {
object.key("description").string(var_111.as_str());
}
if let Some(var_112) = &input.destination {
object.key("destination").string(var_112.as_str());
}
if let Some(var_113) = &input.encryption {
#[allow(unused_mut)]
let mut object_114 = object.key("encryption").start_object();
crate::json_ser::serialize_structure_crate_model_encryption(&mut object_114, var_113)?;
object_114.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_115) = &input.media_stream_output_configurations {
let mut array_116 = object.key("mediaStreamOutputConfigurations").start_array();
for item_117 in var_115 {
{
#[allow(unused_mut)]
let mut object_118 = array_116.value().start_object();
crate::json_ser::serialize_structure_crate_model_media_stream_output_configuration_request(&mut object_118, item_117)?;
object_118.finish();
}
}
array_116.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_119) = &input.name {
object.key("name").string(var_119.as_str());
}
if input.port != 0 {
object.key("port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.port).into()),
);
}
if let Some(var_120) = &input.protocol {
object.key("protocol").string(var_120.as_str());
}
if let Some(var_121) = &input.remote_id {
object.key("remoteId").string(var_121.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 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_122) = &input.stream_id {
object.key("streamId").string(var_122.as_str());
}
if let Some(var_123) = &input.vpc_interface_attachment {
#[allow(unused_mut)]
let mut object_124 = object.key("vpcInterfaceAttachment").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_interface_attachment(
&mut object_124,
var_123,
)?;
object_124.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::error::SerializationError> {
if let Some(var_125) = &input.decryption {
#[allow(unused_mut)]
let mut object_126 = object.key("decryption").start_object();
crate::json_ser::serialize_structure_crate_model_encryption(&mut object_126, var_125)?;
object_126.finish();
}
if let Some(var_127) = &input.description {
object.key("description").string(var_127.as_str());
}
if let Some(var_128) = &input.entitlement_arn {
object.key("entitlementArn").string(var_128.as_str());
}
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_129) = &input.media_stream_source_configurations {
let mut array_130 = object.key("mediaStreamSourceConfigurations").start_array();
for item_131 in var_129 {
{
#[allow(unused_mut)]
let mut object_132 = array_130.value().start_object();
crate::json_ser::serialize_structure_crate_model_media_stream_source_configuration_request(&mut object_132, item_131)?;
object_132.finish();
}
}
array_130.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_133) = &input.name {
object.key("name").string(var_133.as_str());
}
if let Some(var_134) = &input.protocol {
object.key("protocol").string(var_134.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_135) = &input.sender_ip_address {
object.key("senderIpAddress").string(var_135.as_str());
}
if let Some(var_136) = &input.source_listener_address {
object.key("sourceListenerAddress").string(var_136.as_str());
}
if input.source_listener_port != 0 {
object.key("sourceListenerPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.source_listener_port).into()),
);
}
if let Some(var_137) = &input.stream_id {
object.key("streamId").string(var_137.as_str());
}
if let Some(var_138) = &input.vpc_interface_name {
object.key("vpcInterfaceName").string(var_138.as_str());
}
if let Some(var_139) = &input.whitelist_cidr {
object.key("whitelistCidr").string(var_139.as_str());
}
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::error::SerializationError> {
if let Some(var_140) = &input.name {
object.key("name").string(var_140.as_str());
}
if let Some(var_141) = &input.network_interface_type {
object.key("networkInterfaceType").string(var_141.as_str());
}
if let Some(var_142) = &input.role_arn {
object.key("roleArn").string(var_142.as_str());
}
if let Some(var_143) = &input.security_group_ids {
let mut array_144 = object.key("securityGroupIds").start_array();
for item_145 in var_143 {
{
array_144.value().string(item_145.as_str());
}
}
array_144.finish();
}
if let Some(var_146) = &input.subnet_id {
object.key("subnetId").string(var_146.as_str());
}
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::error::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_147) = &input.description {
object.key("description").string(var_147.as_str());
}
if let Some(var_148) = &input.encryption {
#[allow(unused_mut)]
let mut object_149 = object.key("encryption").start_object();
crate::json_ser::serialize_structure_crate_model_encryption(&mut object_149, var_148)?;
object_149.finish();
}
if let Some(var_150) = &input.entitlement_status {
object.key("entitlementStatus").string(var_150.as_str());
}
if let Some(var_151) = &input.name {
object.key("name").string(var_151.as_str());
}
if let Some(var_152) = &input.subscribers {
let mut array_153 = object.key("subscribers").start_array();
for item_154 in var_152 {
{
array_153.value().string(item_154.as_str());
}
}
array_153.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_add_maintenance(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AddMaintenance,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_155) = &input.maintenance_day {
object.key("maintenanceDay").string(var_155.as_str());
}
if let Some(var_156) = &input.maintenance_start_hour {
object.key("maintenanceStartHour").string(var_156.as_str());
}
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::error::SerializationError> {
if let Some(var_157) = &input.failover_mode {
object.key("failoverMode").string(var_157.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_158) = &input.source_priority {
#[allow(unused_mut)]
let mut object_159 = object.key("sourcePriority").start_object();
crate::json_ser::serialize_structure_crate_model_source_priority(&mut object_159, var_158)?;
object_159.finish();
}
if let Some(var_160) = &input.state {
object.key("state").string(var_160.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_maintenance(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateMaintenance,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_161) = &input.maintenance_day {
object.key("maintenanceDay").string(var_161.as_str());
}
if let Some(var_162) = &input.maintenance_scheduled_date {
object
.key("maintenanceScheduledDate")
.string(var_162.as_str());
}
if let Some(var_163) = &input.maintenance_start_hour {
object.key("maintenanceStartHour").string(var_163.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::error::SerializationError> {
if let Some(var_164) = &input.failover_mode {
object.key("failoverMode").string(var_164.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_165) = &input.source_priority {
#[allow(unused_mut)]
let mut object_166 = object.key("sourcePriority").start_object();
crate::json_ser::serialize_structure_crate_model_source_priority(&mut object_166, var_165)?;
object_166.finish();
}
if let Some(var_167) = &input.state {
object.key("state").string(var_167.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::error::SerializationError> {
if let Some(var_168) = &input.algorithm {
object.key("algorithm").string(var_168.as_str());
}
if let Some(var_169) = &input.constant_initialization_vector {
object
.key("constantInitializationVector")
.string(var_169.as_str());
}
if let Some(var_170) = &input.device_id {
object.key("deviceId").string(var_170.as_str());
}
if let Some(var_171) = &input.key_type {
object.key("keyType").string(var_171.as_str());
}
if let Some(var_172) = &input.region {
object.key("region").string(var_172.as_str());
}
if let Some(var_173) = &input.resource_id {
object.key("resourceId").string(var_173.as_str());
}
if let Some(var_174) = &input.role_arn {
object.key("roleArn").string(var_174.as_str());
}
if let Some(var_175) = &input.secret_arn {
object.key("secretArn").string(var_175.as_str());
}
if let Some(var_176) = &input.url {
object.key("url").string(var_176.as_str());
}
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::error::SerializationError> {
if let Some(var_177) = &input.fmtp {
#[allow(unused_mut)]
let mut object_178 = object.key("fmtp").start_object();
crate::json_ser::serialize_structure_crate_model_fmtp_request(&mut object_178, var_177)?;
object_178.finish();
}
if let Some(var_179) = &input.lang {
object.key("lang").string(var_179.as_str());
}
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::error::SerializationError> {
if let Some(var_180) = &input.destination_configurations {
let mut array_181 = object.key("destinationConfigurations").start_array();
for item_182 in var_180 {
{
#[allow(unused_mut)]
let mut object_183 = array_181.value().start_object();
crate::json_ser::serialize_structure_crate_model_destination_configuration_request(
&mut object_183,
item_182,
)?;
object_183.finish();
}
}
array_181.finish();
}
if let Some(var_184) = &input.encoding_name {
object.key("encodingName").string(var_184.as_str());
}
if let Some(var_185) = &input.encoding_parameters {
#[allow(unused_mut)]
let mut object_186 = object.key("encodingParameters").start_object();
crate::json_ser::serialize_structure_crate_model_encoding_parameters_request(
&mut object_186,
var_185,
)?;
object_186.finish();
}
if let Some(var_187) = &input.media_stream_name {
object.key("mediaStreamName").string(var_187.as_str());
}
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::error::SerializationError> {
if let Some(var_188) = &input.vpc_interface_name {
object.key("vpcInterfaceName").string(var_188.as_str());
}
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::error::SerializationError> {
if let Some(var_189) = &input.encoding_name {
object.key("encodingName").string(var_189.as_str());
}
if let Some(var_190) = &input.input_configurations {
let mut array_191 = object.key("inputConfigurations").start_array();
for item_192 in var_190 {
{
#[allow(unused_mut)]
let mut object_193 = array_191.value().start_object();
crate::json_ser::serialize_structure_crate_model_input_configuration_request(
&mut object_193,
item_192,
)?;
object_193.finish();
}
}
array_191.finish();
}
if let Some(var_194) = &input.media_stream_name {
object.key("mediaStreamName").string(var_194.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_encryption(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Encryption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_195) = &input.algorithm {
object.key("algorithm").string(var_195.as_str());
}
if let Some(var_196) = &input.constant_initialization_vector {
object
.key("constantInitializationVector")
.string(var_196.as_str());
}
if let Some(var_197) = &input.device_id {
object.key("deviceId").string(var_197.as_str());
}
if let Some(var_198) = &input.key_type {
object.key("keyType").string(var_198.as_str());
}
if let Some(var_199) = &input.region {
object.key("region").string(var_199.as_str());
}
if let Some(var_200) = &input.resource_id {
object.key("resourceId").string(var_200.as_str());
}
if let Some(var_201) = &input.role_arn {
object.key("roleArn").string(var_201.as_str());
}
if let Some(var_202) = &input.secret_arn {
object.key("secretArn").string(var_202.as_str());
}
if let Some(var_203) = &input.url {
object.key("url").string(var_203.as_str());
}
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::error::SerializationError> {
if let Some(var_204) = &input.primary_source {
object.key("primarySource").string(var_204.as_str());
}
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::error::SerializationError> {
if let Some(var_205) = &input.channel_order {
object.key("channelOrder").string(var_205.as_str());
}
if let Some(var_206) = &input.colorimetry {
object.key("colorimetry").string(var_206.as_str());
}
if let Some(var_207) = &input.exact_framerate {
object.key("exactFramerate").string(var_207.as_str());
}
if let Some(var_208) = &input.par {
object.key("par").string(var_208.as_str());
}
if let Some(var_209) = &input.range {
object.key("range").string(var_209.as_str());
}
if let Some(var_210) = &input.scan_mode {
object.key("scanMode").string(var_210.as_str());
}
if let Some(var_211) = &input.tcs {
object.key("tcs").string(var_211.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::error::SerializationError> {
if let Some(var_212) = &input.destination_ip {
object.key("destinationIp").string(var_212.as_str());
}
{
object.key("destinationPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.destination_port).into()),
);
}
if let Some(var_213) = &input.interface {
#[allow(unused_mut)]
let mut object_214 = object.key("interface").start_object();
crate::json_ser::serialize_structure_crate_model_interface_request(
&mut object_214,
var_213,
)?;
object_214.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::error::SerializationError> {
{
object.key("compressionFactor").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.compression_factor).into()),
);
}
if let Some(var_215) = &input.encoder_profile {
object.key("encoderProfile").string(var_215.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::error::SerializationError> {
{
object.key("inputPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.input_port).into()),
);
}
if let Some(var_216) = &input.interface {
#[allow(unused_mut)]
let mut object_217 = object.key("interface").start_object();
crate::json_ser::serialize_structure_crate_model_interface_request(
&mut object_217,
var_216,
)?;
object_217.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::error::SerializationError> {
if let Some(var_218) = &input.name {
object.key("name").string(var_218.as_str());
}
Ok(())
}