pub fn serialize_structure_crate_input_associate_configuration_items_to_application_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateConfigurationItemsToApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.application_configuration_id {
object
.key("applicationConfigurationId")
.string(var_1.as_str());
}
if let Some(var_2) = &input.configuration_ids {
let mut array_3 = object.key("configurationIds").start_array();
for item_4 in var_2 {
{
array_3.value().string(item_4.as_str());
}
}
array_3.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_delete_import_data_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDeleteImportDataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_5) = &input.import_task_ids {
let mut array_6 = object.key("importTaskIds").start_array();
for item_7 in var_5 {
{
array_6.value().string(item_7.as_str());
}
}
array_6.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_application_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_8) = &input.name {
object.key("name").string(var_8.as_str());
}
if let Some(var_9) = &input.description {
object.key("description").string(var_9.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_10) = &input.configuration_ids {
let mut array_11 = object.key("configurationIds").start_array();
for item_12 in var_10 {
{
array_11.value().string(item_12.as_str());
}
}
array_11.finish();
}
if let Some(var_13) = &input.tags {
let mut array_14 = object.key("tags").start_array();
for item_15 in var_13 {
{
#[allow(unused_mut)]
let mut object_16 = array_14.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_16, item_15)?;
object_16.finish();
}
}
array_14.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_applications_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteApplicationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_17) = &input.configuration_ids {
let mut array_18 = object.key("configurationIds").start_array();
for item_19 in var_17 {
{
array_18.value().string(item_19.as_str());
}
}
array_18.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_20) = &input.configuration_ids {
let mut array_21 = object.key("configurationIds").start_array();
for item_22 in var_20 {
{
array_21.value().string(item_22.as_str());
}
}
array_21.finish();
}
if let Some(var_23) = &input.tags {
let mut array_24 = object.key("tags").start_array();
for item_25 in var_23 {
{
#[allow(unused_mut)]
let mut object_26 = array_24.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_26, item_25)?;
object_26.finish();
}
}
array_24.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_agents_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAgentsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_27) = &input.agent_ids {
let mut array_28 = object.key("agentIds").start_array();
for item_29 in var_27 {
{
array_28.value().string(item_29.as_str());
}
}
array_28.finish();
}
if let Some(var_30) = &input.filters {
let mut array_31 = object.key("filters").start_array();
for item_32 in var_30 {
{
#[allow(unused_mut)]
let mut object_33 = array_31.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_33, item_32)?;
object_33.finish();
}
}
array_31.finish();
}
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_34) = &input.next_token {
object.key("nextToken").string(var_34.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_configurations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeConfigurationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.configuration_ids {
let mut array_36 = object.key("configurationIds").start_array();
for item_37 in var_35 {
{
array_36.value().string(item_37.as_str());
}
}
array_36.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_continuous_exports_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeContinuousExportsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_38) = &input.export_ids {
let mut array_39 = object.key("exportIds").start_array();
for item_40 in var_38 {
{
array_39.value().string(item_40.as_str());
}
}
array_39.finish();
}
if let Some(var_41) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_41).into()),
);
}
if let Some(var_42) = &input.next_token {
object.key("nextToken").string(var_42.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_export_configurations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeExportConfigurationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_43) = &input.export_ids {
let mut array_44 = object.key("exportIds").start_array();
for item_45 in var_43 {
{
array_44.value().string(item_45.as_str());
}
}
array_44.finish();
}
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_46) = &input.next_token {
object.key("nextToken").string(var_46.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_export_tasks_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeExportTasksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_47) = &input.export_ids {
let mut array_48 = object.key("exportIds").start_array();
for item_49 in var_47 {
{
array_48.value().string(item_49.as_str());
}
}
array_48.finish();
}
if let Some(var_50) = &input.filters {
let mut array_51 = object.key("filters").start_array();
for item_52 in var_50 {
{
#[allow(unused_mut)]
let mut object_53 = array_51.value().start_object();
crate::json_ser::serialize_structure_crate_model_export_filter(
&mut object_53,
item_52,
)?;
object_53.finish();
}
}
array_51.finish();
}
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_54) = &input.next_token {
object.key("nextToken").string(var_54.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_import_tasks_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeImportTasksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_55) = &input.filters {
let mut array_56 = object.key("filters").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_import_task_filter(
&mut object_58,
item_57,
)?;
object_58.finish();
}
}
array_56.finish();
}
if let Some(var_59) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_59).into()),
);
}
if let Some(var_60) = &input.next_token {
object.key("nextToken").string(var_60.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_61) = &input.filters {
let mut array_62 = object.key("filters").start_array();
for item_63 in var_61 {
{
#[allow(unused_mut)]
let mut object_64 = array_62.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_filter(
&mut object_64,
item_63,
)?;
object_64.finish();
}
}
array_62.finish();
}
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_65) = &input.next_token {
object.key("nextToken").string(var_65.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_configuration_items_from_application_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateConfigurationItemsFromApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.application_configuration_id {
object
.key("applicationConfigurationId")
.string(var_66.as_str());
}
if let Some(var_67) = &input.configuration_ids {
let mut array_68 = object.key("configurationIds").start_array();
for item_69 in var_67 {
{
array_68.value().string(item_69.as_str());
}
}
array_68.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_configurations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListConfigurationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.configuration_type {
object.key("configurationType").string(var_70.as_str());
}
if let Some(var_71) = &input.filters {
let mut array_72 = object.key("filters").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_filter(&mut object_74, item_73)?;
object_74.finish();
}
}
array_72.finish();
}
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_75) = &input.next_token {
object.key("nextToken").string(var_75.as_str());
}
if let Some(var_76) = &input.order_by {
let mut array_77 = object.key("orderBy").start_array();
for item_78 in var_76 {
{
#[allow(unused_mut)]
let mut object_79 = array_77.value().start_object();
crate::json_ser::serialize_structure_crate_model_order_by_element(
&mut object_79,
item_78,
)?;
object_79.finish();
}
}
array_77.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_server_neighbors_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListServerNeighborsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.configuration_id {
object.key("configurationId").string(var_80.as_str());
}
if input.port_information_needed {
object
.key("portInformationNeeded")
.boolean(input.port_information_needed);
}
if let Some(var_81) = &input.neighbor_configuration_ids {
let mut array_82 = object.key("neighborConfigurationIds").start_array();
for item_83 in var_81 {
{
array_82.value().string(item_83.as_str());
}
}
array_82.finish();
}
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_84) = &input.next_token {
object.key("nextToken").string(var_84.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_data_collection_by_agent_ids_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartDataCollectionByAgentIdsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.agent_ids {
let mut array_86 = object.key("agentIds").start_array();
for item_87 in var_85 {
{
array_86.value().string(item_87.as_str());
}
}
array_86.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_export_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartExportTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_88) = &input.export_data_format {
let mut array_89 = object.key("exportDataFormat").start_array();
for item_90 in var_88 {
{
array_89.value().string(item_90.as_str());
}
}
array_89.finish();
}
if let Some(var_91) = &input.filters {
let mut array_92 = object.key("filters").start_array();
for item_93 in var_91 {
{
#[allow(unused_mut)]
let mut object_94 = array_92.value().start_object();
crate::json_ser::serialize_structure_crate_model_export_filter(
&mut object_94,
item_93,
)?;
object_94.finish();
}
}
array_92.finish();
}
if let Some(var_95) = &input.start_time {
object
.key("startTime")
.date_time(var_95, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_96) = &input.end_time {
object
.key("endTime")
.date_time(var_96, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_input_start_import_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartImportTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
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.import_url {
object.key("importUrl").string(var_99.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_continuous_export_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopContinuousExportInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_100) = &input.export_id {
object.key("exportId").string(var_100.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_data_collection_by_agent_ids_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopDataCollectionByAgentIdsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.agent_ids {
let mut array_102 = object.key("agentIds").start_array();
for item_103 in var_101 {
{
array_102.value().string(item_103.as_str());
}
}
array_102.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_application_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_104) = &input.configuration_id {
object.key("configurationId").string(var_104.as_str());
}
if let Some(var_105) = &input.name {
object.key("name").string(var_105.as_str());
}
if let Some(var_106) = &input.description {
object.key("description").string(var_106.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_107) = &input.key {
object.key("key").string(var_107.as_str());
}
if let Some(var_108) = &input.value {
object.key("value").string(var_108.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Filter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_109) = &input.name {
object.key("name").string(var_109.as_str());
}
if let Some(var_110) = &input.values {
let mut array_111 = object.key("values").start_array();
for item_112 in var_110 {
{
array_111.value().string(item_112.as_str());
}
}
array_111.finish();
}
if let Some(var_113) = &input.condition {
object.key("condition").string(var_113.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_export_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExportFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_114) = &input.name {
object.key("name").string(var_114.as_str());
}
if let Some(var_115) = &input.values {
let mut array_116 = object.key("values").start_array();
for item_117 in var_115 {
{
array_116.value().string(item_117.as_str());
}
}
array_116.finish();
}
if let Some(var_118) = &input.condition {
object.key("condition").string(var_118.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_import_task_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImportTaskFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_119) = &input.name {
object.key("name").string(var_119.as_str());
}
if let Some(var_120) = &input.values {
let mut array_121 = object.key("values").start_array();
for item_122 in var_120 {
{
array_121.value().string(item_122.as_str());
}
}
array_121.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tag_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TagFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_123) = &input.name {
object.key("name").string(var_123.as_str());
}
if let Some(var_124) = &input.values {
let mut array_125 = object.key("values").start_array();
for item_126 in var_124 {
{
array_125.value().string(item_126.as_str());
}
}
array_125.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_order_by_element(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OrderByElement,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_127) = &input.field_name {
object.key("fieldName").string(var_127.as_str());
}
if let Some(var_128) = &input.sort_order {
object.key("sortOrder").string(var_128.as_str());
}
Ok(())
}