pub fn serialize_structure_crate_input_acknowledge_order_receipt_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AcknowledgeOrderReceiptInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.order_arn {
object.key("orderArn").string(var_1.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_activate_device_identifier_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ActivateDeviceIdentifierInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2) = &input.client_token {
object.key("clientToken").string(var_2.as_str());
}
if let Some(var_3) = &input.device_identifier_arn {
object.key("deviceIdentifierArn").string(var_3.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_activate_network_site_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ActivateNetworkSiteInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_4) = &input.client_token {
object.key("clientToken").string(var_4.as_str());
}
if let Some(var_5) = &input.network_site_arn {
object.key("networkSiteArn").string(var_5.as_str());
}
if let Some(var_6) = &input.shipping_address {
#[allow(unused_mut)]
let mut object_7 = object.key("shippingAddress").start_object();
crate::json_ser::serialize_structure_crate_model_address(&mut object_7, var_6)?;
object_7.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_configure_access_point_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ConfigureAccessPointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_8) = &input.access_point_arn {
object.key("accessPointArn").string(var_8.as_str());
}
if let Some(var_9) = &input.cpi_secret_key {
object.key("cpiSecretKey").string(var_9.as_str());
}
if let Some(var_10) = &input.cpi_user_id {
object.key("cpiUserId").string(var_10.as_str());
}
if let Some(var_11) = &input.cpi_user_password {
object.key("cpiUserPassword").string(var_11.as_str());
}
if let Some(var_12) = &input.cpi_username {
object.key("cpiUsername").string(var_12.as_str());
}
if let Some(var_13) = &input.position {
#[allow(unused_mut)]
let mut object_14 = object.key("position").start_object();
crate::json_ser::serialize_structure_crate_model_position(&mut object_14, var_13)?;
object_14.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_network_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateNetworkInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_15) = &input.client_token {
object.key("clientToken").string(var_15.as_str());
}
if let Some(var_16) = &input.description {
object.key("description").string(var_16.as_str());
}
if let Some(var_17) = &input.network_name {
object.key("networkName").string(var_17.as_str());
}
if let Some(var_18) = &input.tags {
#[allow(unused_mut)]
let mut object_19 = object.key("tags").start_object();
for (key_20, value_21) in var_18 {
{
object_19.key(key_20.as_str()).string(value_21.as_str());
}
}
object_19.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_network_site_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateNetworkSiteInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_22) = &input.availability_zone {
object.key("availabilityZone").string(var_22.as_str());
}
if let Some(var_23) = &input.availability_zone_id {
object.key("availabilityZoneId").string(var_23.as_str());
}
if let Some(var_24) = &input.client_token {
object.key("clientToken").string(var_24.as_str());
}
if let Some(var_25) = &input.description {
object.key("description").string(var_25.as_str());
}
if let Some(var_26) = &input.network_arn {
object.key("networkArn").string(var_26.as_str());
}
if let Some(var_27) = &input.network_site_name {
object.key("networkSiteName").string(var_27.as_str());
}
if let Some(var_28) = &input.pending_plan {
#[allow(unused_mut)]
let mut object_29 = object.key("pendingPlan").start_object();
crate::json_ser::serialize_structure_crate_model_site_plan(&mut object_29, var_28)?;
object_29.finish();
}
if let Some(var_30) = &input.tags {
#[allow(unused_mut)]
let mut object_31 = object.key("tags").start_object();
for (key_32, value_33) in var_30 {
{
object_31.key(key_32.as_str()).string(value_33.as_str());
}
}
object_31.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_deactivate_device_identifier_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeactivateDeviceIdentifierInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_34) = &input.client_token {
object.key("clientToken").string(var_34.as_str());
}
if let Some(var_35) = &input.device_identifier_arn {
object.key("deviceIdentifierArn").string(var_35.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_device_identifiers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDeviceIdentifiersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_36) = &input.filters {
#[allow(unused_mut)]
let mut object_37 = object.key("filters").start_object();
for (key_38, value_39) in var_36 {
{
let mut array_40 = object_37.key(key_38.as_str()).start_array();
for item_41 in value_39 {
{
array_40.value().string(item_41.as_str());
}
}
array_40.finish();
}
}
object_37.finish();
}
if let Some(var_42) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_42).into()),
);
}
if let Some(var_43) = &input.network_arn {
object.key("networkArn").string(var_43.as_str());
}
if let Some(var_44) = &input.start_token {
object.key("startToken").string(var_44.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_network_resources_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListNetworkResourcesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_45) = &input.filters {
#[allow(unused_mut)]
let mut object_46 = object.key("filters").start_object();
for (key_47, value_48) in var_45 {
{
let mut array_49 = object_46.key(key_47.as_str()).start_array();
for item_50 in value_48 {
{
array_49.value().string(item_50.as_str());
}
}
array_49.finish();
}
}
object_46.finish();
}
if let Some(var_51) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_51).into()),
);
}
if let Some(var_52) = &input.network_arn {
object.key("networkArn").string(var_52.as_str());
}
if let Some(var_53) = &input.start_token {
object.key("startToken").string(var_53.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_networks_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListNetworksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_54) = &input.filters {
#[allow(unused_mut)]
let mut object_55 = object.key("filters").start_object();
for (key_56, value_57) in var_54 {
{
let mut array_58 = object_55.key(key_56.as_str()).start_array();
for item_59 in value_57 {
{
array_58.value().string(item_59.as_str());
}
}
array_58.finish();
}
}
object_55.finish();
}
if let Some(var_60) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_60).into()),
);
}
if let Some(var_61) = &input.start_token {
object.key("startToken").string(var_61.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_network_sites_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListNetworkSitesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_62) = &input.filters {
#[allow(unused_mut)]
let mut object_63 = object.key("filters").start_object();
for (key_64, value_65) in var_62 {
{
let mut array_66 = object_63.key(key_64.as_str()).start_array();
for item_67 in value_65 {
{
array_66.value().string(item_67.as_str());
}
}
array_66.finish();
}
}
object_63.finish();
}
if let Some(var_68) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_68).into()),
);
}
if let Some(var_69) = &input.network_arn {
object.key("networkArn").string(var_69.as_str());
}
if let Some(var_70) = &input.start_token {
object.key("startToken").string(var_70.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_orders_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListOrdersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_71) = &input.filters {
#[allow(unused_mut)]
let mut object_72 = object.key("filters").start_object();
for (key_73, value_74) in var_71 {
{
let mut array_75 = object_72.key(key_73.as_str()).start_array();
for item_76 in value_74 {
{
array_75.value().string(item_76.as_str());
}
}
array_75.finish();
}
}
object_72.finish();
}
if let Some(var_77) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_77).into()),
);
}
if let Some(var_78) = &input.network_arn {
object.key("networkArn").string(var_78.as_str());
}
if let Some(var_79) = &input.start_token {
object.key("startToken").string(var_79.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.tags {
#[allow(unused_mut)]
let mut object_81 = object.key("tags").start_object();
for (key_82, value_83) in var_80 {
{
object_81.key(key_82.as_str()).string(value_83.as_str());
}
}
object_81.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_network_site_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateNetworkSiteInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_84) = &input.client_token {
object.key("clientToken").string(var_84.as_str());
}
if let Some(var_85) = &input.description {
object.key("description").string(var_85.as_str());
}
if let Some(var_86) = &input.network_site_arn {
object.key("networkSiteArn").string(var_86.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_network_site_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateNetworkSitePlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.client_token {
object.key("clientToken").string(var_87.as_str());
}
if let Some(var_88) = &input.network_site_arn {
object.key("networkSiteArn").string(var_88.as_str());
}
if let Some(var_89) = &input.pending_plan {
#[allow(unused_mut)]
let mut object_90 = object.key("pendingPlan").start_object();
crate::json_ser::serialize_structure_crate_model_site_plan(&mut object_90, var_89)?;
object_90.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_address(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Address,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_91) = &input.city {
object.key("city").string(var_91.as_str());
}
if let Some(var_92) = &input.company {
object.key("company").string(var_92.as_str());
}
if let Some(var_93) = &input.country {
object.key("country").string(var_93.as_str());
}
if let Some(var_94) = &input.name {
object.key("name").string(var_94.as_str());
}
if let Some(var_95) = &input.phone_number {
object.key("phoneNumber").string(var_95.as_str());
}
if let Some(var_96) = &input.postal_code {
object.key("postalCode").string(var_96.as_str());
}
if let Some(var_97) = &input.state_or_province {
object.key("stateOrProvince").string(var_97.as_str());
}
if let Some(var_98) = &input.street1 {
object.key("street1").string(var_98.as_str());
}
if let Some(var_99) = &input.street2 {
object.key("street2").string(var_99.as_str());
}
if let Some(var_100) = &input.street3 {
object.key("street3").string(var_100.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_position(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Position,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.latitude {
object.key("latitude").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_101).into()),
);
}
if let Some(var_102) = &input.longitude {
object.key("longitude").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_102).into()),
);
}
if let Some(var_103) = &input.elevation {
object.key("elevation").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_103).into()),
);
}
if let Some(var_104) = &input.elevation_unit {
object.key("elevationUnit").string(var_104.as_str());
}
if let Some(var_105) = &input.elevation_reference {
object.key("elevationReference").string(var_105.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_site_plan(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SitePlan,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_106) = &input.resource_definitions {
let mut array_107 = object.key("resourceDefinitions").start_array();
for item_108 in var_106 {
{
#[allow(unused_mut)]
let mut object_109 = array_107.value().start_object();
crate::json_ser::serialize_structure_crate_model_network_resource_definition(
&mut object_109,
item_108,
)?;
object_109.finish();
}
}
array_107.finish();
}
if let Some(var_110) = &input.options {
let mut array_111 = object.key("options").start_array();
for item_112 in var_110 {
{
#[allow(unused_mut)]
let mut object_113 = array_111.value().start_object();
crate::json_ser::serialize_structure_crate_model_name_value_pair(
&mut object_113,
item_112,
)?;
object_113.finish();
}
}
array_111.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_network_resource_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NetworkResourceDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_114) = &input.r#type {
object.key("type").string(var_114.as_str());
}
if let Some(var_115) = &input.options {
let mut array_116 = object.key("options").start_array();
for item_117 in var_115 {
{
#[allow(unused_mut)]
let mut object_118 = array_116.value().start_object();
crate::json_ser::serialize_structure_crate_model_name_value_pair(
&mut object_118,
item_117,
)?;
object_118.finish();
}
}
array_116.finish();
}
if let Some(var_119) = &input.count {
object.key("count").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_119).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_name_value_pair(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NameValuePair,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_120) = &input.name {
object.key("name").string(var_120.as_str());
}
if let Some(var_121) = &input.value {
object.key("value").string(var_121.as_str());
}
Ok(())
}