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::error::SerializationError> {
if let Some(var_1) = &input.resource_type {
object.key("resourceType").string(var_1.as_str());
}
if let Some(var_2) = &input.scope {
#[allow(unused_mut)]
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::error::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 {
{
#[allow(unused_mut)]
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::error::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 {
{
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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::error::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 {
{
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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::error::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 {
{
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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_ecs_service_recommendations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ExportEcsServiceRecommendationsInput,
) -> Result<(), aws_smithy_http::operation::error::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 {
{
#[allow(unused_mut)]
let mut object_65 = array_63.value().start_object();
crate::json_ser::serialize_structure_crate_model_ecs_service_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 {
#[allow(unused_mut)]
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_export_lambda_function_recommendations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ExportLambdaFunctionRecommendationsInput,
) -> Result<(), aws_smithy_http::operation::error::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.filters {
let mut array_76 = object.key("filters").start_array();
for item_77 in var_75 {
{
#[allow(unused_mut)]
let mut object_78 = array_76.value().start_object();
crate::json_ser::serialize_structure_crate_model_lambda_function_recommendation_filter(&mut object_78, item_77)?;
object_78.finish();
}
}
array_76.finish();
}
if let Some(var_79) = &input.fields_to_export {
let mut array_80 = object.key("fieldsToExport").start_array();
for item_81 in var_79 {
{
array_80.value().string(item_81.as_str());
}
}
array_80.finish();
}
if let Some(var_82) = &input.s3_destination_config {
#[allow(unused_mut)]
let mut object_83 = object.key("s3DestinationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_s3_destination_config(
&mut object_83,
var_82,
)?;
object_83.finish();
}
if let Some(var_84) = &input.file_format {
object.key("fileFormat").string(var_84.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::error::SerializationError> {
if let Some(var_85) = &input.account_ids {
let mut array_86 = object.key("accountIds").start_array();
for item_87 in var_85 {
{
array_86.value().string(item_87.as_str());
}
}
array_86.finish();
}
if let Some(var_88) = &input.auto_scaling_group_arns {
let mut array_89 = object.key("autoScalingGroupArns").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.next_token {
object.key("nextToken").string(var_91.as_str());
}
if let Some(var_92) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_92).into()),
);
}
if let Some(var_93) = &input.filters {
let mut array_94 = object.key("filters").start_array();
for item_95 in var_93 {
{
#[allow(unused_mut)]
let mut object_96 = array_94.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_96, item_95)?;
object_96.finish();
}
}
array_94.finish();
}
if let Some(var_97) = &input.recommendation_preferences {
#[allow(unused_mut)]
let mut object_98 = object.key("recommendationPreferences").start_object();
crate::json_ser::serialize_structure_crate_model_recommendation_preferences(
&mut object_98,
var_97,
)?;
object_98.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::error::SerializationError> {
if let Some(var_99) = &input.volume_arns {
let mut array_100 = object.key("volumeArns").start_array();
for item_101 in var_99 {
{
array_100.value().string(item_101.as_str());
}
}
array_100.finish();
}
if let Some(var_102) = &input.next_token {
object.key("nextToken").string(var_102.as_str());
}
if let Some(var_103) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_103).into()),
);
}
if let Some(var_104) = &input.filters {
let mut array_105 = object.key("filters").start_array();
for item_106 in var_104 {
{
#[allow(unused_mut)]
let mut object_107 = array_105.value().start_object();
crate::json_ser::serialize_structure_crate_model_ebs_filter(
&mut object_107,
item_106,
)?;
object_107.finish();
}
}
array_105.finish();
}
if let Some(var_108) = &input.account_ids {
let mut array_109 = object.key("accountIds").start_array();
for item_110 in var_108 {
{
array_109.value().string(item_110.as_str());
}
}
array_109.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::error::SerializationError> {
if let Some(var_111) = &input.instance_arns {
let mut array_112 = object.key("instanceArns").start_array();
for item_113 in var_111 {
{
array_112.value().string(item_113.as_str());
}
}
array_112.finish();
}
if let Some(var_114) = &input.next_token {
object.key("nextToken").string(var_114.as_str());
}
if let Some(var_115) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_115).into()),
);
}
if let Some(var_116) = &input.filters {
let mut array_117 = object.key("filters").start_array();
for item_118 in var_116 {
{
#[allow(unused_mut)]
let mut object_119 = array_117.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_119, item_118)?;
object_119.finish();
}
}
array_117.finish();
}
if let Some(var_120) = &input.account_ids {
let mut array_121 = object.key("accountIds").start_array();
for item_122 in var_120 {
{
array_121.value().string(item_122.as_str());
}
}
array_121.finish();
}
if let Some(var_123) = &input.recommendation_preferences {
#[allow(unused_mut)]
let mut object_124 = object.key("recommendationPreferences").start_object();
crate::json_ser::serialize_structure_crate_model_recommendation_preferences(
&mut object_124,
var_123,
)?;
object_124.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::error::SerializationError> {
if let Some(var_125) = &input.instance_arn {
object.key("instanceArn").string(var_125.as_str());
}
if let Some(var_126) = &input.stat {
object.key("stat").string(var_126.as_str());
}
{
object.key("period").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.period).into()),
);
}
if let Some(var_127) = &input.start_time {
object
.key("startTime")
.date_time(var_127, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_128) = &input.end_time {
object
.key("endTime")
.date_time(var_128, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_129) = &input.recommendation_preferences {
#[allow(unused_mut)]
let mut object_130 = object.key("recommendationPreferences").start_object();
crate::json_ser::serialize_structure_crate_model_recommendation_preferences(
&mut object_130,
var_129,
)?;
object_130.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_ecs_service_recommendation_projected_metrics_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetEcsServiceRecommendationProjectedMetricsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_131) = &input.service_arn {
object.key("serviceArn").string(var_131.as_str());
}
if let Some(var_132) = &input.stat {
object.key("stat").string(var_132.as_str());
}
{
object.key("period").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.period).into()),
);
}
if let Some(var_133) = &input.start_time {
object
.key("startTime")
.date_time(var_133, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_134) = &input.end_time {
object
.key("endTime")
.date_time(var_134, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_input_get_ecs_service_recommendations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetEcsServiceRecommendationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_135) = &input.service_arns {
let mut array_136 = object.key("serviceArns").start_array();
for item_137 in var_135 {
{
array_136.value().string(item_137.as_str());
}
}
array_136.finish();
}
if let Some(var_138) = &input.next_token {
object.key("nextToken").string(var_138.as_str());
}
if let Some(var_139) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_139).into()),
);
}
if let Some(var_140) = &input.filters {
let mut array_141 = object.key("filters").start_array();
for item_142 in var_140 {
{
#[allow(unused_mut)]
let mut object_143 = array_141.value().start_object();
crate::json_ser::serialize_structure_crate_model_ecs_service_recommendation_filter(
&mut object_143,
item_142,
)?;
object_143.finish();
}
}
array_141.finish();
}
if let Some(var_144) = &input.account_ids {
let mut array_145 = object.key("accountIds").start_array();
for item_146 in var_144 {
{
array_145.value().string(item_146.as_str());
}
}
array_145.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::error::SerializationError> {
if let Some(var_147) = &input.resource_arn {
object.key("resourceArn").string(var_147.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::error::SerializationError> {
if let Some(var_148) = &input.filters {
let mut array_149 = object.key("filters").start_array();
for item_150 in var_148 {
{
#[allow(unused_mut)]
let mut object_151 = array_149.value().start_object();
crate::json_ser::serialize_structure_crate_model_enrollment_filter(
&mut object_151,
item_150,
)?;
object_151.finish();
}
}
array_149.finish();
}
if let Some(var_152) = &input.next_token {
object.key("nextToken").string(var_152.as_str());
}
if let Some(var_153) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_153).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::error::SerializationError> {
if let Some(var_154) = &input.function_arns {
let mut array_155 = object.key("functionArns").start_array();
for item_156 in var_154 {
{
array_155.value().string(item_156.as_str());
}
}
array_155.finish();
}
if let Some(var_157) = &input.account_ids {
let mut array_158 = object.key("accountIds").start_array();
for item_159 in var_157 {
{
array_158.value().string(item_159.as_str());
}
}
array_158.finish();
}
if let Some(var_160) = &input.filters {
let mut array_161 = object.key("filters").start_array();
for item_162 in var_160 {
{
#[allow(unused_mut)]
let mut object_163 = array_161.value().start_object();
crate::json_ser::serialize_structure_crate_model_lambda_function_recommendation_filter(&mut object_163, item_162)?;
object_163.finish();
}
}
array_161.finish();
}
if let Some(var_164) = &input.next_token {
object.key("nextToken").string(var_164.as_str());
}
if let Some(var_165) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_165).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::error::SerializationError> {
if let Some(var_166) = &input.resource_type {
object.key("resourceType").string(var_166.as_str());
}
if let Some(var_167) = &input.scope {
#[allow(unused_mut)]
let mut object_168 = object.key("scope").start_object();
crate::json_ser::serialize_structure_crate_model_scope(&mut object_168, var_167)?;
object_168.finish();
}
if let Some(var_169) = &input.next_token {
object.key("nextToken").string(var_169.as_str());
}
if let Some(var_170) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_170).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::error::SerializationError> {
if let Some(var_171) = &input.account_ids {
let mut array_172 = object.key("accountIds").start_array();
for item_173 in var_171 {
{
array_172.value().string(item_173.as_str());
}
}
array_172.finish();
}
if let Some(var_174) = &input.next_token {
object.key("nextToken").string(var_174.as_str());
}
if let Some(var_175) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_175).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::error::SerializationError> {
if let Some(var_176) = &input.resource_type {
object.key("resourceType").string(var_176.as_str());
}
if let Some(var_177) = &input.scope {
#[allow(unused_mut)]
let mut object_178 = object.key("scope").start_object();
crate::json_ser::serialize_structure_crate_model_scope(&mut object_178, var_177)?;
object_178.finish();
}
if let Some(var_179) = &input.enhanced_infrastructure_metrics {
object
.key("enhancedInfrastructureMetrics")
.string(var_179.as_str());
}
if let Some(var_180) = &input.inferred_workload_types {
object.key("inferredWorkloadTypes").string(var_180.as_str());
}
if let Some(var_181) = &input.external_metrics_preference {
#[allow(unused_mut)]
let mut object_182 = object.key("externalMetricsPreference").start_object();
crate::json_ser::serialize_structure_crate_model_external_metrics_preference(
&mut object_182,
var_181,
)?;
object_182.finish();
}
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::error::SerializationError> {
if let Some(var_183) = &input.status {
object.key("status").string(var_183.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::error::SerializationError> {
if let Some(var_184) = &input.name {
object.key("name").string(var_184.as_str());
}
if let Some(var_185) = &input.value {
object.key("value").string(var_185.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::error::SerializationError> {
if let Some(var_186) = &input.name {
object.key("name").string(var_186.as_str());
}
if let Some(var_187) = &input.values {
let mut array_188 = object.key("values").start_array();
for item_189 in var_187 {
{
array_188.value().string(item_189.as_str());
}
}
array_188.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::error::SerializationError> {
if let Some(var_190) = &input.name {
object.key("name").string(var_190.as_str());
}
if let Some(var_191) = &input.values {
let mut array_192 = object.key("values").start_array();
for item_193 in var_191 {
{
array_192.value().string(item_193.as_str());
}
}
array_192.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::error::SerializationError> {
if let Some(var_194) = &input.bucket {
object.key("bucket").string(var_194.as_str());
}
if let Some(var_195) = &input.key_prefix {
object.key("keyPrefix").string(var_195.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::error::SerializationError> {
if let Some(var_196) = &input.cpu_vendor_architectures {
let mut array_197 = object.key("cpuVendorArchitectures").start_array();
for item_198 in var_196 {
{
array_197.value().string(item_198.as_str());
}
}
array_197.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::error::SerializationError> {
if let Some(var_199) = &input.name {
object.key("name").string(var_199.as_str());
}
if let Some(var_200) = &input.values {
let mut array_201 = object.key("values").start_array();
for item_202 in var_200 {
{
array_201.value().string(item_202.as_str());
}
}
array_201.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_ecs_service_recommendation_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EcsServiceRecommendationFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_203) = &input.name {
object.key("name").string(var_203.as_str());
}
if let Some(var_204) = &input.values {
let mut array_205 = object.key("values").start_array();
for item_206 in var_204 {
{
array_205.value().string(item_206.as_str());
}
}
array_205.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::error::SerializationError> {
if let Some(var_207) = &input.name {
object.key("name").string(var_207.as_str());
}
if let Some(var_208) = &input.values {
let mut array_209 = object.key("values").start_array();
for item_210 in var_208 {
{
array_209.value().string(item_210.as_str());
}
}
array_209.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::error::SerializationError> {
if let Some(var_211) = &input.name {
object.key("name").string(var_211.as_str());
}
if let Some(var_212) = &input.values {
let mut array_213 = object.key("values").start_array();
for item_214 in var_212 {
{
array_213.value().string(item_214.as_str());
}
}
array_213.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_external_metrics_preference(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExternalMetricsPreference,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_215) = &input.source {
object.key("source").string(var_215.as_str());
}
Ok(())
}