pub fn serialize_structure_crate_input_create_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.config_data {
#[allow(unused_mut)]
let mut object_2 = object.key("configData").start_object();
crate::json_ser::serialize_union_crate_model_config_type_data(&mut object_2, var_1)?;
object_2.finish();
}
if let Some(var_3) = &input.name {
object.key("name").string(var_3.as_str());
}
if let Some(var_4) = &input.tags {
#[allow(unused_mut)]
let mut object_5 = object.key("tags").start_object();
for (key_6, value_7) in var_4 {
{
object_5.key(key_6.as_str()).string(value_7.as_str());
}
}
object_5.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_dataflow_endpoint_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDataflowEndpointGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_8) = &input.contact_post_pass_duration_seconds {
object.key("contactPostPassDurationSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_8).into()),
);
}
if let Some(var_9) = &input.contact_pre_pass_duration_seconds {
object.key("contactPrePassDurationSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_9).into()),
);
}
if let Some(var_10) = &input.endpoint_details {
let mut array_11 = object.key("endpointDetails").start_array();
for item_12 in var_10 {
{
#[allow(unused_mut)]
let mut object_13 = array_11.value().start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_details(
&mut object_13,
item_12,
)?;
object_13.finish();
}
}
array_11.finish();
}
if let Some(var_14) = &input.tags {
#[allow(unused_mut)]
let mut object_15 = object.key("tags").start_object();
for (key_16, value_17) in var_14 {
{
object_15.key(key_16.as_str()).string(value_17.as_str());
}
}
object_15.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_ephemeris_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateEphemerisInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_18) = &input.enabled {
object.key("enabled").boolean(*var_18);
}
if let Some(var_19) = &input.ephemeris {
#[allow(unused_mut)]
let mut object_20 = object.key("ephemeris").start_object();
crate::json_ser::serialize_union_crate_model_ephemeris_data(&mut object_20, var_19)?;
object_20.finish();
}
if let Some(var_21) = &input.expiration_time {
object
.key("expirationTime")
.date_time(var_21, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_22) = &input.kms_key_arn {
object.key("kmsKeyArn").string(var_22.as_str());
}
if let Some(var_23) = &input.name {
object.key("name").string(var_23.as_str());
}
if let Some(var_24) = &input.priority {
object.key("priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_24).into()),
);
}
if let Some(var_25) = &input.satellite_id {
object.key("satelliteId").string(var_25.as_str());
}
if let Some(var_26) = &input.tags {
#[allow(unused_mut)]
let mut object_27 = object.key("tags").start_object();
for (key_28, value_29) in var_26 {
{
object_27.key(key_28.as_str()).string(value_29.as_str());
}
}
object_27.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_mission_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateMissionProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_30) = &input.contact_post_pass_duration_seconds {
object.key("contactPostPassDurationSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_30).into()),
);
}
if let Some(var_31) = &input.contact_pre_pass_duration_seconds {
object.key("contactPrePassDurationSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_31).into()),
);
}
if let Some(var_32) = &input.dataflow_edges {
let mut array_33 = object.key("dataflowEdges").start_array();
for item_34 in var_32 {
{
let mut array_35 = array_33.value().start_array();
for item_36 in item_34 {
{
array_35.value().string(item_36.as_str());
}
}
array_35.finish();
}
}
array_33.finish();
}
if let Some(var_37) = &input.minimum_viable_contact_duration_seconds {
object.key("minimumViableContactDurationSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_37).into()),
);
}
if let Some(var_38) = &input.name {
object.key("name").string(var_38.as_str());
}
if let Some(var_39) = &input.tags {
#[allow(unused_mut)]
let mut object_40 = object.key("tags").start_object();
for (key_41, value_42) in var_39 {
{
object_40.key(key_41.as_str()).string(value_42.as_str());
}
}
object_40.finish();
}
if let Some(var_43) = &input.tracking_config_arn {
object.key("trackingConfigArn").string(var_43.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_minute_usage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetMinuteUsageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_44) = &input.month {
object.key("month").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_44).into()),
);
}
if let Some(var_45) = &input.year {
object.key("year").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_45).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_contacts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListContactsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.end_time {
object
.key("endTime")
.date_time(var_46, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_47) = &input.ground_station {
object.key("groundStation").string(var_47.as_str());
}
if let Some(var_48) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_48).into()),
);
}
if let Some(var_49) = &input.mission_profile_arn {
object.key("missionProfileArn").string(var_49.as_str());
}
if let Some(var_50) = &input.next_token {
object.key("nextToken").string(var_50.as_str());
}
if let Some(var_51) = &input.satellite_arn {
object.key("satelliteArn").string(var_51.as_str());
}
if let Some(var_52) = &input.start_time {
object
.key("startTime")
.date_time(var_52, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_53) = &input.status_list {
let mut array_54 = object.key("statusList").start_array();
for item_55 in var_53 {
{
array_54.value().string(item_55.as_str());
}
}
array_54.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_ephemerides_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListEphemeridesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.end_time {
object
.key("endTime")
.date_time(var_56, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_57) = &input.satellite_id {
object.key("satelliteId").string(var_57.as_str());
}
if let Some(var_58) = &input.start_time {
object
.key("startTime")
.date_time(var_58, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_59) = &input.status_list {
let mut array_60 = object.key("statusList").start_array();
for item_61 in var_59 {
{
array_60.value().string(item_61.as_str());
}
}
array_60.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_reserve_contact_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ReserveContactInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_62) = &input.end_time {
object
.key("endTime")
.date_time(var_62, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_63) = &input.ground_station {
object.key("groundStation").string(var_63.as_str());
}
if let Some(var_64) = &input.mission_profile_arn {
object.key("missionProfileArn").string(var_64.as_str());
}
if let Some(var_65) = &input.satellite_arn {
object.key("satelliteArn").string(var_65.as_str());
}
if let Some(var_66) = &input.start_time {
object
.key("startTime")
.date_time(var_66, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_67) = &input.tags {
#[allow(unused_mut)]
let mut object_68 = object.key("tags").start_object();
for (key_69, value_70) in var_67 {
{
object_68.key(key_69.as_str()).string(value_70.as_str());
}
}
object_68.finish();
}
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_71) = &input.tags {
#[allow(unused_mut)]
let mut object_72 = object.key("tags").start_object();
for (key_73, value_74) in var_71 {
{
object_72.key(key_73.as_str()).string(value_74.as_str());
}
}
object_72.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_75) = &input.config_data {
#[allow(unused_mut)]
let mut object_76 = object.key("configData").start_object();
crate::json_ser::serialize_union_crate_model_config_type_data(&mut object_76, var_75)?;
object_76.finish();
}
if let Some(var_77) = &input.name {
object.key("name").string(var_77.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_ephemeris_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateEphemerisInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_78) = &input.enabled {
object.key("enabled").boolean(*var_78);
}
if let Some(var_79) = &input.name {
object.key("name").string(var_79.as_str());
}
if let Some(var_80) = &input.priority {
object.key("priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_80).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_mission_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateMissionProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.contact_post_pass_duration_seconds {
object.key("contactPostPassDurationSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_81).into()),
);
}
if let Some(var_82) = &input.contact_pre_pass_duration_seconds {
object.key("contactPrePassDurationSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_82).into()),
);
}
if let Some(var_83) = &input.dataflow_edges {
let mut array_84 = object.key("dataflowEdges").start_array();
for item_85 in var_83 {
{
let mut array_86 = array_84.value().start_array();
for item_87 in item_85 {
{
array_86.value().string(item_87.as_str());
}
}
array_86.finish();
}
}
array_84.finish();
}
if let Some(var_88) = &input.minimum_viable_contact_duration_seconds {
object.key("minimumViableContactDurationSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_88).into()),
);
}
if let Some(var_89) = &input.name {
object.key("name").string(var_89.as_str());
}
if let Some(var_90) = &input.tracking_config_arn {
object.key("trackingConfigArn").string(var_90.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_config_type_data(
object_2: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConfigTypeData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::ConfigTypeData::AntennaDownlinkConfig(inner) => {
#[allow(unused_mut)]
let mut object_91 = object_2.key("antennaDownlinkConfig").start_object();
crate::json_ser::serialize_structure_crate_model_antenna_downlink_config(
&mut object_91,
inner,
)?;
object_91.finish();
}
crate::model::ConfigTypeData::TrackingConfig(inner) => {
#[allow(unused_mut)]
let mut object_92 = object_2.key("trackingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_tracking_config(
&mut object_92,
inner,
)?;
object_92.finish();
}
crate::model::ConfigTypeData::DataflowEndpointConfig(inner) => {
#[allow(unused_mut)]
let mut object_93 = object_2.key("dataflowEndpointConfig").start_object();
crate::json_ser::serialize_structure_crate_model_dataflow_endpoint_config(
&mut object_93,
inner,
)?;
object_93.finish();
}
crate::model::ConfigTypeData::AntennaDownlinkDemodDecodeConfig(inner) => {
#[allow(unused_mut)]
let mut object_94 = object_2
.key("antennaDownlinkDemodDecodeConfig")
.start_object();
crate::json_ser::serialize_structure_crate_model_antenna_downlink_demod_decode_config(
&mut object_94,
inner,
)?;
object_94.finish();
}
crate::model::ConfigTypeData::AntennaUplinkConfig(inner) => {
#[allow(unused_mut)]
let mut object_95 = object_2.key("antennaUplinkConfig").start_object();
crate::json_ser::serialize_structure_crate_model_antenna_uplink_config(
&mut object_95,
inner,
)?;
object_95.finish();
}
crate::model::ConfigTypeData::UplinkEchoConfig(inner) => {
#[allow(unused_mut)]
let mut object_96 = object_2.key("uplinkEchoConfig").start_object();
crate::json_ser::serialize_structure_crate_model_uplink_echo_config(
&mut object_96,
inner,
)?;
object_96.finish();
}
crate::model::ConfigTypeData::S3RecordingConfig(inner) => {
#[allow(unused_mut)]
let mut object_97 = object_2.key("s3RecordingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_s3_recording_config(
&mut object_97,
inner,
)?;
object_97.finish();
}
crate::model::ConfigTypeData::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"ConfigTypeData",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_endpoint_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EndpointDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_98) = &input.security_details {
#[allow(unused_mut)]
let mut object_99 = object.key("securityDetails").start_object();
crate::json_ser::serialize_structure_crate_model_security_details(&mut object_99, var_98)?;
object_99.finish();
}
if let Some(var_100) = &input.endpoint {
#[allow(unused_mut)]
let mut object_101 = object.key("endpoint").start_object();
crate::json_ser::serialize_structure_crate_model_dataflow_endpoint(
&mut object_101,
var_100,
)?;
object_101.finish();
}
Ok(())
}
pub fn serialize_union_crate_model_ephemeris_data(
object_20: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EphemerisData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::EphemerisData::Tle(inner) => {
#[allow(unused_mut)]
let mut object_102 = object_20.key("tle").start_object();
crate::json_ser::serialize_structure_crate_model_tle_ephemeris(&mut object_102, inner)?;
object_102.finish();
}
crate::model::EphemerisData::Oem(inner) => {
#[allow(unused_mut)]
let mut object_103 = object_20.key("oem").start_object();
crate::json_ser::serialize_structure_crate_model_oem_ephemeris(&mut object_103, inner)?;
object_103.finish();
}
crate::model::EphemerisData::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"EphemerisData",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_antenna_downlink_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AntennaDownlinkConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_104) = &input.spectrum_config {
#[allow(unused_mut)]
let mut object_105 = object.key("spectrumConfig").start_object();
crate::json_ser::serialize_structure_crate_model_spectrum_config(&mut object_105, var_104)?;
object_105.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tracking_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TrackingConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_106) = &input.autotrack {
object.key("autotrack").string(var_106.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dataflow_endpoint_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataflowEndpointConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_107) = &input.dataflow_endpoint_name {
object.key("dataflowEndpointName").string(var_107.as_str());
}
if let Some(var_108) = &input.dataflow_endpoint_region {
object
.key("dataflowEndpointRegion")
.string(var_108.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_antenna_downlink_demod_decode_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AntennaDownlinkDemodDecodeConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_109) = &input.spectrum_config {
#[allow(unused_mut)]
let mut object_110 = object.key("spectrumConfig").start_object();
crate::json_ser::serialize_structure_crate_model_spectrum_config(&mut object_110, var_109)?;
object_110.finish();
}
if let Some(var_111) = &input.demodulation_config {
#[allow(unused_mut)]
let mut object_112 = object.key("demodulationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_demodulation_config(
&mut object_112,
var_111,
)?;
object_112.finish();
}
if let Some(var_113) = &input.decode_config {
#[allow(unused_mut)]
let mut object_114 = object.key("decodeConfig").start_object();
crate::json_ser::serialize_structure_crate_model_decode_config(&mut object_114, var_113)?;
object_114.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_antenna_uplink_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AntennaUplinkConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_115) = &input.transmit_disabled {
object.key("transmitDisabled").boolean(*var_115);
}
if let Some(var_116) = &input.spectrum_config {
#[allow(unused_mut)]
let mut object_117 = object.key("spectrumConfig").start_object();
crate::json_ser::serialize_structure_crate_model_uplink_spectrum_config(
&mut object_117,
var_116,
)?;
object_117.finish();
}
if let Some(var_118) = &input.target_eirp {
#[allow(unused_mut)]
let mut object_119 = object.key("targetEirp").start_object();
crate::json_ser::serialize_structure_crate_model_eirp(&mut object_119, var_118)?;
object_119.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_uplink_echo_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UplinkEchoConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_120) = &input.enabled {
object.key("enabled").boolean(*var_120);
}
if let Some(var_121) = &input.antenna_uplink_config_arn {
object
.key("antennaUplinkConfigArn")
.string(var_121.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_recording_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3RecordingConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_122) = &input.bucket_arn {
object.key("bucketArn").string(var_122.as_str());
}
if let Some(var_123) = &input.role_arn {
object.key("roleArn").string(var_123.as_str());
}
if let Some(var_124) = &input.prefix {
object.key("prefix").string(var_124.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_security_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SecurityDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.subnet_ids {
let mut array_126 = object.key("subnetIds").start_array();
for item_127 in var_125 {
{
array_126.value().string(item_127.as_str());
}
}
array_126.finish();
}
if let Some(var_128) = &input.security_group_ids {
let mut array_129 = object.key("securityGroupIds").start_array();
for item_130 in var_128 {
{
array_129.value().string(item_130.as_str());
}
}
array_129.finish();
}
if let Some(var_131) = &input.role_arn {
object.key("roleArn").string(var_131.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dataflow_endpoint(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataflowEndpoint,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_132) = &input.name {
object.key("name").string(var_132.as_str());
}
if let Some(var_133) = &input.address {
#[allow(unused_mut)]
let mut object_134 = object.key("address").start_object();
crate::json_ser::serialize_structure_crate_model_socket_address(&mut object_134, var_133)?;
object_134.finish();
}
if let Some(var_135) = &input.status {
object.key("status").string(var_135.as_str());
}
if let Some(var_136) = &input.mtu {
object.key("mtu").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_136).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_tle_ephemeris(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TleEphemeris,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_137) = &input.s3_object {
#[allow(unused_mut)]
let mut object_138 = object.key("s3Object").start_object();
crate::json_ser::serialize_structure_crate_model_s3_object(&mut object_138, var_137)?;
object_138.finish();
}
if let Some(var_139) = &input.tle_data {
let mut array_140 = object.key("tleData").start_array();
for item_141 in var_139 {
{
#[allow(unused_mut)]
let mut object_142 = array_140.value().start_object();
crate::json_ser::serialize_structure_crate_model_tle_data(
&mut object_142,
item_141,
)?;
object_142.finish();
}
}
array_140.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_oem_ephemeris(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OemEphemeris,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_143) = &input.s3_object {
#[allow(unused_mut)]
let mut object_144 = object.key("s3Object").start_object();
crate::json_ser::serialize_structure_crate_model_s3_object(&mut object_144, var_143)?;
object_144.finish();
}
if let Some(var_145) = &input.oem_data {
object.key("oemData").string(var_145.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_spectrum_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SpectrumConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.center_frequency {
#[allow(unused_mut)]
let mut object_147 = object.key("centerFrequency").start_object();
crate::json_ser::serialize_structure_crate_model_frequency(&mut object_147, var_146)?;
object_147.finish();
}
if let Some(var_148) = &input.bandwidth {
#[allow(unused_mut)]
let mut object_149 = object.key("bandwidth").start_object();
crate::json_ser::serialize_structure_crate_model_frequency_bandwidth(
&mut object_149,
var_148,
)?;
object_149.finish();
}
if let Some(var_150) = &input.polarization {
object.key("polarization").string(var_150.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_demodulation_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DemodulationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_151) = &input.unvalidated_json {
object.key("unvalidatedJSON").string(var_151.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_decode_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DecodeConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_152) = &input.unvalidated_json {
object.key("unvalidatedJSON").string(var_152.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_uplink_spectrum_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UplinkSpectrumConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_153) = &input.center_frequency {
#[allow(unused_mut)]
let mut object_154 = object.key("centerFrequency").start_object();
crate::json_ser::serialize_structure_crate_model_frequency(&mut object_154, var_153)?;
object_154.finish();
}
if let Some(var_155) = &input.polarization {
object.key("polarization").string(var_155.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_eirp(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Eirp,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.value {
object.key("value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_156).into()),
);
}
if let Some(var_157) = &input.units {
object.key("units").string(var_157.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_socket_address(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SocketAddress,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_158) = &input.name {
object.key("name").string(var_158.as_str());
}
if let Some(var_159) = &input.port {
object.key("port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_159).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_object(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3Object,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_160) = &input.bucket {
object.key("bucket").string(var_160.as_str());
}
if let Some(var_161) = &input.key {
object.key("key").string(var_161.as_str());
}
if let Some(var_162) = &input.version {
object.key("version").string(var_162.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tle_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TleData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_163) = &input.tle_line1 {
object.key("tleLine1").string(var_163.as_str());
}
if let Some(var_164) = &input.tle_line2 {
object.key("tleLine2").string(var_164.as_str());
}
if let Some(var_165) = &input.valid_time_range {
#[allow(unused_mut)]
let mut object_166 = object.key("validTimeRange").start_object();
crate::json_ser::serialize_structure_crate_model_time_range(&mut object_166, var_165)?;
object_166.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_frequency(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Frequency,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_167) = &input.value {
object.key("value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_167).into()),
);
}
if let Some(var_168) = &input.units {
object.key("units").string(var_168.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_frequency_bandwidth(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FrequencyBandwidth,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_169) = &input.value {
object.key("value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_169).into()),
);
}
if let Some(var_170) = &input.units {
object.key("units").string(var_170.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_time_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_171) = &input.start_time {
object
.key("startTime")
.date_time(var_171, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_172) = &input.end_time {
object
.key("endTime")
.date_time(var_172, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}