pub fn serialize_structure_crate_input_associate_aws_account_with_partner_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateAwsAccountWithPartnerAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.client_request_token {
object.key("ClientRequestToken").string(var_1.as_str());
}
if let Some(var_2) = &input.sidewalk {
#[allow(unused_mut)]
let mut object_3 = object.key("Sidewalk").start_object();
crate::json_ser::serialize_structure_crate_model_sidewalk_account_info(
&mut object_3,
var_2,
)?;
object_3.finish();
}
if let Some(var_4) = &input.tags {
let mut array_5 = object.key("Tags").start_array();
for item_6 in var_4 {
{
#[allow(unused_mut)]
let mut object_7 = array_5.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_7, item_6)?;
object_7.finish();
}
}
array_5.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_multicast_group_with_fuota_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateMulticastGroupWithFuotaTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_8) = &input.multicast_group_id {
object.key("MulticastGroupId").string(var_8.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_wireless_device_with_fuota_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateWirelessDeviceWithFuotaTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_9) = &input.wireless_device_id {
object.key("WirelessDeviceId").string(var_9.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_wireless_device_with_multicast_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateWirelessDeviceWithMulticastGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_10) = &input.wireless_device_id {
object.key("WirelessDeviceId").string(var_10.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_wireless_device_with_thing_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateWirelessDeviceWithThingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_11) = &input.thing_arn {
object.key("ThingArn").string(var_11.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_wireless_gateway_with_certificate_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateWirelessGatewayWithCertificateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.iot_certificate_id {
object.key("IotCertificateId").string(var_12.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_wireless_gateway_with_thing_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateWirelessGatewayWithThingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_13) = &input.thing_arn {
object.key("ThingArn").string(var_13.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_destination_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDestinationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.client_request_token {
object.key("ClientRequestToken").string(var_14.as_str());
}
if let Some(var_15) = &input.description {
object.key("Description").string(var_15.as_str());
}
if let Some(var_16) = &input.expression {
object.key("Expression").string(var_16.as_str());
}
if let Some(var_17) = &input.expression_type {
object.key("ExpressionType").string(var_17.as_str());
}
if let Some(var_18) = &input.name {
object.key("Name").string(var_18.as_str());
}
if let Some(var_19) = &input.role_arn {
object.key("RoleArn").string(var_19.as_str());
}
if let Some(var_20) = &input.tags {
let mut array_21 = object.key("Tags").start_array();
for item_22 in var_20 {
{
#[allow(unused_mut)]
let mut object_23 = array_21.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_23, item_22)?;
object_23.finish();
}
}
array_21.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_device_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDeviceProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_24) = &input.client_request_token {
object.key("ClientRequestToken").string(var_24.as_str());
}
if let Some(var_25) = &input.lo_ra_wan {
#[allow(unused_mut)]
let mut object_26 = object.key("LoRaWAN").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_device_profile(
&mut object_26,
var_25,
)?;
object_26.finish();
}
if let Some(var_27) = &input.name {
object.key("Name").string(var_27.as_str());
}
if let Some(var_28) = &input.tags {
let mut array_29 = object.key("Tags").start_array();
for item_30 in var_28 {
{
#[allow(unused_mut)]
let mut object_31 = array_29.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_31, item_30)?;
object_31.finish();
}
}
array_29.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_fuota_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFuotaTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_32) = &input.client_request_token {
object.key("ClientRequestToken").string(var_32.as_str());
}
if let Some(var_33) = &input.description {
object.key("Description").string(var_33.as_str());
}
if let Some(var_34) = &input.firmware_update_image {
object.key("FirmwareUpdateImage").string(var_34.as_str());
}
if let Some(var_35) = &input.firmware_update_role {
object.key("FirmwareUpdateRole").string(var_35.as_str());
}
if let Some(var_36) = &input.lo_ra_wan {
#[allow(unused_mut)]
let mut object_37 = object.key("LoRaWAN").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_fuota_task(
&mut object_37,
var_36,
)?;
object_37.finish();
}
if let Some(var_38) = &input.name {
object.key("Name").string(var_38.as_str());
}
if let Some(var_39) = &input.tags {
let mut array_40 = object.key("Tags").start_array();
for item_41 in var_39 {
{
#[allow(unused_mut)]
let mut object_42 = array_40.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_42, item_41)?;
object_42.finish();
}
}
array_40.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_multicast_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateMulticastGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_43) = &input.client_request_token {
object.key("ClientRequestToken").string(var_43.as_str());
}
if let Some(var_44) = &input.description {
object.key("Description").string(var_44.as_str());
}
if let Some(var_45) = &input.lo_ra_wan {
#[allow(unused_mut)]
let mut object_46 = object.key("LoRaWAN").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_multicast(
&mut object_46,
var_45,
)?;
object_46.finish();
}
if let Some(var_47) = &input.name {
object.key("Name").string(var_47.as_str());
}
if let Some(var_48) = &input.tags {
let mut array_49 = object.key("Tags").start_array();
for item_50 in var_48 {
{
#[allow(unused_mut)]
let mut object_51 = array_49.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_51, item_50)?;
object_51.finish();
}
}
array_49.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_network_analyzer_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateNetworkAnalyzerConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_52) = &input.client_request_token {
object.key("ClientRequestToken").string(var_52.as_str());
}
if let Some(var_53) = &input.description {
object.key("Description").string(var_53.as_str());
}
if let Some(var_54) = &input.name {
object.key("Name").string(var_54.as_str());
}
if let Some(var_55) = &input.tags {
let mut array_56 = object.key("Tags").start_array();
for item_57 in var_55 {
{
#[allow(unused_mut)]
let mut object_58 = array_56.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_58, item_57)?;
object_58.finish();
}
}
array_56.finish();
}
if let Some(var_59) = &input.trace_content {
#[allow(unused_mut)]
let mut object_60 = object.key("TraceContent").start_object();
crate::json_ser::serialize_structure_crate_model_trace_content(&mut object_60, var_59)?;
object_60.finish();
}
if let Some(var_61) = &input.wireless_devices {
let mut array_62 = object.key("WirelessDevices").start_array();
for item_63 in var_61 {
{
array_62.value().string(item_63.as_str());
}
}
array_62.finish();
}
if let Some(var_64) = &input.wireless_gateways {
let mut array_65 = object.key("WirelessGateways").start_array();
for item_66 in var_64 {
{
array_65.value().string(item_66.as_str());
}
}
array_65.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_service_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateServiceProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_67) = &input.client_request_token {
object.key("ClientRequestToken").string(var_67.as_str());
}
if let Some(var_68) = &input.lo_ra_wan {
#[allow(unused_mut)]
let mut object_69 = object.key("LoRaWAN").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_service_profile(
&mut object_69,
var_68,
)?;
object_69.finish();
}
if let Some(var_70) = &input.name {
object.key("Name").string(var_70.as_str());
}
if let Some(var_71) = &input.tags {
let mut array_72 = object.key("Tags").start_array();
for item_73 in var_71 {
{
#[allow(unused_mut)]
let mut object_74 = array_72.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_74, item_73)?;
object_74.finish();
}
}
array_72.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_wireless_device_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateWirelessDeviceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_75) = &input.client_request_token {
object.key("ClientRequestToken").string(var_75.as_str());
}
if let Some(var_76) = &input.description {
object.key("Description").string(var_76.as_str());
}
if let Some(var_77) = &input.destination_name {
object.key("DestinationName").string(var_77.as_str());
}
if let Some(var_78) = &input.lo_ra_wan {
#[allow(unused_mut)]
let mut object_79 = object.key("LoRaWAN").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_device(&mut object_79, var_78)?;
object_79.finish();
}
if let Some(var_80) = &input.name {
object.key("Name").string(var_80.as_str());
}
if let Some(var_81) = &input.positioning {
object.key("Positioning").string(var_81.as_str());
}
if let Some(var_82) = &input.tags {
let mut array_83 = object.key("Tags").start_array();
for item_84 in var_82 {
{
#[allow(unused_mut)]
let mut object_85 = array_83.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_85, item_84)?;
object_85.finish();
}
}
array_83.finish();
}
if let Some(var_86) = &input.r#type {
object.key("Type").string(var_86.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_wireless_gateway_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateWirelessGatewayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.client_request_token {
object.key("ClientRequestToken").string(var_87.as_str());
}
if let Some(var_88) = &input.description {
object.key("Description").string(var_88.as_str());
}
if let Some(var_89) = &input.lo_ra_wan {
#[allow(unused_mut)]
let mut object_90 = object.key("LoRaWAN").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_gateway(&mut object_90, var_89)?;
object_90.finish();
}
if let Some(var_91) = &input.name {
object.key("Name").string(var_91.as_str());
}
if let Some(var_92) = &input.tags {
let mut array_93 = object.key("Tags").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_tag(&mut object_95, item_94)?;
object_95.finish();
}
}
array_93.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_wireless_gateway_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateWirelessGatewayTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_96) = &input.wireless_gateway_task_definition_id {
object
.key("WirelessGatewayTaskDefinitionId")
.string(var_96.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_wireless_gateway_task_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateWirelessGatewayTaskDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object
.key("AutoCreateTasks")
.boolean(input.auto_create_tasks);
}
if let Some(var_97) = &input.client_request_token {
object.key("ClientRequestToken").string(var_97.as_str());
}
if let Some(var_98) = &input.name {
object.key("Name").string(var_98.as_str());
}
if let Some(var_99) = &input.tags {
let mut array_100 = object.key("Tags").start_array();
for item_101 in var_99 {
{
#[allow(unused_mut)]
let mut object_102 = array_100.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_102, item_101)?;
object_102.finish();
}
}
array_100.finish();
}
if let Some(var_103) = &input.update {
#[allow(unused_mut)]
let mut object_104 = object.key("Update").start_object();
crate::json_ser::serialize_structure_crate_model_update_wireless_gateway_task_create(
&mut object_104,
var_103,
)?;
object_104.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_position_estimate_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetPositionEstimateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_105) = &input.cell_towers {
#[allow(unused_mut)]
let mut object_106 = object.key("CellTowers").start_object();
crate::json_ser::serialize_structure_crate_model_cell_towers(&mut object_106, var_105)?;
object_106.finish();
}
if let Some(var_107) = &input.gnss {
#[allow(unused_mut)]
let mut object_108 = object.key("Gnss").start_object();
crate::json_ser::serialize_structure_crate_model_gnss(&mut object_108, var_107)?;
object_108.finish();
}
if let Some(var_109) = &input.ip {
#[allow(unused_mut)]
let mut object_110 = object.key("Ip").start_object();
crate::json_ser::serialize_structure_crate_model_ip(&mut object_110, var_109)?;
object_110.finish();
}
if let Some(var_111) = &input.timestamp {
object
.key("Timestamp")
.date_time(var_111, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_112) = &input.wi_fi_access_points {
let mut array_113 = object.key("WiFiAccessPoints").start_array();
for item_114 in var_112 {
{
#[allow(unused_mut)]
let mut object_115 = array_113.value().start_object();
crate::json_ser::serialize_structure_crate_model_wi_fi_access_point(
&mut object_115,
item_114,
)?;
object_115.finish();
}
}
array_113.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_position_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutPositionConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_116) = &input.destination {
object.key("Destination").string(var_116.as_str());
}
if let Some(var_117) = &input.solvers {
#[allow(unused_mut)]
let mut object_118 = object.key("Solvers").start_object();
crate::json_ser::serialize_structure_crate_model_position_solver_configurations(
&mut object_118,
var_117,
)?;
object_118.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_resource_log_level_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutResourceLogLevelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_119) = &input.log_level {
object.key("LogLevel").string(var_119.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_send_data_to_multicast_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SendDataToMulticastGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_120) = &input.payload_data {
object.key("PayloadData").string(var_120.as_str());
}
if let Some(var_121) = &input.wireless_metadata {
#[allow(unused_mut)]
let mut object_122 = object.key("WirelessMetadata").start_object();
crate::json_ser::serialize_structure_crate_model_multicast_wireless_metadata(
&mut object_122,
var_121,
)?;
object_122.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_send_data_to_wireless_device_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SendDataToWirelessDeviceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_123) = &input.payload_data {
object.key("PayloadData").string(var_123.as_str());
}
if let Some(var_124) = &input.transmit_mode {
object.key("TransmitMode").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_124).into()),
);
}
if let Some(var_125) = &input.wireless_metadata {
#[allow(unused_mut)]
let mut object_126 = object.key("WirelessMetadata").start_object();
crate::json_ser::serialize_structure_crate_model_wireless_metadata(
&mut object_126,
var_125,
)?;
object_126.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_bulk_associate_wireless_device_with_multicast_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartBulkAssociateWirelessDeviceWithMulticastGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_127) = &input.query_string {
object.key("QueryString").string(var_127.as_str());
}
if let Some(var_128) = &input.tags {
let mut array_129 = object.key("Tags").start_array();
for item_130 in var_128 {
{
#[allow(unused_mut)]
let mut object_131 = array_129.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_131, item_130)?;
object_131.finish();
}
}
array_129.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_bulk_disassociate_wireless_device_from_multicast_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartBulkDisassociateWirelessDeviceFromMulticastGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_132) = &input.query_string {
object.key("QueryString").string(var_132.as_str());
}
if let Some(var_133) = &input.tags {
let mut array_134 = object.key("Tags").start_array();
for item_135 in var_133 {
{
#[allow(unused_mut)]
let mut object_136 = array_134.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_136, item_135)?;
object_136.finish();
}
}
array_134.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_fuota_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartFuotaTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_137) = &input.lo_ra_wan {
#[allow(unused_mut)]
let mut object_138 = object.key("LoRaWAN").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_start_fuota_task(
&mut object_138,
var_137,
)?;
object_138.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_multicast_group_session_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartMulticastGroupSessionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_139) = &input.lo_ra_wan {
#[allow(unused_mut)]
let mut object_140 = object.key("LoRaWAN").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_multicast_session(
&mut object_140,
var_139,
)?;
object_140.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_141) = &input.tags {
let mut array_142 = object.key("Tags").start_array();
for item_143 in var_141 {
{
#[allow(unused_mut)]
let mut object_144 = array_142.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_144, item_143)?;
object_144.finish();
}
}
array_142.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_destination_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDestinationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_145) = &input.description {
object.key("Description").string(var_145.as_str());
}
if let Some(var_146) = &input.expression {
object.key("Expression").string(var_146.as_str());
}
if let Some(var_147) = &input.expression_type {
object.key("ExpressionType").string(var_147.as_str());
}
if let Some(var_148) = &input.role_arn {
object.key("RoleArn").string(var_148.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_event_configuration_by_resource_types_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateEventConfigurationByResourceTypesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_149) = &input.connection_status {
#[allow(unused_mut)]
let mut object_150 = object.key("ConnectionStatus").start_object();
crate::json_ser::serialize_structure_crate_model_connection_status_resource_type_event_configuration(&mut object_150, var_149)?;
object_150.finish();
}
if let Some(var_151) = &input.device_registration_state {
#[allow(unused_mut)]
let mut object_152 = object.key("DeviceRegistrationState").start_object();
crate::json_ser::serialize_structure_crate_model_device_registration_state_resource_type_event_configuration(&mut object_152, var_151)?;
object_152.finish();
}
if let Some(var_153) = &input.join {
#[allow(unused_mut)]
let mut object_154 = object.key("Join").start_object();
crate::json_ser::serialize_structure_crate_model_join_resource_type_event_configuration(
&mut object_154,
var_153,
)?;
object_154.finish();
}
if let Some(var_155) = &input.message_delivery_status {
#[allow(unused_mut)]
let mut object_156 = object.key("MessageDeliveryStatus").start_object();
crate::json_ser::serialize_structure_crate_model_message_delivery_status_resource_type_event_configuration(&mut object_156, var_155)?;
object_156.finish();
}
if let Some(var_157) = &input.proximity {
#[allow(unused_mut)]
let mut object_158 = object.key("Proximity").start_object();
crate::json_ser::serialize_structure_crate_model_proximity_resource_type_event_configuration(&mut object_158, var_157)?;
object_158.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_fuota_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFuotaTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_159) = &input.description {
object.key("Description").string(var_159.as_str());
}
if let Some(var_160) = &input.firmware_update_image {
object.key("FirmwareUpdateImage").string(var_160.as_str());
}
if let Some(var_161) = &input.firmware_update_role {
object.key("FirmwareUpdateRole").string(var_161.as_str());
}
if let Some(var_162) = &input.lo_ra_wan {
#[allow(unused_mut)]
let mut object_163 = object.key("LoRaWAN").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_fuota_task(
&mut object_163,
var_162,
)?;
object_163.finish();
}
if let Some(var_164) = &input.name {
object.key("Name").string(var_164.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_log_levels_by_resource_types_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateLogLevelsByResourceTypesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.default_log_level {
object.key("DefaultLogLevel").string(var_165.as_str());
}
if let Some(var_166) = &input.wireless_device_log_options {
let mut array_167 = object.key("WirelessDeviceLogOptions").start_array();
for item_168 in var_166 {
{
#[allow(unused_mut)]
let mut object_169 = array_167.value().start_object();
crate::json_ser::serialize_structure_crate_model_wireless_device_log_option(
&mut object_169,
item_168,
)?;
object_169.finish();
}
}
array_167.finish();
}
if let Some(var_170) = &input.wireless_gateway_log_options {
let mut array_171 = object.key("WirelessGatewayLogOptions").start_array();
for item_172 in var_170 {
{
#[allow(unused_mut)]
let mut object_173 = array_171.value().start_object();
crate::json_ser::serialize_structure_crate_model_wireless_gateway_log_option(
&mut object_173,
item_172,
)?;
object_173.finish();
}
}
array_171.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_multicast_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateMulticastGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_174) = &input.description {
object.key("Description").string(var_174.as_str());
}
if let Some(var_175) = &input.lo_ra_wan {
#[allow(unused_mut)]
let mut object_176 = object.key("LoRaWAN").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_multicast(
&mut object_176,
var_175,
)?;
object_176.finish();
}
if let Some(var_177) = &input.name {
object.key("Name").string(var_177.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_network_analyzer_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateNetworkAnalyzerConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_178) = &input.description {
object.key("Description").string(var_178.as_str());
}
if let Some(var_179) = &input.trace_content {
#[allow(unused_mut)]
let mut object_180 = object.key("TraceContent").start_object();
crate::json_ser::serialize_structure_crate_model_trace_content(&mut object_180, var_179)?;
object_180.finish();
}
if let Some(var_181) = &input.wireless_devices_to_add {
let mut array_182 = object.key("WirelessDevicesToAdd").start_array();
for item_183 in var_181 {
{
array_182.value().string(item_183.as_str());
}
}
array_182.finish();
}
if let Some(var_184) = &input.wireless_devices_to_remove {
let mut array_185 = object.key("WirelessDevicesToRemove").start_array();
for item_186 in var_184 {
{
array_185.value().string(item_186.as_str());
}
}
array_185.finish();
}
if let Some(var_187) = &input.wireless_gateways_to_add {
let mut array_188 = object.key("WirelessGatewaysToAdd").start_array();
for item_189 in var_187 {
{
array_188.value().string(item_189.as_str());
}
}
array_188.finish();
}
if let Some(var_190) = &input.wireless_gateways_to_remove {
let mut array_191 = object.key("WirelessGatewaysToRemove").start_array();
for item_192 in var_190 {
{
array_191.value().string(item_192.as_str());
}
}
array_191.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_partner_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePartnerAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_193) = &input.sidewalk {
#[allow(unused_mut)]
let mut object_194 = object.key("Sidewalk").start_object();
crate::json_ser::serialize_structure_crate_model_sidewalk_update_account(
&mut object_194,
var_193,
)?;
object_194.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_position_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePositionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_195) = &input.position {
let mut array_196 = object.key("Position").start_array();
for item_197 in var_195 {
{
array_196.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*item_197).into()),
);
}
}
array_196.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_resource_event_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateResourceEventConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_198) = &input.connection_status {
#[allow(unused_mut)]
let mut object_199 = object.key("ConnectionStatus").start_object();
crate::json_ser::serialize_structure_crate_model_connection_status_event_configuration(
&mut object_199,
var_198,
)?;
object_199.finish();
}
if let Some(var_200) = &input.device_registration_state {
#[allow(unused_mut)]
let mut object_201 = object.key("DeviceRegistrationState").start_object();
crate::json_ser::serialize_structure_crate_model_device_registration_state_event_configuration(&mut object_201, var_200)?;
object_201.finish();
}
if let Some(var_202) = &input.join {
#[allow(unused_mut)]
let mut object_203 = object.key("Join").start_object();
crate::json_ser::serialize_structure_crate_model_join_event_configuration(
&mut object_203,
var_202,
)?;
object_203.finish();
}
if let Some(var_204) = &input.message_delivery_status {
#[allow(unused_mut)]
let mut object_205 = object.key("MessageDeliveryStatus").start_object();
crate::json_ser::serialize_structure_crate_model_message_delivery_status_event_configuration(&mut object_205, var_204)?;
object_205.finish();
}
if let Some(var_206) = &input.proximity {
#[allow(unused_mut)]
let mut object_207 = object.key("Proximity").start_object();
crate::json_ser::serialize_structure_crate_model_proximity_event_configuration(
&mut object_207,
var_206,
)?;
object_207.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_wireless_device_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateWirelessDeviceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_208) = &input.description {
object.key("Description").string(var_208.as_str());
}
if let Some(var_209) = &input.destination_name {
object.key("DestinationName").string(var_209.as_str());
}
if let Some(var_210) = &input.lo_ra_wan {
#[allow(unused_mut)]
let mut object_211 = object.key("LoRaWAN").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_update_device(
&mut object_211,
var_210,
)?;
object_211.finish();
}
if let Some(var_212) = &input.name {
object.key("Name").string(var_212.as_str());
}
if let Some(var_213) = &input.positioning {
object.key("Positioning").string(var_213.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_wireless_gateway_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateWirelessGatewayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_214) = &input.description {
object.key("Description").string(var_214.as_str());
}
if let Some(var_215) = &input.join_eui_filters {
let mut array_216 = object.key("JoinEuiFilters").start_array();
for item_217 in var_215 {
{
let mut array_218 = array_216.value().start_array();
for item_219 in item_217 {
{
array_218.value().string(item_219.as_str());
}
}
array_218.finish();
}
}
array_216.finish();
}
if let Some(var_220) = &input.name {
object.key("Name").string(var_220.as_str());
}
if let Some(var_221) = &input.net_id_filters {
let mut array_222 = object.key("NetIdFilters").start_array();
for item_223 in var_221 {
{
array_222.value().string(item_223.as_str());
}
}
array_222.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sidewalk_account_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SidewalkAccountInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_224) = &input.amazon_id {
object.key("AmazonId").string(var_224.as_str());
}
if let Some(var_225) = &input.app_server_private_key {
object.key("AppServerPrivateKey").string(var_225.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_226) = &input.key {
object.key("Key").string(var_226.as_str());
}
if let Some(var_227) = &input.value {
object.key("Value").string(var_227.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lo_ra_wan_device_profile(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoRaWanDeviceProfile,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.supports_class_b {
object.key("SupportsClassB").boolean(input.supports_class_b);
}
if let Some(var_228) = &input.class_b_timeout {
object.key("ClassBTimeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_228).into()),
);
}
if let Some(var_229) = &input.ping_slot_period {
object.key("PingSlotPeriod").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_229).into()),
);
}
if let Some(var_230) = &input.ping_slot_dr {
object.key("PingSlotDr").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_230).into()),
);
}
if let Some(var_231) = &input.ping_slot_freq {
object.key("PingSlotFreq").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_231).into()),
);
}
if input.supports_class_c {
object.key("SupportsClassC").boolean(input.supports_class_c);
}
if let Some(var_232) = &input.class_c_timeout {
object.key("ClassCTimeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_232).into()),
);
}
if let Some(var_233) = &input.mac_version {
object.key("MacVersion").string(var_233.as_str());
}
if let Some(var_234) = &input.reg_params_revision {
object.key("RegParamsRevision").string(var_234.as_str());
}
if let Some(var_235) = &input.rx_delay1 {
object.key("RxDelay1").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_235).into()),
);
}
if let Some(var_236) = &input.rx_dr_offset1 {
object.key("RxDrOffset1").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_236).into()),
);
}
if let Some(var_237) = &input.rx_data_rate2 {
object.key("RxDataRate2").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_237).into()),
);
}
if let Some(var_238) = &input.rx_freq2 {
object.key("RxFreq2").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_238).into()),
);
}
if let Some(var_239) = &input.factory_preset_freqs_list {
let mut array_240 = object.key("FactoryPresetFreqsList").start_array();
for item_241 in var_239 {
{
array_240.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_241).into()),
);
}
}
array_240.finish();
}
if let Some(var_242) = &input.max_eirp {
object.key("MaxEirp").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_242).into()),
);
}
if let Some(var_243) = &input.max_duty_cycle {
object.key("MaxDutyCycle").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_243).into()),
);
}
if let Some(var_244) = &input.rf_region {
object.key("RfRegion").string(var_244.as_str());
}
if let Some(var_245) = &input.supports_join {
object.key("SupportsJoin").boolean(*var_245);
}
if input.supports32_bit_f_cnt {
object
.key("Supports32BitFCnt")
.boolean(input.supports32_bit_f_cnt);
}
Ok(())
}
pub fn serialize_structure_crate_model_lo_ra_wan_fuota_task(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoRaWanFuotaTask,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_246) = &input.rf_region {
object.key("RfRegion").string(var_246.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lo_ra_wan_multicast(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoRaWanMulticast,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_247) = &input.rf_region {
object.key("RfRegion").string(var_247.as_str());
}
if let Some(var_248) = &input.dl_class {
object.key("DlClass").string(var_248.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_trace_content(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TraceContent,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_249) = &input.wireless_device_frame_info {
object
.key("WirelessDeviceFrameInfo")
.string(var_249.as_str());
}
if let Some(var_250) = &input.log_level {
object.key("LogLevel").string(var_250.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lo_ra_wan_service_profile(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoRaWanServiceProfile,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.add_gw_metadata {
object.key("AddGwMetadata").boolean(input.add_gw_metadata);
}
if let Some(var_251) = &input.dr_min {
object.key("DrMin").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_251).into()),
);
}
if let Some(var_252) = &input.dr_max {
object.key("DrMax").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_252).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_lo_ra_wan_device(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoRaWanDevice,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_253) = &input.dev_eui {
object.key("DevEui").string(var_253.as_str());
}
if let Some(var_254) = &input.device_profile_id {
object.key("DeviceProfileId").string(var_254.as_str());
}
if let Some(var_255) = &input.service_profile_id {
object.key("ServiceProfileId").string(var_255.as_str());
}
if let Some(var_256) = &input.otaa_v1_1 {
#[allow(unused_mut)]
let mut object_257 = object.key("OtaaV1_1").start_object();
crate::json_ser::serialize_structure_crate_model_otaa_v11(&mut object_257, var_256)?;
object_257.finish();
}
if let Some(var_258) = &input.otaa_v1_0_x {
#[allow(unused_mut)]
let mut object_259 = object.key("OtaaV1_0_x").start_object();
crate::json_ser::serialize_structure_crate_model_otaa_v10_x(&mut object_259, var_258)?;
object_259.finish();
}
if let Some(var_260) = &input.abp_v1_1 {
#[allow(unused_mut)]
let mut object_261 = object.key("AbpV1_1").start_object();
crate::json_ser::serialize_structure_crate_model_abp_v11(&mut object_261, var_260)?;
object_261.finish();
}
if let Some(var_262) = &input.abp_v1_0_x {
#[allow(unused_mut)]
let mut object_263 = object.key("AbpV1_0_x").start_object();
crate::json_ser::serialize_structure_crate_model_abp_v10_x(&mut object_263, var_262)?;
object_263.finish();
}
if let Some(var_264) = &input.f_ports {
#[allow(unused_mut)]
let mut object_265 = object.key("FPorts").start_object();
crate::json_ser::serialize_structure_crate_model_f_ports(&mut object_265, var_264)?;
object_265.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_lo_ra_wan_gateway(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoRaWanGateway,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_266) = &input.gateway_eui {
object.key("GatewayEui").string(var_266.as_str());
}
if let Some(var_267) = &input.rf_region {
object.key("RfRegion").string(var_267.as_str());
}
if let Some(var_268) = &input.join_eui_filters {
let mut array_269 = object.key("JoinEuiFilters").start_array();
for item_270 in var_268 {
{
let mut array_271 = array_269.value().start_array();
for item_272 in item_270 {
{
array_271.value().string(item_272.as_str());
}
}
array_271.finish();
}
}
array_269.finish();
}
if let Some(var_273) = &input.net_id_filters {
let mut array_274 = object.key("NetIdFilters").start_array();
for item_275 in var_273 {
{
array_274.value().string(item_275.as_str());
}
}
array_274.finish();
}
if let Some(var_276) = &input.sub_bands {
let mut array_277 = object.key("SubBands").start_array();
for item_278 in var_276 {
{
array_277.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_278).into()),
);
}
}
array_277.finish();
}
if let Some(var_279) = &input.beaconing {
#[allow(unused_mut)]
let mut object_280 = object.key("Beaconing").start_object();
crate::json_ser::serialize_structure_crate_model_beaconing(&mut object_280, var_279)?;
object_280.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_wireless_gateway_task_create(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateWirelessGatewayTaskCreate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_281) = &input.update_data_source {
object.key("UpdateDataSource").string(var_281.as_str());
}
if let Some(var_282) = &input.update_data_role {
object.key("UpdateDataRole").string(var_282.as_str());
}
if let Some(var_283) = &input.lo_ra_wan {
#[allow(unused_mut)]
let mut object_284 = object.key("LoRaWAN").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_update_gateway_task_create(
&mut object_284,
var_283,
)?;
object_284.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_cell_towers(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CellTowers,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_285) = &input.gsm {
let mut array_286 = object.key("Gsm").start_array();
for item_287 in var_285 {
{
#[allow(unused_mut)]
let mut object_288 = array_286.value().start_object();
crate::json_ser::serialize_structure_crate_model_gsm_obj(
&mut object_288,
item_287,
)?;
object_288.finish();
}
}
array_286.finish();
}
if let Some(var_289) = &input.wcdma {
let mut array_290 = object.key("Wcdma").start_array();
for item_291 in var_289 {
{
#[allow(unused_mut)]
let mut object_292 = array_290.value().start_object();
crate::json_ser::serialize_structure_crate_model_wcdma_obj(
&mut object_292,
item_291,
)?;
object_292.finish();
}
}
array_290.finish();
}
if let Some(var_293) = &input.tdscdma {
let mut array_294 = object.key("Tdscdma").start_array();
for item_295 in var_293 {
{
#[allow(unused_mut)]
let mut object_296 = array_294.value().start_object();
crate::json_ser::serialize_structure_crate_model_tdscdma_obj(
&mut object_296,
item_295,
)?;
object_296.finish();
}
}
array_294.finish();
}
if let Some(var_297) = &input.lte {
let mut array_298 = object.key("Lte").start_array();
for item_299 in var_297 {
{
#[allow(unused_mut)]
let mut object_300 = array_298.value().start_object();
crate::json_ser::serialize_structure_crate_model_lte_obj(
&mut object_300,
item_299,
)?;
object_300.finish();
}
}
array_298.finish();
}
if let Some(var_301) = &input.cdma {
let mut array_302 = object.key("Cdma").start_array();
for item_303 in var_301 {
{
#[allow(unused_mut)]
let mut object_304 = array_302.value().start_object();
crate::json_ser::serialize_structure_crate_model_cdma_obj(
&mut object_304,
item_303,
)?;
object_304.finish();
}
}
array_302.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_gnss(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Gnss,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_305) = &input.payload {
object.key("Payload").string(var_305.as_str());
}
if let Some(var_306) = &input.capture_time {
object.key("CaptureTime").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_306).into()),
);
}
if let Some(var_307) = &input.capture_time_accuracy {
object.key("CaptureTimeAccuracy").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_307).into()),
);
}
if let Some(var_308) = &input.assist_position {
let mut array_309 = object.key("AssistPosition").start_array();
for item_310 in var_308 {
{
array_309.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*item_310).into()),
);
}
}
array_309.finish();
}
if let Some(var_311) = &input.assist_altitude {
object.key("AssistAltitude").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_311).into()),
);
}
if input.use2_d_solver {
object.key("Use2DSolver").boolean(input.use2_d_solver);
}
Ok(())
}
pub fn serialize_structure_crate_model_ip(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Ip,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_312) = &input.ip_address {
object.key("IpAddress").string(var_312.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_wi_fi_access_point(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WiFiAccessPoint,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_313) = &input.mac_address {
object.key("MacAddress").string(var_313.as_str());
}
if let Some(var_314) = &input.rss {
object.key("Rss").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_314).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_position_solver_configurations(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PositionSolverConfigurations,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_315) = &input.semtech_gnss {
#[allow(unused_mut)]
let mut object_316 = object.key("SemtechGnss").start_object();
crate::json_ser::serialize_structure_crate_model_semtech_gnss_configuration(
&mut object_316,
var_315,
)?;
object_316.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_multicast_wireless_metadata(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MulticastWirelessMetadata,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_317) = &input.lo_ra_wan {
#[allow(unused_mut)]
let mut object_318 = object.key("LoRaWAN").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_multicast_metadata(
&mut object_318,
var_317,
)?;
object_318.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_wireless_metadata(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WirelessMetadata,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_319) = &input.lo_ra_wan {
#[allow(unused_mut)]
let mut object_320 = object.key("LoRaWAN").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_send_data_to_device(
&mut object_320,
var_319,
)?;
object_320.finish();
}
if let Some(var_321) = &input.sidewalk {
#[allow(unused_mut)]
let mut object_322 = object.key("Sidewalk").start_object();
crate::json_ser::serialize_structure_crate_model_sidewalk_send_data_to_device(
&mut object_322,
var_321,
)?;
object_322.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_lo_ra_wan_start_fuota_task(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoRaWanStartFuotaTask,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_323) = &input.start_time {
object
.key("StartTime")
.date_time(var_323, aws_smithy_types::date_time::Format::DateTime)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_lo_ra_wan_multicast_session(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoRaWanMulticastSession,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_324) = &input.dl_dr {
object.key("DlDr").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_324).into()),
);
}
if let Some(var_325) = &input.dl_freq {
object.key("DlFreq").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_325).into()),
);
}
if let Some(var_326) = &input.session_start_time {
object
.key("SessionStartTime")
.date_time(var_326, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_327) = &input.session_timeout {
object.key("SessionTimeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_327).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_connection_status_resource_type_event_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConnectionStatusResourceTypeEventConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_328) = &input.lo_ra_wan {
#[allow(unused_mut)]
let mut object_329 = object.key("LoRaWAN").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_connection_status_resource_type_event_configuration(&mut object_329, var_328)?;
object_329.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_device_registration_state_resource_type_event_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeviceRegistrationStateResourceTypeEventConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_330) = &input.sidewalk {
#[allow(unused_mut)]
let mut object_331 = object.key("Sidewalk").start_object();
crate::json_ser::serialize_structure_crate_model_sidewalk_resource_type_event_configuration(&mut object_331, var_330)?;
object_331.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_join_resource_type_event_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JoinResourceTypeEventConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_332) = &input.lo_ra_wan {
#[allow(unused_mut)]
let mut object_333 = object.key("LoRaWAN").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_join_resource_type_event_configuration(&mut object_333, var_332)?;
object_333.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_message_delivery_status_resource_type_event_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MessageDeliveryStatusResourceTypeEventConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_334) = &input.sidewalk {
#[allow(unused_mut)]
let mut object_335 = object.key("Sidewalk").start_object();
crate::json_ser::serialize_structure_crate_model_sidewalk_resource_type_event_configuration(&mut object_335, var_334)?;
object_335.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_proximity_resource_type_event_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProximityResourceTypeEventConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_336) = &input.sidewalk {
#[allow(unused_mut)]
let mut object_337 = object.key("Sidewalk").start_object();
crate::json_ser::serialize_structure_crate_model_sidewalk_resource_type_event_configuration(&mut object_337, var_336)?;
object_337.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_wireless_device_log_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WirelessDeviceLogOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_338) = &input.r#type {
object.key("Type").string(var_338.as_str());
}
if let Some(var_339) = &input.log_level {
object.key("LogLevel").string(var_339.as_str());
}
if let Some(var_340) = &input.events {
let mut array_341 = object.key("Events").start_array();
for item_342 in var_340 {
{
#[allow(unused_mut)]
let mut object_343 = array_341.value().start_object();
crate::json_ser::serialize_structure_crate_model_wireless_device_event_log_option(
&mut object_343,
item_342,
)?;
object_343.finish();
}
}
array_341.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_wireless_gateway_log_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WirelessGatewayLogOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_344) = &input.r#type {
object.key("Type").string(var_344.as_str());
}
if let Some(var_345) = &input.log_level {
object.key("LogLevel").string(var_345.as_str());
}
if let Some(var_346) = &input.events {
let mut array_347 = object.key("Events").start_array();
for item_348 in var_346 {
{
#[allow(unused_mut)]
let mut object_349 = array_347.value().start_object();
crate::json_ser::serialize_structure_crate_model_wireless_gateway_event_log_option(
&mut object_349,
item_348,
)?;
object_349.finish();
}
}
array_347.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sidewalk_update_account(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SidewalkUpdateAccount,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_350) = &input.app_server_private_key {
object.key("AppServerPrivateKey").string(var_350.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_connection_status_event_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConnectionStatusEventConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_351) = &input.lo_ra_wan {
#[allow(unused_mut)]
let mut object_352 = object.key("LoRaWAN").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_connection_status_event_notification_configurations(&mut object_352, var_351)?;
object_352.finish();
}
if let Some(var_353) = &input.wireless_gateway_id_event_topic {
object
.key("WirelessGatewayIdEventTopic")
.string(var_353.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_device_registration_state_event_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeviceRegistrationStateEventConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_354) = &input.sidewalk {
#[allow(unused_mut)]
let mut object_355 = object.key("Sidewalk").start_object();
crate::json_ser::serialize_structure_crate_model_sidewalk_event_notification_configurations(&mut object_355, var_354)?;
object_355.finish();
}
if let Some(var_356) = &input.wireless_device_id_event_topic {
object
.key("WirelessDeviceIdEventTopic")
.string(var_356.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_join_event_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JoinEventConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_357) = &input.lo_ra_wan {
#[allow(unused_mut)]
let mut object_358 = object.key("LoRaWAN").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_join_event_notification_configurations(&mut object_358, var_357)?;
object_358.finish();
}
if let Some(var_359) = &input.wireless_device_id_event_topic {
object
.key("WirelessDeviceIdEventTopic")
.string(var_359.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_message_delivery_status_event_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MessageDeliveryStatusEventConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_360) = &input.sidewalk {
#[allow(unused_mut)]
let mut object_361 = object.key("Sidewalk").start_object();
crate::json_ser::serialize_structure_crate_model_sidewalk_event_notification_configurations(&mut object_361, var_360)?;
object_361.finish();
}
if let Some(var_362) = &input.wireless_device_id_event_topic {
object
.key("WirelessDeviceIdEventTopic")
.string(var_362.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_proximity_event_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProximityEventConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_363) = &input.sidewalk {
#[allow(unused_mut)]
let mut object_364 = object.key("Sidewalk").start_object();
crate::json_ser::serialize_structure_crate_model_sidewalk_event_notification_configurations(&mut object_364, var_363)?;
object_364.finish();
}
if let Some(var_365) = &input.wireless_device_id_event_topic {
object
.key("WirelessDeviceIdEventTopic")
.string(var_365.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lo_ra_wan_update_device(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoRaWanUpdateDevice,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_366) = &input.device_profile_id {
object.key("DeviceProfileId").string(var_366.as_str());
}
if let Some(var_367) = &input.service_profile_id {
object.key("ServiceProfileId").string(var_367.as_str());
}
if let Some(var_368) = &input.abp_v1_1 {
#[allow(unused_mut)]
let mut object_369 = object.key("AbpV1_1").start_object();
crate::json_ser::serialize_structure_crate_model_update_abp_v11(&mut object_369, var_368)?;
object_369.finish();
}
if let Some(var_370) = &input.abp_v1_0_x {
#[allow(unused_mut)]
let mut object_371 = object.key("AbpV1_0_x").start_object();
crate::json_ser::serialize_structure_crate_model_update_abp_v10_x(
&mut object_371,
var_370,
)?;
object_371.finish();
}
if let Some(var_372) = &input.f_ports {
#[allow(unused_mut)]
let mut object_373 = object.key("FPorts").start_object();
crate::json_ser::serialize_structure_crate_model_update_f_ports(&mut object_373, var_372)?;
object_373.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_otaa_v11(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OtaaV11,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_374) = &input.app_key {
object.key("AppKey").string(var_374.as_str());
}
if let Some(var_375) = &input.nwk_key {
object.key("NwkKey").string(var_375.as_str());
}
if let Some(var_376) = &input.join_eui {
object.key("JoinEui").string(var_376.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_otaa_v10_x(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OtaaV10X,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_377) = &input.app_key {
object.key("AppKey").string(var_377.as_str());
}
if let Some(var_378) = &input.app_eui {
object.key("AppEui").string(var_378.as_str());
}
if let Some(var_379) = &input.gen_app_key {
object.key("GenAppKey").string(var_379.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_abp_v11(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AbpV11,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_380) = &input.dev_addr {
object.key("DevAddr").string(var_380.as_str());
}
if let Some(var_381) = &input.session_keys {
#[allow(unused_mut)]
let mut object_382 = object.key("SessionKeys").start_object();
crate::json_ser::serialize_structure_crate_model_session_keys_abp_v11(
&mut object_382,
var_381,
)?;
object_382.finish();
}
if let Some(var_383) = &input.f_cnt_start {
object.key("FCntStart").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_383).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_abp_v10_x(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AbpV10X,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_384) = &input.dev_addr {
object.key("DevAddr").string(var_384.as_str());
}
if let Some(var_385) = &input.session_keys {
#[allow(unused_mut)]
let mut object_386 = object.key("SessionKeys").start_object();
crate::json_ser::serialize_structure_crate_model_session_keys_abp_v10_x(
&mut object_386,
var_385,
)?;
object_386.finish();
}
if let Some(var_387) = &input.f_cnt_start {
object.key("FCntStart").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_387).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_f_ports(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FPorts,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_388) = &input.fuota {
object.key("Fuota").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_388).into()),
);
}
if let Some(var_389) = &input.multicast {
object.key("Multicast").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_389).into()),
);
}
if let Some(var_390) = &input.clock_sync {
object.key("ClockSync").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_390).into()),
);
}
if let Some(var_391) = &input.positioning {
#[allow(unused_mut)]
let mut object_392 = object.key("Positioning").start_object();
crate::json_ser::serialize_structure_crate_model_positioning(&mut object_392, var_391)?;
object_392.finish();
}
if let Some(var_393) = &input.applications {
let mut array_394 = object.key("Applications").start_array();
for item_395 in var_393 {
{
#[allow(unused_mut)]
let mut object_396 = array_394.value().start_object();
crate::json_ser::serialize_structure_crate_model_application_config(
&mut object_396,
item_395,
)?;
object_396.finish();
}
}
array_394.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_beaconing(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Beaconing,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_397) = &input.data_rate {
object.key("DataRate").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_397).into()),
);
}
if let Some(var_398) = &input.frequencies {
let mut array_399 = object.key("Frequencies").start_array();
for item_400 in var_398 {
{
array_399.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_400).into()),
);
}
}
array_399.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_lo_ra_wan_update_gateway_task_create(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoRaWanUpdateGatewayTaskCreate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_401) = &input.update_signature {
object.key("UpdateSignature").string(var_401.as_str());
}
if let Some(var_402) = &input.sig_key_crc {
object.key("SigKeyCrc").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_402).into()),
);
}
if let Some(var_403) = &input.current_version {
#[allow(unused_mut)]
let mut object_404 = object.key("CurrentVersion").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_gateway_version(
&mut object_404,
var_403,
)?;
object_404.finish();
}
if let Some(var_405) = &input.update_version {
#[allow(unused_mut)]
let mut object_406 = object.key("UpdateVersion").start_object();
crate::json_ser::serialize_structure_crate_model_lo_ra_wan_gateway_version(
&mut object_406,
var_405,
)?;
object_406.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_gsm_obj(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GsmObj,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_407) = &input.mcc {
object.key("Mcc").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_407).into()),
);
}
if let Some(var_408) = &input.mnc {
object.key("Mnc").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_408).into()),
);
}
if let Some(var_409) = &input.lac {
object.key("Lac").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_409).into()),
);
}
if let Some(var_410) = &input.geran_cid {
object.key("GeranCid").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_410).into()),
);
}
if let Some(var_411) = &input.gsm_local_id {
#[allow(unused_mut)]
let mut object_412 = object.key("GsmLocalId").start_object();
crate::json_ser::serialize_structure_crate_model_gsm_local_id(&mut object_412, var_411)?;
object_412.finish();
}
if let Some(var_413) = &input.gsm_timing_advance {
object.key("GsmTimingAdvance").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_413).into()),
);
}
if let Some(var_414) = &input.rx_level {
object.key("RxLevel").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_414).into()),
);
}
if let Some(var_415) = &input.gsm_nmr {
let mut array_416 = object.key("GsmNmr").start_array();
for item_417 in var_415 {
{
#[allow(unused_mut)]
let mut object_418 = array_416.value().start_object();
crate::json_ser::serialize_structure_crate_model_gsm_nmr_obj(
&mut object_418,
item_417,
)?;
object_418.finish();
}
}
array_416.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_wcdma_obj(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WcdmaObj,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_419) = &input.mcc {
object.key("Mcc").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_419).into()),
);
}
if let Some(var_420) = &input.mnc {
object.key("Mnc").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_420).into()),
);
}
if let Some(var_421) = &input.lac {
object.key("Lac").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_421).into()),
);
}
if let Some(var_422) = &input.utran_cid {
object.key("UtranCid").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_422).into()),
);
}
if let Some(var_423) = &input.wcdma_local_id {
#[allow(unused_mut)]
let mut object_424 = object.key("WcdmaLocalId").start_object();
crate::json_ser::serialize_structure_crate_model_wcdma_local_id(&mut object_424, var_423)?;
object_424.finish();
}
if let Some(var_425) = &input.rscp {
object.key("Rscp").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_425).into()),
);
}
if let Some(var_426) = &input.path_loss {
object.key("PathLoss").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_426).into()),
);
}
if let Some(var_427) = &input.wcdma_nmr {
let mut array_428 = object.key("WcdmaNmr").start_array();
for item_429 in var_427 {
{
#[allow(unused_mut)]
let mut object_430 = array_428.value().start_object();
crate::json_ser::serialize_structure_crate_model_wcdma_nmr_obj(
&mut object_430,
item_429,
)?;
object_430.finish();
}
}
array_428.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tdscdma_obj(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TdscdmaObj,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_431) = &input.mcc {
object.key("Mcc").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_431).into()),
);
}
if let Some(var_432) = &input.mnc {
object.key("Mnc").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_432).into()),
);
}
if let Some(var_433) = &input.lac {
object.key("Lac").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_433).into()),
);
}
if let Some(var_434) = &input.utran_cid {
object.key("UtranCid").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_434).into()),
);
}
if let Some(var_435) = &input.tdscdma_local_id {
#[allow(unused_mut)]
let mut object_436 = object.key("TdscdmaLocalId").start_object();
crate::json_ser::serialize_structure_crate_model_tdscdma_local_id(
&mut object_436,
var_435,
)?;
object_436.finish();
}
if let Some(var_437) = &input.tdscdma_timing_advance {
object.key("TdscdmaTimingAdvance").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_437).into()),
);
}
if let Some(var_438) = &input.rscp {
object.key("Rscp").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_438).into()),
);
}
if let Some(var_439) = &input.path_loss {
object.key("PathLoss").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_439).into()),
);
}
if let Some(var_440) = &input.tdscdma_nmr {
let mut array_441 = object.key("TdscdmaNmr").start_array();
for item_442 in var_440 {
{
#[allow(unused_mut)]
let mut object_443 = array_441.value().start_object();
crate::json_ser::serialize_structure_crate_model_tdscdma_nmr_obj(
&mut object_443,
item_442,
)?;
object_443.finish();
}
}
array_441.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_lte_obj(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LteObj,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_444) = &input.mcc {
object.key("Mcc").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_444).into()),
);
}
if let Some(var_445) = &input.mnc {
object.key("Mnc").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_445).into()),
);
}
if let Some(var_446) = &input.eutran_cid {
object.key("EutranCid").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_446).into()),
);
}
if let Some(var_447) = &input.tac {
object.key("Tac").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_447).into()),
);
}
if let Some(var_448) = &input.lte_local_id {
#[allow(unused_mut)]
let mut object_449 = object.key("LteLocalId").start_object();
crate::json_ser::serialize_structure_crate_model_lte_local_id(&mut object_449, var_448)?;
object_449.finish();
}
if let Some(var_450) = &input.lte_timing_advance {
object.key("LteTimingAdvance").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_450).into()),
);
}
if let Some(var_451) = &input.rsrp {
object.key("Rsrp").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_451).into()),
);
}
if let Some(var_452) = &input.rsrq {
object.key("Rsrq").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_452).into()),
);
}
if input.nr_capable {
object.key("NrCapable").boolean(input.nr_capable);
}
if let Some(var_453) = &input.lte_nmr {
let mut array_454 = object.key("LteNmr").start_array();
for item_455 in var_453 {
{
#[allow(unused_mut)]
let mut object_456 = array_454.value().start_object();
crate::json_ser::serialize_structure_crate_model_lte_nmr_obj(
&mut object_456,
item_455,
)?;
object_456.finish();
}
}
array_454.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_cdma_obj(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CdmaObj,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_457) = &input.system_id {
object.key("SystemId").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_457).into()),
);
}
if let Some(var_458) = &input.network_id {
object.key("NetworkId").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_458).into()),
);
}
if let Some(var_459) = &input.base_station_id {
object.key("BaseStationId").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_459).into()),
);
}
if let Some(var_460) = &input.registration_zone {
object.key("RegistrationZone").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_460).into()),
);
}
if let Some(var_461) = &input.cdma_local_id {
#[allow(unused_mut)]
let mut object_462 = object.key("CdmaLocalId").start_object();
crate::json_ser::serialize_structure_crate_model_cdma_local_id(&mut object_462, var_461)?;
object_462.finish();
}
if let Some(var_463) = &input.pilot_power {
object.key("PilotPower").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_463).into()),
);
}
if let Some(var_464) = &input.base_lat {
object.key("BaseLat").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_464).into()),
);
}
if let Some(var_465) = &input.base_lng {
object.key("BaseLng").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_465).into()),
);
}
if let Some(var_466) = &input.cdma_nmr {
let mut array_467 = object.key("CdmaNmr").start_array();
for item_468 in var_466 {
{
#[allow(unused_mut)]
let mut object_469 = array_467.value().start_object();
crate::json_ser::serialize_structure_crate_model_cdma_nmr_obj(
&mut object_469,
item_468,
)?;
object_469.finish();
}
}
array_467.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_semtech_gnss_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SemtechGnssConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_470) = &input.status {
object.key("Status").string(var_470.as_str());
}
if let Some(var_471) = &input.fec {
object.key("Fec").string(var_471.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lo_ra_wan_multicast_metadata(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoRaWanMulticastMetadata,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_472) = &input.f_port {
object.key("FPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_472).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_lo_ra_wan_send_data_to_device(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoRaWanSendDataToDevice,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_473) = &input.f_port {
object.key("FPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_473).into()),
);
}
if let Some(var_474) = &input.participating_gateways {
#[allow(unused_mut)]
let mut object_475 = object.key("ParticipatingGateways").start_object();
crate::json_ser::serialize_structure_crate_model_participating_gateways(
&mut object_475,
var_474,
)?;
object_475.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sidewalk_send_data_to_device(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SidewalkSendDataToDevice,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_476) = &input.seq {
object.key("Seq").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_476).into()),
);
}
if let Some(var_477) = &input.message_type {
object.key("MessageType").string(var_477.as_str());
}
if let Some(var_478) = &input.ack_mode_retry_duration_secs {
object.key("AckModeRetryDurationSecs").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_478).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_lo_ra_wan_connection_status_resource_type_event_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoRaWanConnectionStatusResourceTypeEventConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_479) = &input.wireless_gateway_event_topic {
object
.key("WirelessGatewayEventTopic")
.string(var_479.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sidewalk_resource_type_event_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SidewalkResourceTypeEventConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_480) = &input.wireless_device_event_topic {
object
.key("WirelessDeviceEventTopic")
.string(var_480.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lo_ra_wan_join_resource_type_event_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoRaWanJoinResourceTypeEventConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_481) = &input.wireless_device_event_topic {
object
.key("WirelessDeviceEventTopic")
.string(var_481.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_wireless_device_event_log_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WirelessDeviceEventLogOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_482) = &input.event {
object.key("Event").string(var_482.as_str());
}
if let Some(var_483) = &input.log_level {
object.key("LogLevel").string(var_483.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_wireless_gateway_event_log_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WirelessGatewayEventLogOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_484) = &input.event {
object.key("Event").string(var_484.as_str());
}
if let Some(var_485) = &input.log_level {
object.key("LogLevel").string(var_485.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lo_ra_wan_connection_status_event_notification_configurations(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoRaWanConnectionStatusEventNotificationConfigurations,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_486) = &input.gateway_eui_event_topic {
object.key("GatewayEuiEventTopic").string(var_486.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sidewalk_event_notification_configurations(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SidewalkEventNotificationConfigurations,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_487) = &input.amazon_id_event_topic {
object.key("AmazonIdEventTopic").string(var_487.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lo_ra_wan_join_event_notification_configurations(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoRaWanJoinEventNotificationConfigurations,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_488) = &input.dev_eui_event_topic {
object.key("DevEuiEventTopic").string(var_488.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_abp_v11(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateAbpV11,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_489) = &input.f_cnt_start {
object.key("FCntStart").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_489).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_update_abp_v10_x(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateAbpV10X,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_490) = &input.f_cnt_start {
object.key("FCntStart").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_490).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_update_f_ports(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateFPorts,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_491) = &input.positioning {
#[allow(unused_mut)]
let mut object_492 = object.key("Positioning").start_object();
crate::json_ser::serialize_structure_crate_model_positioning(&mut object_492, var_491)?;
object_492.finish();
}
if let Some(var_493) = &input.applications {
let mut array_494 = object.key("Applications").start_array();
for item_495 in var_493 {
{
#[allow(unused_mut)]
let mut object_496 = array_494.value().start_object();
crate::json_ser::serialize_structure_crate_model_application_config(
&mut object_496,
item_495,
)?;
object_496.finish();
}
}
array_494.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_session_keys_abp_v11(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SessionKeysAbpV11,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_497) = &input.f_nwk_s_int_key {
object.key("FNwkSIntKey").string(var_497.as_str());
}
if let Some(var_498) = &input.s_nwk_s_int_key {
object.key("SNwkSIntKey").string(var_498.as_str());
}
if let Some(var_499) = &input.nwk_s_enc_key {
object.key("NwkSEncKey").string(var_499.as_str());
}
if let Some(var_500) = &input.app_s_key {
object.key("AppSKey").string(var_500.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_session_keys_abp_v10_x(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SessionKeysAbpV10X,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_501) = &input.nwk_s_key {
object.key("NwkSKey").string(var_501.as_str());
}
if let Some(var_502) = &input.app_s_key {
object.key("AppSKey").string(var_502.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_positioning(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Positioning,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_503) = &input.clock_sync {
object.key("ClockSync").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_503).into()),
);
}
if let Some(var_504) = &input.stream {
object.key("Stream").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_504).into()),
);
}
if let Some(var_505) = &input.gnss {
object.key("Gnss").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_505).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_application_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ApplicationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_506) = &input.f_port {
object.key("FPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_506).into()),
);
}
if let Some(var_507) = &input.r#type {
object.key("Type").string(var_507.as_str());
}
if let Some(var_508) = &input.destination_name {
object.key("DestinationName").string(var_508.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lo_ra_wan_gateway_version(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoRaWanGatewayVersion,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_509) = &input.package_version {
object.key("PackageVersion").string(var_509.as_str());
}
if let Some(var_510) = &input.model {
object.key("Model").string(var_510.as_str());
}
if let Some(var_511) = &input.station {
object.key("Station").string(var_511.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_gsm_local_id(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GsmLocalId,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_512) = &input.bsic {
object.key("Bsic").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_512).into()),
);
}
if let Some(var_513) = &input.bcch {
object.key("Bcch").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_513).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_gsm_nmr_obj(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GsmNmrObj,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_514) = &input.bsic {
object.key("Bsic").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_514).into()),
);
}
if let Some(var_515) = &input.bcch {
object.key("Bcch").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_515).into()),
);
}
if let Some(var_516) = &input.rx_level {
object.key("RxLevel").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_516).into()),
);
}
if let Some(var_517) = &input.global_identity {
#[allow(unused_mut)]
let mut object_518 = object.key("GlobalIdentity").start_object();
crate::json_ser::serialize_structure_crate_model_global_identity(&mut object_518, var_517)?;
object_518.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_wcdma_local_id(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WcdmaLocalId,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_519) = &input.uarfcndl {
object.key("Uarfcndl").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_519).into()),
);
}
if let Some(var_520) = &input.psc {
object.key("Psc").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_520).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_wcdma_nmr_obj(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WcdmaNmrObj,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_521) = &input.uarfcndl {
object.key("Uarfcndl").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_521).into()),
);
}
if let Some(var_522) = &input.psc {
object.key("Psc").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_522).into()),
);
}
if let Some(var_523) = &input.utran_cid {
object.key("UtranCid").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_523).into()),
);
}
if let Some(var_524) = &input.rscp {
object.key("Rscp").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_524).into()),
);
}
if let Some(var_525) = &input.path_loss {
object.key("PathLoss").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_525).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_tdscdma_local_id(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TdscdmaLocalId,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_526) = &input.uarfcn {
object.key("Uarfcn").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_526).into()),
);
}
if let Some(var_527) = &input.cell_params {
object.key("CellParams").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_527).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_tdscdma_nmr_obj(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TdscdmaNmrObj,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_528) = &input.uarfcn {
object.key("Uarfcn").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_528).into()),
);
}
if let Some(var_529) = &input.cell_params {
object.key("CellParams").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_529).into()),
);
}
if let Some(var_530) = &input.utran_cid {
object.key("UtranCid").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_530).into()),
);
}
if let Some(var_531) = &input.rscp {
object.key("Rscp").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_531).into()),
);
}
if let Some(var_532) = &input.path_loss {
object.key("PathLoss").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_532).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_lte_local_id(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LteLocalId,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_533) = &input.pci {
object.key("Pci").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_533).into()),
);
}
if let Some(var_534) = &input.earfcn {
object.key("Earfcn").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_534).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_lte_nmr_obj(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LteNmrObj,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_535) = &input.pci {
object.key("Pci").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_535).into()),
);
}
if let Some(var_536) = &input.earfcn {
object.key("Earfcn").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_536).into()),
);
}
if let Some(var_537) = &input.eutran_cid {
object.key("EutranCid").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_537).into()),
);
}
if let Some(var_538) = &input.rsrp {
object.key("Rsrp").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_538).into()),
);
}
if let Some(var_539) = &input.rsrq {
object.key("Rsrq").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_539).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_cdma_local_id(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CdmaLocalId,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_540) = &input.pn_offset {
object.key("PnOffset").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_540).into()),
);
}
if let Some(var_541) = &input.cdma_channel {
object.key("CdmaChannel").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_541).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_cdma_nmr_obj(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CdmaNmrObj,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_542) = &input.pn_offset {
object.key("PnOffset").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_542).into()),
);
}
if let Some(var_543) = &input.cdma_channel {
object.key("CdmaChannel").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_543).into()),
);
}
if let Some(var_544) = &input.pilot_power {
object.key("PilotPower").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_544).into()),
);
}
if let Some(var_545) = &input.base_station_id {
object.key("BaseStationId").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_545).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_participating_gateways(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParticipatingGateways,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_546) = &input.downlink_mode {
object.key("DownlinkMode").string(var_546.as_str());
}
if let Some(var_547) = &input.gateway_list {
let mut array_548 = object.key("GatewayList").start_array();
for item_549 in var_547 {
{
#[allow(unused_mut)]
let mut object_550 = array_548.value().start_object();
crate::json_ser::serialize_structure_crate_model_gateway_list_item(
&mut object_550,
item_549,
)?;
object_550.finish();
}
}
array_548.finish();
}
if let Some(var_551) = &input.transmission_interval {
object.key("TransmissionInterval").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_551).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_global_identity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GlobalIdentity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_552) = &input.lac {
object.key("Lac").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_552).into()),
);
}
if let Some(var_553) = &input.geran_cid {
object.key("GeranCid").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_553).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_gateway_list_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GatewayListItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_554) = &input.gateway_id {
object.key("GatewayId").string(var_554.as_str());
}
if let Some(var_555) = &input.downlink_frequency {
object.key("DownlinkFrequency").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_555).into()),
);
}
Ok(())
}