pub fn serialize_structure_crate_input_delete_recommendation_preferences_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteRecommendationPreferencesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_1) = &input.resource_type {
object.key("resourceType").string(var_1.as_str());
}
if let Some(var_2) = &input.scope {
let mut object_3 = object.key("scope").start_object();
crate::json_ser::serialize_structure_crate_model_scope(&mut object_3, var_2)?;
object_3.finish();
}
if let Some(var_4) = &input.recommendation_preference_names {
let mut array_5 = object.key("recommendationPreferenceNames").start_array();
for item_6 in var_4 {
{
array_5.value().string(item_6.as_str());
}
}
array_5.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_recommendation_export_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeRecommendationExportJobsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_7) = &input.job_ids {
let mut array_8 = object.key("jobIds").start_array();
for item_9 in var_7 {
{
array_8.value().string(item_9.as_str());
}
}
array_8.finish();
}
if let Some(var_10) = &input.filters {
let mut array_11 = object.key("filters").start_array();
for item_12 in var_10 {
{
let mut object_13 = array_11.value().start_object();
crate::json_ser::serialize_structure_crate_model_job_filter(
&mut object_13,
item_12,
)?;
object_13.finish();
}
}
array_11.finish();
}
if let Some(var_14) = &input.next_token {
object.key("nextToken").string(var_14.as_str());
}
if let Some(var_15) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_15).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_export_auto_scaling_group_recommendations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ExportAutoScalingGroupRecommendationsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_16) = &input.account_ids {
let mut array_17 = object.key("accountIds").start_array();
for item_18 in var_16 {
{
array_17.value().string(item_18.as_str());
}
}
array_17.finish();
}
if let Some(var_19) = &input.filters {
let mut array_20 = object.key("filters").start_array();
for item_21 in var_19 {
{
let mut object_22 = array_20.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_22, item_21)?;
object_22.finish();
}
}
array_20.finish();
}
if let Some(var_23) = &input.fields_to_export {
let mut array_24 = object.key("fieldsToExport").start_array();
for item_25 in var_23 {
{
array_24.value().string(item_25.as_str());
}
}
array_24.finish();
}
if let Some(var_26) = &input.s3_destination_config {
let mut object_27 = object.key("s3DestinationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_s3_destination_config(
&mut object_27,
var_26,
)?;
object_27.finish();
}
if let Some(var_28) = &input.file_format {
object.key("fileFormat").string(var_28.as_str());
}
if input.include_member_accounts {
object
.key("includeMemberAccounts")
.boolean(input.include_member_accounts);
}
if let Some(var_29) = &input.recommendation_preferences {
let mut object_30 = object.key("recommendationPreferences").start_object();
crate::json_ser::serialize_structure_crate_model_recommendation_preferences(
&mut object_30,
var_29,
)?;
object_30.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_export_ebs_volume_recommendations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ExportEbsVolumeRecommendationsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_31) = &input.account_ids {
let mut array_32 = object.key("accountIds").start_array();
for item_33 in var_31 {
{
array_32.value().string(item_33.as_str());
}
}
array_32.finish();
}
if let Some(var_34) = &input.filters {
let mut array_35 = object.key("filters").start_array();
for item_36 in var_34 {
{
let mut object_37 = array_35.value().start_object();
crate::json_ser::serialize_structure_crate_model_ebs_filter(
&mut object_37,
item_36,
)?;
object_37.finish();
}
}
array_35.finish();
}
if let Some(var_38) = &input.fields_to_export {
let mut array_39 = object.key("fieldsToExport").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.s3_destination_config {
let mut object_42 = object.key("s3DestinationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_s3_destination_config(
&mut object_42,
var_41,
)?;
object_42.finish();
}
if let Some(var_43) = &input.file_format {
object.key("fileFormat").string(var_43.as_str());
}
if input.include_member_accounts {
object
.key("includeMemberAccounts")
.boolean(input.include_member_accounts);
}
Ok(())
}
pub fn serialize_structure_crate_input_export_ec2_instance_recommendations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ExportEc2InstanceRecommendationsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_44) = &input.account_ids {
let mut array_45 = object.key("accountIds").start_array();
for item_46 in var_44 {
{
array_45.value().string(item_46.as_str());
}
}
array_45.finish();
}
if let Some(var_47) = &input.filters {
let mut array_48 = object.key("filters").start_array();
for item_49 in var_47 {
{
let mut object_50 = array_48.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_50, item_49)?;
object_50.finish();
}
}
array_48.finish();
}
if let Some(var_51) = &input.fields_to_export {
let mut array_52 = object.key("fieldsToExport").start_array();
for item_53 in var_51 {
{
array_52.value().string(item_53.as_str());
}
}
array_52.finish();
}
if let Some(var_54) = &input.s3_destination_config {
let mut object_55 = object.key("s3DestinationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_s3_destination_config(
&mut object_55,
var_54,
)?;
object_55.finish();
}
if let Some(var_56) = &input.file_format {
object.key("fileFormat").string(var_56.as_str());
}
if input.include_member_accounts {
object
.key("includeMemberAccounts")
.boolean(input.include_member_accounts);
}
if let Some(var_57) = &input.recommendation_preferences {
let mut object_58 = object.key("recommendationPreferences").start_object();
crate::json_ser::serialize_structure_crate_model_recommendation_preferences(
&mut object_58,
var_57,
)?;
object_58.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_export_lambda_function_recommendations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ExportLambdaFunctionRecommendationsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_59) = &input.account_ids {
let mut array_60 = object.key("accountIds").start_array();
for item_61 in var_59 {
{
array_60.value().string(item_61.as_str());
}
}
array_60.finish();
}
if let Some(var_62) = &input.filters {
let mut array_63 = object.key("filters").start_array();
for item_64 in var_62 {
{
let mut object_65 = array_63.value().start_object();
crate::json_ser::serialize_structure_crate_model_lambda_function_recommendation_filter(&mut object_65, item_64)?;
object_65.finish();
}
}
array_63.finish();
}
if let Some(var_66) = &input.fields_to_export {
let mut array_67 = object.key("fieldsToExport").start_array();
for item_68 in var_66 {
{
array_67.value().string(item_68.as_str());
}
}
array_67.finish();
}
if let Some(var_69) = &input.s3_destination_config {
let mut object_70 = object.key("s3DestinationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_s3_destination_config(
&mut object_70,
var_69,
)?;
object_70.finish();
}
if let Some(var_71) = &input.file_format {
object.key("fileFormat").string(var_71.as_str());
}
if input.include_member_accounts {
object
.key("includeMemberAccounts")
.boolean(input.include_member_accounts);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_auto_scaling_group_recommendations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAutoScalingGroupRecommendationsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_72) = &input.account_ids {
let mut array_73 = object.key("accountIds").start_array();
for item_74 in var_72 {
{
array_73.value().string(item_74.as_str());
}
}
array_73.finish();
}
if let Some(var_75) = &input.auto_scaling_group_arns {
let mut array_76 = object.key("autoScalingGroupArns").start_array();
for item_77 in var_75 {
{
array_76.value().string(item_77.as_str());
}
}
array_76.finish();
}
if let Some(var_78) = &input.next_token {
object.key("nextToken").string(var_78.as_str());
}
if let Some(var_79) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_79).into()),
);
}
if let Some(var_80) = &input.filters {
let mut array_81 = object.key("filters").start_array();
for item_82 in var_80 {
{
let mut object_83 = array_81.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_83, item_82)?;
object_83.finish();
}
}
array_81.finish();
}
if let Some(var_84) = &input.recommendation_preferences {
let mut object_85 = object.key("recommendationPreferences").start_object();
crate::json_ser::serialize_structure_crate_model_recommendation_preferences(
&mut object_85,
var_84,
)?;
object_85.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_ebs_volume_recommendations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetEbsVolumeRecommendationsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_86) = &input.volume_arns {
let mut array_87 = object.key("volumeArns").start_array();
for item_88 in var_86 {
{
array_87.value().string(item_88.as_str());
}
}
array_87.finish();
}
if let Some(var_89) = &input.next_token {
object.key("nextToken").string(var_89.as_str());
}
if let Some(var_90) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_90).into()),
);
}
if let Some(var_91) = &input.filters {
let mut array_92 = object.key("filters").start_array();
for item_93 in var_91 {
{
let mut object_94 = array_92.value().start_object();
crate::json_ser::serialize_structure_crate_model_ebs_filter(
&mut object_94,
item_93,
)?;
object_94.finish();
}
}
array_92.finish();
}
if let Some(var_95) = &input.account_ids {
let mut array_96 = object.key("accountIds").start_array();
for item_97 in var_95 {
{
array_96.value().string(item_97.as_str());
}
}
array_96.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_ec2_instance_recommendations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetEc2InstanceRecommendationsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_98) = &input.instance_arns {
let mut array_99 = object.key("instanceArns").start_array();
for item_100 in var_98 {
{
array_99.value().string(item_100.as_str());
}
}
array_99.finish();
}
if let Some(var_101) = &input.next_token {
object.key("nextToken").string(var_101.as_str());
}
if let Some(var_102) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_102).into()),
);
}
if let Some(var_103) = &input.filters {
let mut array_104 = object.key("filters").start_array();
for item_105 in var_103 {
{
let mut object_106 = array_104.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_106, item_105)?;
object_106.finish();
}
}
array_104.finish();
}
if let Some(var_107) = &input.account_ids {
let mut array_108 = object.key("accountIds").start_array();
for item_109 in var_107 {
{
array_108.value().string(item_109.as_str());
}
}
array_108.finish();
}
if let Some(var_110) = &input.recommendation_preferences {
let mut object_111 = object.key("recommendationPreferences").start_object();
crate::json_ser::serialize_structure_crate_model_recommendation_preferences(
&mut object_111,
var_110,
)?;
object_111.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_ec2_recommendation_projected_metrics_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetEc2RecommendationProjectedMetricsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_112) = &input.instance_arn {
object.key("instanceArn").string(var_112.as_str());
}
if let Some(var_113) = &input.stat {
object.key("stat").string(var_113.as_str());
}
{
object.key("period").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.period).into()),
);
}
if let Some(var_114) = &input.start_time {
object
.key("startTime")
.date_time(var_114, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_115) = &input.end_time {
object
.key("endTime")
.date_time(var_115, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_116) = &input.recommendation_preferences {
let mut object_117 = object.key("recommendationPreferences").start_object();
crate::json_ser::serialize_structure_crate_model_recommendation_preferences(
&mut object_117,
var_116,
)?;
object_117.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_effective_recommendation_preferences_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetEffectiveRecommendationPreferencesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_118) = &input.resource_arn {
object.key("resourceArn").string(var_118.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_enrollment_statuses_for_organization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetEnrollmentStatusesForOrganizationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_119) = &input.filters {
let mut array_120 = object.key("filters").start_array();
for item_121 in var_119 {
{
let mut object_122 = array_120.value().start_object();
crate::json_ser::serialize_structure_crate_model_enrollment_filter(
&mut object_122,
item_121,
)?;
object_122.finish();
}
}
array_120.finish();
}
if let Some(var_123) = &input.next_token {
object.key("nextToken").string(var_123.as_str());
}
if let Some(var_124) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_124).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_lambda_function_recommendations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetLambdaFunctionRecommendationsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_125) = &input.function_arns {
let mut array_126 = object.key("functionArns").start_array();
for item_127 in var_125 {
{
array_126.value().string(item_127.as_str());
}
}
array_126.finish();
}
if let Some(var_128) = &input.account_ids {
let mut array_129 = object.key("accountIds").start_array();
for item_130 in var_128 {
{
array_129.value().string(item_130.as_str());
}
}
array_129.finish();
}
if let Some(var_131) = &input.filters {
let mut array_132 = object.key("filters").start_array();
for item_133 in var_131 {
{
let mut object_134 = array_132.value().start_object();
crate::json_ser::serialize_structure_crate_model_lambda_function_recommendation_filter(&mut object_134, item_133)?;
object_134.finish();
}
}
array_132.finish();
}
if let Some(var_135) = &input.next_token {
object.key("nextToken").string(var_135.as_str());
}
if let Some(var_136) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_136).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_recommendation_preferences_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetRecommendationPreferencesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_137) = &input.resource_type {
object.key("resourceType").string(var_137.as_str());
}
if let Some(var_138) = &input.scope {
let mut object_139 = object.key("scope").start_object();
crate::json_ser::serialize_structure_crate_model_scope(&mut object_139, var_138)?;
object_139.finish();
}
if let Some(var_140) = &input.next_token {
object.key("nextToken").string(var_140.as_str());
}
if let Some(var_141) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_141).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_recommendation_summaries_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetRecommendationSummariesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_142) = &input.account_ids {
let mut array_143 = object.key("accountIds").start_array();
for item_144 in var_142 {
{
array_143.value().string(item_144.as_str());
}
}
array_143.finish();
}
if let Some(var_145) = &input.next_token {
object.key("nextToken").string(var_145.as_str());
}
if let Some(var_146) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_146).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_recommendation_preferences_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutRecommendationPreferencesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_147) = &input.resource_type {
object.key("resourceType").string(var_147.as_str());
}
if let Some(var_148) = &input.scope {
let mut object_149 = object.key("scope").start_object();
crate::json_ser::serialize_structure_crate_model_scope(&mut object_149, var_148)?;
object_149.finish();
}
if let Some(var_150) = &input.enhanced_infrastructure_metrics {
object
.key("enhancedInfrastructureMetrics")
.string(var_150.as_str());
}
if let Some(var_151) = &input.inferred_workload_types {
object.key("inferredWorkloadTypes").string(var_151.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_enrollment_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateEnrollmentStatusInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_152) = &input.status {
object.key("status").string(var_152.as_str());
}
if input.include_member_accounts {
object
.key("includeMemberAccounts")
.boolean(input.include_member_accounts);
}
Ok(())
}
pub fn serialize_structure_crate_model_scope(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Scope,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_153) = &input.name {
object.key("name").string(var_153.as_str());
}
if let Some(var_154) = &input.value {
object.key("value").string(var_154.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_job_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JobFilter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_155) = &input.name {
object.key("name").string(var_155.as_str());
}
if let Some(var_156) = &input.values {
let mut array_157 = object.key("values").start_array();
for item_158 in var_156 {
{
array_157.value().string(item_158.as_str());
}
}
array_157.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Filter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_159) = &input.name {
object.key("name").string(var_159.as_str());
}
if let Some(var_160) = &input.values {
let mut array_161 = object.key("values").start_array();
for item_162 in var_160 {
{
array_161.value().string(item_162.as_str());
}
}
array_161.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_destination_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3DestinationConfig,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_163) = &input.bucket {
object.key("bucket").string(var_163.as_str());
}
if let Some(var_164) = &input.key_prefix {
object.key("keyPrefix").string(var_164.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_recommendation_preferences(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RecommendationPreferences,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_165) = &input.cpu_vendor_architectures {
let mut array_166 = object.key("cpuVendorArchitectures").start_array();
for item_167 in var_165 {
{
array_166.value().string(item_167.as_str());
}
}
array_166.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_ebs_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EbsFilter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_168) = &input.name {
object.key("name").string(var_168.as_str());
}
if let Some(var_169) = &input.values {
let mut array_170 = object.key("values").start_array();
for item_171 in var_169 {
{
array_170.value().string(item_171.as_str());
}
}
array_170.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_lambda_function_recommendation_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LambdaFunctionRecommendationFilter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_172) = &input.name {
object.key("name").string(var_172.as_str());
}
if let Some(var_173) = &input.values {
let mut array_174 = object.key("values").start_array();
for item_175 in var_173 {
{
array_174.value().string(item_175.as_str());
}
}
array_174.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_enrollment_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EnrollmentFilter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_176) = &input.name {
object.key("name").string(var_176.as_str());
}
if let Some(var_177) = &input.values {
let mut array_178 = object.key("values").start_array();
for item_179 in var_177 {
{
array_178.value().string(item_179.as_str());
}
}
array_178.finish();
}
Ok(())
}