pub fn serialize_structure_crate_input_create_anomaly_monitor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAnomalyMonitorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.anomaly_monitor {
#[allow(unused_mut)]
let mut object_2 = object.key("AnomalyMonitor").start_object();
crate::json_ser::serialize_structure_crate_model_anomaly_monitor(&mut object_2, var_1)?;
object_2.finish();
}
if let Some(var_3) = &input.resource_tags {
let mut array_4 = object.key("ResourceTags").start_array();
for item_5 in var_3 {
{
#[allow(unused_mut)]
let mut object_6 = array_4.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_tag(
&mut object_6,
item_5,
)?;
object_6.finish();
}
}
array_4.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_anomaly_subscription_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAnomalySubscriptionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_7) = &input.anomaly_subscription {
#[allow(unused_mut)]
let mut object_8 = object.key("AnomalySubscription").start_object();
crate::json_ser::serialize_structure_crate_model_anomaly_subscription(
&mut object_8,
var_7,
)?;
object_8.finish();
}
if let Some(var_9) = &input.resource_tags {
let mut array_10 = object.key("ResourceTags").start_array();
for item_11 in var_9 {
{
#[allow(unused_mut)]
let mut object_12 = array_10.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_tag(
&mut object_12,
item_11,
)?;
object_12.finish();
}
}
array_10.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_cost_category_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCostCategoryDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_13) = &input.name {
object.key("Name").string(var_13.as_str());
}
if let Some(var_14) = &input.effective_start {
object.key("EffectiveStart").string(var_14.as_str());
}
if let Some(var_15) = &input.rule_version {
object.key("RuleVersion").string(var_15.as_str());
}
if let Some(var_16) = &input.rules {
let mut array_17 = object.key("Rules").start_array();
for item_18 in var_16 {
{
#[allow(unused_mut)]
let mut object_19 = array_17.value().start_object();
crate::json_ser::serialize_structure_crate_model_cost_category_rule(
&mut object_19,
item_18,
)?;
object_19.finish();
}
}
array_17.finish();
}
if let Some(var_20) = &input.default_value {
object.key("DefaultValue").string(var_20.as_str());
}
if let Some(var_21) = &input.split_charge_rules {
let mut array_22 = object.key("SplitChargeRules").start_array();
for item_23 in var_21 {
{
#[allow(unused_mut)]
let mut object_24 = array_22.value().start_object();
crate::json_ser::serialize_structure_crate_model_cost_category_split_charge_rule(
&mut object_24,
item_23,
)?;
object_24.finish();
}
}
array_22.finish();
}
if let Some(var_25) = &input.resource_tags {
let mut array_26 = object.key("ResourceTags").start_array();
for item_27 in var_25 {
{
#[allow(unused_mut)]
let mut object_28 = array_26.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_tag(
&mut object_28,
item_27,
)?;
object_28.finish();
}
}
array_26.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_anomaly_monitor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAnomalyMonitorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.monitor_arn {
object.key("MonitorArn").string(var_29.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_anomaly_subscription_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAnomalySubscriptionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_30) = &input.subscription_arn {
object.key("SubscriptionArn").string(var_30.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_cost_category_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteCostCategoryDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.cost_category_arn {
object.key("CostCategoryArn").string(var_31.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_cost_category_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeCostCategoryDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_32) = &input.cost_category_arn {
object.key("CostCategoryArn").string(var_32.as_str());
}
if let Some(var_33) = &input.effective_on {
object.key("EffectiveOn").string(var_33.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_anomalies_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAnomaliesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_34) = &input.monitor_arn {
object.key("MonitorArn").string(var_34.as_str());
}
if let Some(var_35) = &input.date_interval {
#[allow(unused_mut)]
let mut object_36 = object.key("DateInterval").start_object();
crate::json_ser::serialize_structure_crate_model_anomaly_date_interval(
&mut object_36,
var_35,
)?;
object_36.finish();
}
if let Some(var_37) = &input.feedback {
object.key("Feedback").string(var_37.as_str());
}
if let Some(var_38) = &input.total_impact {
#[allow(unused_mut)]
let mut object_39 = object.key("TotalImpact").start_object();
crate::json_ser::serialize_structure_crate_model_total_impact_filter(
&mut object_39,
var_38,
)?;
object_39.finish();
}
if let Some(var_40) = &input.next_page_token {
object.key("NextPageToken").string(var_40.as_str());
}
if let Some(var_41) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_41).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_anomaly_monitors_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAnomalyMonitorsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_42) = &input.monitor_arn_list {
let mut array_43 = object.key("MonitorArnList").start_array();
for item_44 in var_42 {
{
array_43.value().string(item_44.as_str());
}
}
array_43.finish();
}
if let Some(var_45) = &input.next_page_token {
object.key("NextPageToken").string(var_45.as_str());
}
if let Some(var_46) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_46).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_anomaly_subscriptions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAnomalySubscriptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_47) = &input.subscription_arn_list {
let mut array_48 = object.key("SubscriptionArnList").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.monitor_arn {
object.key("MonitorArn").string(var_50.as_str());
}
if let Some(var_51) = &input.next_page_token {
object.key("NextPageToken").string(var_51.as_str());
}
if let Some(var_52) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_52).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_cost_and_usage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetCostAndUsageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_53) = &input.time_period {
#[allow(unused_mut)]
let mut object_54 = object.key("TimePeriod").start_object();
crate::json_ser::serialize_structure_crate_model_date_interval(&mut object_54, var_53)?;
object_54.finish();
}
if let Some(var_55) = &input.granularity {
object.key("Granularity").string(var_55.as_str());
}
if let Some(var_56) = &input.filter {
#[allow(unused_mut)]
let mut object_57 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_57, var_56)?;
object_57.finish();
}
if let Some(var_58) = &input.metrics {
let mut array_59 = object.key("Metrics").start_array();
for item_60 in var_58 {
{
array_59.value().string(item_60.as_str());
}
}
array_59.finish();
}
if let Some(var_61) = &input.group_by {
let mut array_62 = object.key("GroupBy").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_group_definition(
&mut object_64,
item_63,
)?;
object_64.finish();
}
}
array_62.finish();
}
if let Some(var_65) = &input.next_page_token {
object.key("NextPageToken").string(var_65.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_cost_and_usage_with_resources_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetCostAndUsageWithResourcesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.time_period {
#[allow(unused_mut)]
let mut object_67 = object.key("TimePeriod").start_object();
crate::json_ser::serialize_structure_crate_model_date_interval(&mut object_67, var_66)?;
object_67.finish();
}
if let Some(var_68) = &input.granularity {
object.key("Granularity").string(var_68.as_str());
}
if let Some(var_69) = &input.filter {
#[allow(unused_mut)]
let mut object_70 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_70, var_69)?;
object_70.finish();
}
if let Some(var_71) = &input.metrics {
let mut array_72 = object.key("Metrics").start_array();
for item_73 in var_71 {
{
array_72.value().string(item_73.as_str());
}
}
array_72.finish();
}
if let Some(var_74) = &input.group_by {
let mut array_75 = object.key("GroupBy").start_array();
for item_76 in var_74 {
{
#[allow(unused_mut)]
let mut object_77 = array_75.value().start_object();
crate::json_ser::serialize_structure_crate_model_group_definition(
&mut object_77,
item_76,
)?;
object_77.finish();
}
}
array_75.finish();
}
if let Some(var_78) = &input.next_page_token {
object.key("NextPageToken").string(var_78.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_cost_categories_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetCostCategoriesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_79) = &input.search_string {
object.key("SearchString").string(var_79.as_str());
}
if let Some(var_80) = &input.time_period {
#[allow(unused_mut)]
let mut object_81 = object.key("TimePeriod").start_object();
crate::json_ser::serialize_structure_crate_model_date_interval(&mut object_81, var_80)?;
object_81.finish();
}
if let Some(var_82) = &input.cost_category_name {
object.key("CostCategoryName").string(var_82.as_str());
}
if let Some(var_83) = &input.filter {
#[allow(unused_mut)]
let mut object_84 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_84, var_83)?;
object_84.finish();
}
if let Some(var_85) = &input.sort_by {
let mut array_86 = object.key("SortBy").start_array();
for item_87 in var_85 {
{
#[allow(unused_mut)]
let mut object_88 = array_86.value().start_object();
crate::json_ser::serialize_structure_crate_model_sort_definition(
&mut object_88,
item_87,
)?;
object_88.finish();
}
}
array_86.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_89) = &input.next_page_token {
object.key("NextPageToken").string(var_89.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_cost_forecast_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetCostForecastInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_90) = &input.time_period {
#[allow(unused_mut)]
let mut object_91 = object.key("TimePeriod").start_object();
crate::json_ser::serialize_structure_crate_model_date_interval(&mut object_91, var_90)?;
object_91.finish();
}
if let Some(var_92) = &input.metric {
object.key("Metric").string(var_92.as_str());
}
if let Some(var_93) = &input.granularity {
object.key("Granularity").string(var_93.as_str());
}
if let Some(var_94) = &input.filter {
#[allow(unused_mut)]
let mut object_95 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_95, var_94)?;
object_95.finish();
}
if let Some(var_96) = &input.prediction_interval_level {
object.key("PredictionIntervalLevel").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_96).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_dimension_values_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDimensionValuesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.search_string {
object.key("SearchString").string(var_97.as_str());
}
if let Some(var_98) = &input.time_period {
#[allow(unused_mut)]
let mut object_99 = object.key("TimePeriod").start_object();
crate::json_ser::serialize_structure_crate_model_date_interval(&mut object_99, var_98)?;
object_99.finish();
}
if let Some(var_100) = &input.dimension {
object.key("Dimension").string(var_100.as_str());
}
if let Some(var_101) = &input.context {
object.key("Context").string(var_101.as_str());
}
if let Some(var_102) = &input.filter {
#[allow(unused_mut)]
let mut object_103 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_103, var_102)?;
object_103.finish();
}
if let Some(var_104) = &input.sort_by {
let mut array_105 = object.key("SortBy").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_sort_definition(
&mut object_107,
item_106,
)?;
object_107.finish();
}
}
array_105.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_108) = &input.next_page_token {
object.key("NextPageToken").string(var_108.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_reservation_coverage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetReservationCoverageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_109) = &input.time_period {
#[allow(unused_mut)]
let mut object_110 = object.key("TimePeriod").start_object();
crate::json_ser::serialize_structure_crate_model_date_interval(&mut object_110, var_109)?;
object_110.finish();
}
if let Some(var_111) = &input.group_by {
let mut array_112 = object.key("GroupBy").start_array();
for item_113 in var_111 {
{
#[allow(unused_mut)]
let mut object_114 = array_112.value().start_object();
crate::json_ser::serialize_structure_crate_model_group_definition(
&mut object_114,
item_113,
)?;
object_114.finish();
}
}
array_112.finish();
}
if let Some(var_115) = &input.granularity {
object.key("Granularity").string(var_115.as_str());
}
if let Some(var_116) = &input.filter {
#[allow(unused_mut)]
let mut object_117 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_117, var_116)?;
object_117.finish();
}
if let Some(var_118) = &input.metrics {
let mut array_119 = object.key("Metrics").start_array();
for item_120 in var_118 {
{
array_119.value().string(item_120.as_str());
}
}
array_119.finish();
}
if let Some(var_121) = &input.next_page_token {
object.key("NextPageToken").string(var_121.as_str());
}
if let Some(var_122) = &input.sort_by {
#[allow(unused_mut)]
let mut object_123 = object.key("SortBy").start_object();
crate::json_ser::serialize_structure_crate_model_sort_definition(&mut object_123, var_122)?;
object_123.finish();
}
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_reservation_purchase_recommendation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetReservationPurchaseRecommendationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.account_id {
object.key("AccountId").string(var_125.as_str());
}
if let Some(var_126) = &input.service {
object.key("Service").string(var_126.as_str());
}
if let Some(var_127) = &input.filter {
#[allow(unused_mut)]
let mut object_128 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_128, var_127)?;
object_128.finish();
}
if let Some(var_129) = &input.account_scope {
object.key("AccountScope").string(var_129.as_str());
}
if let Some(var_130) = &input.lookback_period_in_days {
object.key("LookbackPeriodInDays").string(var_130.as_str());
}
if let Some(var_131) = &input.term_in_years {
object.key("TermInYears").string(var_131.as_str());
}
if let Some(var_132) = &input.payment_option {
object.key("PaymentOption").string(var_132.as_str());
}
if let Some(var_133) = &input.service_specification {
#[allow(unused_mut)]
let mut object_134 = object.key("ServiceSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_service_specification(
&mut object_134,
var_133,
)?;
object_134.finish();
}
if input.page_size != 0 {
object.key("PageSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.page_size).into()),
);
}
if let Some(var_135) = &input.next_page_token {
object.key("NextPageToken").string(var_135.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_reservation_utilization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetReservationUtilizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_136) = &input.time_period {
#[allow(unused_mut)]
let mut object_137 = object.key("TimePeriod").start_object();
crate::json_ser::serialize_structure_crate_model_date_interval(&mut object_137, var_136)?;
object_137.finish();
}
if let Some(var_138) = &input.group_by {
let mut array_139 = object.key("GroupBy").start_array();
for item_140 in var_138 {
{
#[allow(unused_mut)]
let mut object_141 = array_139.value().start_object();
crate::json_ser::serialize_structure_crate_model_group_definition(
&mut object_141,
item_140,
)?;
object_141.finish();
}
}
array_139.finish();
}
if let Some(var_142) = &input.granularity {
object.key("Granularity").string(var_142.as_str());
}
if let Some(var_143) = &input.filter {
#[allow(unused_mut)]
let mut object_144 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_144, var_143)?;
object_144.finish();
}
if let Some(var_145) = &input.sort_by {
#[allow(unused_mut)]
let mut object_146 = object.key("SortBy").start_object();
crate::json_ser::serialize_structure_crate_model_sort_definition(&mut object_146, var_145)?;
object_146.finish();
}
if let Some(var_147) = &input.next_page_token {
object.key("NextPageToken").string(var_147.as_str());
}
if let Some(var_148) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_148).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_rightsizing_recommendation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetRightsizingRecommendationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_149) = &input.filter {
#[allow(unused_mut)]
let mut object_150 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_150, var_149)?;
object_150.finish();
}
if let Some(var_151) = &input.configuration {
#[allow(unused_mut)]
let mut object_152 = object.key("Configuration").start_object();
crate::json_ser::serialize_structure_crate_model_rightsizing_recommendation_configuration(
&mut object_152,
var_151,
)?;
object_152.finish();
}
if let Some(var_153) = &input.service {
object.key("Service").string(var_153.as_str());
}
if input.page_size != 0 {
object.key("PageSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.page_size).into()),
);
}
if let Some(var_154) = &input.next_page_token {
object.key("NextPageToken").string(var_154.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_savings_plans_coverage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetSavingsPlansCoverageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_155) = &input.time_period {
#[allow(unused_mut)]
let mut object_156 = object.key("TimePeriod").start_object();
crate::json_ser::serialize_structure_crate_model_date_interval(&mut object_156, var_155)?;
object_156.finish();
}
if let Some(var_157) = &input.group_by {
let mut array_158 = object.key("GroupBy").start_array();
for item_159 in var_157 {
{
#[allow(unused_mut)]
let mut object_160 = array_158.value().start_object();
crate::json_ser::serialize_structure_crate_model_group_definition(
&mut object_160,
item_159,
)?;
object_160.finish();
}
}
array_158.finish();
}
if let Some(var_161) = &input.granularity {
object.key("Granularity").string(var_161.as_str());
}
if let Some(var_162) = &input.filter {
#[allow(unused_mut)]
let mut object_163 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_163, var_162)?;
object_163.finish();
}
if let Some(var_164) = &input.metrics {
let mut array_165 = object.key("Metrics").start_array();
for item_166 in var_164 {
{
array_165.value().string(item_166.as_str());
}
}
array_165.finish();
}
if let Some(var_167) = &input.next_token {
object.key("NextToken").string(var_167.as_str());
}
if let Some(var_168) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_168).into()),
);
}
if let Some(var_169) = &input.sort_by {
#[allow(unused_mut)]
let mut object_170 = object.key("SortBy").start_object();
crate::json_ser::serialize_structure_crate_model_sort_definition(&mut object_170, var_169)?;
object_170.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_savings_plans_purchase_recommendation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetSavingsPlansPurchaseRecommendationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_171) = &input.savings_plans_type {
object.key("SavingsPlansType").string(var_171.as_str());
}
if let Some(var_172) = &input.term_in_years {
object.key("TermInYears").string(var_172.as_str());
}
if let Some(var_173) = &input.payment_option {
object.key("PaymentOption").string(var_173.as_str());
}
if let Some(var_174) = &input.account_scope {
object.key("AccountScope").string(var_174.as_str());
}
if let Some(var_175) = &input.next_page_token {
object.key("NextPageToken").string(var_175.as_str());
}
if input.page_size != 0 {
object.key("PageSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.page_size).into()),
);
}
if let Some(var_176) = &input.lookback_period_in_days {
object.key("LookbackPeriodInDays").string(var_176.as_str());
}
if let Some(var_177) = &input.filter {
#[allow(unused_mut)]
let mut object_178 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_178, var_177)?;
object_178.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_savings_plans_utilization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetSavingsPlansUtilizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_179) = &input.time_period {
#[allow(unused_mut)]
let mut object_180 = object.key("TimePeriod").start_object();
crate::json_ser::serialize_structure_crate_model_date_interval(&mut object_180, var_179)?;
object_180.finish();
}
if let Some(var_181) = &input.granularity {
object.key("Granularity").string(var_181.as_str());
}
if let Some(var_182) = &input.filter {
#[allow(unused_mut)]
let mut object_183 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_183, var_182)?;
object_183.finish();
}
if let Some(var_184) = &input.sort_by {
#[allow(unused_mut)]
let mut object_185 = object.key("SortBy").start_object();
crate::json_ser::serialize_structure_crate_model_sort_definition(&mut object_185, var_184)?;
object_185.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_savings_plans_utilization_details_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetSavingsPlansUtilizationDetailsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_186) = &input.time_period {
#[allow(unused_mut)]
let mut object_187 = object.key("TimePeriod").start_object();
crate::json_ser::serialize_structure_crate_model_date_interval(&mut object_187, var_186)?;
object_187.finish();
}
if let Some(var_188) = &input.filter {
#[allow(unused_mut)]
let mut object_189 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_189, var_188)?;
object_189.finish();
}
if let Some(var_190) = &input.data_type {
let mut array_191 = object.key("DataType").start_array();
for item_192 in var_190 {
{
array_191.value().string(item_192.as_str());
}
}
array_191.finish();
}
if let Some(var_193) = &input.next_token {
object.key("NextToken").string(var_193.as_str());
}
if let Some(var_194) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_194).into()),
);
}
if let Some(var_195) = &input.sort_by {
#[allow(unused_mut)]
let mut object_196 = object.key("SortBy").start_object();
crate::json_ser::serialize_structure_crate_model_sort_definition(&mut object_196, var_195)?;
object_196.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.search_string {
object.key("SearchString").string(var_197.as_str());
}
if let Some(var_198) = &input.time_period {
#[allow(unused_mut)]
let mut object_199 = object.key("TimePeriod").start_object();
crate::json_ser::serialize_structure_crate_model_date_interval(&mut object_199, var_198)?;
object_199.finish();
}
if let Some(var_200) = &input.tag_key {
object.key("TagKey").string(var_200.as_str());
}
if let Some(var_201) = &input.filter {
#[allow(unused_mut)]
let mut object_202 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_202, var_201)?;
object_202.finish();
}
if let Some(var_203) = &input.sort_by {
let mut array_204 = object.key("SortBy").start_array();
for item_205 in var_203 {
{
#[allow(unused_mut)]
let mut object_206 = array_204.value().start_object();
crate::json_ser::serialize_structure_crate_model_sort_definition(
&mut object_206,
item_205,
)?;
object_206.finish();
}
}
array_204.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_207) = &input.next_page_token {
object.key("NextPageToken").string(var_207.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_usage_forecast_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetUsageForecastInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_208) = &input.time_period {
#[allow(unused_mut)]
let mut object_209 = object.key("TimePeriod").start_object();
crate::json_ser::serialize_structure_crate_model_date_interval(&mut object_209, var_208)?;
object_209.finish();
}
if let Some(var_210) = &input.metric {
object.key("Metric").string(var_210.as_str());
}
if let Some(var_211) = &input.granularity {
object.key("Granularity").string(var_211.as_str());
}
if let Some(var_212) = &input.filter {
#[allow(unused_mut)]
let mut object_213 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_213, var_212)?;
object_213.finish();
}
if let Some(var_214) = &input.prediction_interval_level {
object.key("PredictionIntervalLevel").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_214).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_cost_allocation_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListCostAllocationTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_215) = &input.status {
object.key("Status").string(var_215.as_str());
}
if let Some(var_216) = &input.tag_keys {
let mut array_217 = object.key("TagKeys").start_array();
for item_218 in var_216 {
{
array_217.value().string(item_218.as_str());
}
}
array_217.finish();
}
if let Some(var_219) = &input.r#type {
object.key("Type").string(var_219.as_str());
}
if let Some(var_220) = &input.next_token {
object.key("NextToken").string(var_220.as_str());
}
if let Some(var_221) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_221).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_cost_category_definitions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListCostCategoryDefinitionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_222) = &input.effective_on {
object.key("EffectiveOn").string(var_222.as_str());
}
if let Some(var_223) = &input.next_token {
object.key("NextToken").string(var_223.as_str());
}
if let Some(var_224) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_224).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_savings_plans_purchase_recommendation_generation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSavingsPlansPurchaseRecommendationGenerationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_225) = &input.generation_status {
object.key("GenerationStatus").string(var_225.as_str());
}
if let Some(var_226) = &input.recommendation_ids {
let mut array_227 = object.key("RecommendationIds").start_array();
for item_228 in var_226 {
{
array_227.value().string(item_228.as_str());
}
}
array_227.finish();
}
if input.page_size != 0 {
object.key("PageSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.page_size).into()),
);
}
if let Some(var_229) = &input.next_page_token {
object.key("NextPageToken").string(var_229.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_for_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsForResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_230) = &input.resource_arn {
object.key("ResourceArn").string(var_230.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_provide_anomaly_feedback_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ProvideAnomalyFeedbackInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_231) = &input.anomaly_id {
object.key("AnomalyId").string(var_231.as_str());
}
if let Some(var_232) = &input.feedback {
object.key("Feedback").string(var_232.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_233) = &input.resource_arn {
object.key("ResourceArn").string(var_233.as_str());
}
if let Some(var_234) = &input.resource_tags {
let mut array_235 = object.key("ResourceTags").start_array();
for item_236 in var_234 {
{
#[allow(unused_mut)]
let mut object_237 = array_235.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_tag(
&mut object_237,
item_236,
)?;
object_237.finish();
}
}
array_235.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_untag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_238) = &input.resource_arn {
object.key("ResourceArn").string(var_238.as_str());
}
if let Some(var_239) = &input.resource_tag_keys {
let mut array_240 = object.key("ResourceTagKeys").start_array();
for item_241 in var_239 {
{
array_240.value().string(item_241.as_str());
}
}
array_240.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_anomaly_monitor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAnomalyMonitorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_242) = &input.monitor_arn {
object.key("MonitorArn").string(var_242.as_str());
}
if let Some(var_243) = &input.monitor_name {
object.key("MonitorName").string(var_243.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_anomaly_subscription_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAnomalySubscriptionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_244) = &input.subscription_arn {
object.key("SubscriptionArn").string(var_244.as_str());
}
if let Some(var_245) = &input.threshold {
object.key("Threshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_245).into()),
);
}
if let Some(var_246) = &input.frequency {
object.key("Frequency").string(var_246.as_str());
}
if let Some(var_247) = &input.monitor_arn_list {
let mut array_248 = object.key("MonitorArnList").start_array();
for item_249 in var_247 {
{
array_248.value().string(item_249.as_str());
}
}
array_248.finish();
}
if let Some(var_250) = &input.subscribers {
let mut array_251 = object.key("Subscribers").start_array();
for item_252 in var_250 {
{
#[allow(unused_mut)]
let mut object_253 = array_251.value().start_object();
crate::json_ser::serialize_structure_crate_model_subscriber(
&mut object_253,
item_252,
)?;
object_253.finish();
}
}
array_251.finish();
}
if let Some(var_254) = &input.subscription_name {
object.key("SubscriptionName").string(var_254.as_str());
}
if let Some(var_255) = &input.threshold_expression {
#[allow(unused_mut)]
let mut object_256 = object.key("ThresholdExpression").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_256, var_255)?;
object_256.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_cost_allocation_tags_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateCostAllocationTagsStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_257) = &input.cost_allocation_tags_status {
let mut array_258 = object.key("CostAllocationTagsStatus").start_array();
for item_259 in var_257 {
{
#[allow(unused_mut)]
let mut object_260 = array_258.value().start_object();
crate::json_ser::serialize_structure_crate_model_cost_allocation_tag_status_entry(
&mut object_260,
item_259,
)?;
object_260.finish();
}
}
array_258.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_cost_category_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateCostCategoryDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_261) = &input.cost_category_arn {
object.key("CostCategoryArn").string(var_261.as_str());
}
if let Some(var_262) = &input.effective_start {
object.key("EffectiveStart").string(var_262.as_str());
}
if let Some(var_263) = &input.rule_version {
object.key("RuleVersion").string(var_263.as_str());
}
if let Some(var_264) = &input.rules {
let mut array_265 = object.key("Rules").start_array();
for item_266 in var_264 {
{
#[allow(unused_mut)]
let mut object_267 = array_265.value().start_object();
crate::json_ser::serialize_structure_crate_model_cost_category_rule(
&mut object_267,
item_266,
)?;
object_267.finish();
}
}
array_265.finish();
}
if let Some(var_268) = &input.default_value {
object.key("DefaultValue").string(var_268.as_str());
}
if let Some(var_269) = &input.split_charge_rules {
let mut array_270 = object.key("SplitChargeRules").start_array();
for item_271 in var_269 {
{
#[allow(unused_mut)]
let mut object_272 = array_270.value().start_object();
crate::json_ser::serialize_structure_crate_model_cost_category_split_charge_rule(
&mut object_272,
item_271,
)?;
object_272.finish();
}
}
array_270.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_anomaly_monitor(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnomalyMonitor,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_273) = &input.monitor_arn {
object.key("MonitorArn").string(var_273.as_str());
}
if let Some(var_274) = &input.monitor_name {
object.key("MonitorName").string(var_274.as_str());
}
if let Some(var_275) = &input.creation_date {
object.key("CreationDate").string(var_275.as_str());
}
if let Some(var_276) = &input.last_updated_date {
object.key("LastUpdatedDate").string(var_276.as_str());
}
if let Some(var_277) = &input.last_evaluated_date {
object.key("LastEvaluatedDate").string(var_277.as_str());
}
if let Some(var_278) = &input.monitor_type {
object.key("MonitorType").string(var_278.as_str());
}
if let Some(var_279) = &input.monitor_dimension {
object.key("MonitorDimension").string(var_279.as_str());
}
if let Some(var_280) = &input.monitor_specification {
#[allow(unused_mut)]
let mut object_281 = object.key("MonitorSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_281, var_280)?;
object_281.finish();
}
if input.dimensional_value_count != 0 {
object.key("DimensionalValueCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.dimensional_value_count).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceTag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_282) = &input.key {
object.key("Key").string(var_282.as_str());
}
if let Some(var_283) = &input.value {
object.key("Value").string(var_283.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_anomaly_subscription(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnomalySubscription,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_284) = &input.subscription_arn {
object.key("SubscriptionArn").string(var_284.as_str());
}
if let Some(var_285) = &input.account_id {
object.key("AccountId").string(var_285.as_str());
}
if let Some(var_286) = &input.monitor_arn_list {
let mut array_287 = object.key("MonitorArnList").start_array();
for item_288 in var_286 {
{
array_287.value().string(item_288.as_str());
}
}
array_287.finish();
}
if let Some(var_289) = &input.subscribers {
let mut array_290 = object.key("Subscribers").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_subscriber(
&mut object_292,
item_291,
)?;
object_292.finish();
}
}
array_290.finish();
}
if let Some(var_293) = &input.threshold {
object.key("Threshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_293).into()),
);
}
if let Some(var_294) = &input.frequency {
object.key("Frequency").string(var_294.as_str());
}
if let Some(var_295) = &input.subscription_name {
object.key("SubscriptionName").string(var_295.as_str());
}
if let Some(var_296) = &input.threshold_expression {
#[allow(unused_mut)]
let mut object_297 = object.key("ThresholdExpression").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_297, var_296)?;
object_297.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_cost_category_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CostCategoryRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_298) = &input.value {
object.key("Value").string(var_298.as_str());
}
if let Some(var_299) = &input.rule {
#[allow(unused_mut)]
let mut object_300 = object.key("Rule").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_300, var_299)?;
object_300.finish();
}
if let Some(var_301) = &input.inherited_value {
#[allow(unused_mut)]
let mut object_302 = object.key("InheritedValue").start_object();
crate::json_ser::serialize_structure_crate_model_cost_category_inherited_value_dimension(
&mut object_302,
var_301,
)?;
object_302.finish();
}
if let Some(var_303) = &input.r#type {
object.key("Type").string(var_303.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cost_category_split_charge_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CostCategorySplitChargeRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_304) = &input.source {
object.key("Source").string(var_304.as_str());
}
if let Some(var_305) = &input.targets {
let mut array_306 = object.key("Targets").start_array();
for item_307 in var_305 {
{
array_306.value().string(item_307.as_str());
}
}
array_306.finish();
}
if let Some(var_308) = &input.method {
object.key("Method").string(var_308.as_str());
}
if let Some(var_309) = &input.parameters {
let mut array_310 = object.key("Parameters").start_array();
for item_311 in var_309 {
{
#[allow(unused_mut)]
let mut object_312 = array_310.value().start_object();
crate::json_ser::serialize_structure_crate_model_cost_category_split_charge_rule_parameter(&mut object_312, item_311)?;
object_312.finish();
}
}
array_310.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_anomaly_date_interval(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnomalyDateInterval,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_313) = &input.start_date {
object.key("StartDate").string(var_313.as_str());
}
if let Some(var_314) = &input.end_date {
object.key("EndDate").string(var_314.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_total_impact_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TotalImpactFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_315) = &input.numeric_operator {
object.key("NumericOperator").string(var_315.as_str());
}
{
object.key("StartValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.start_value).into()),
);
}
if input.end_value != 0.0 {
object.key("EndValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.end_value).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_date_interval(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DateInterval,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_316) = &input.start {
object.key("Start").string(var_316.as_str());
}
if let Some(var_317) = &input.end {
object.key("End").string(var_317.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_expression(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Expression,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_318) = &input.or {
let mut array_319 = object.key("Or").start_array();
for item_320 in var_318 {
{
#[allow(unused_mut)]
let mut object_321 = array_319.value().start_object();
crate::json_ser::serialize_structure_crate_model_expression(
&mut object_321,
item_320,
)?;
object_321.finish();
}
}
array_319.finish();
}
if let Some(var_322) = &input.and {
let mut array_323 = object.key("And").start_array();
for item_324 in var_322 {
{
#[allow(unused_mut)]
let mut object_325 = array_323.value().start_object();
crate::json_ser::serialize_structure_crate_model_expression(
&mut object_325,
item_324,
)?;
object_325.finish();
}
}
array_323.finish();
}
if let Some(var_326) = &input.not {
#[allow(unused_mut)]
let mut object_327 = object.key("Not").start_object();
crate::json_ser::serialize_structure_crate_model_expression(&mut object_327, var_326)?;
object_327.finish();
}
if let Some(var_328) = &input.dimensions {
#[allow(unused_mut)]
let mut object_329 = object.key("Dimensions").start_object();
crate::json_ser::serialize_structure_crate_model_dimension_values(
&mut object_329,
var_328,
)?;
object_329.finish();
}
if let Some(var_330) = &input.tags {
#[allow(unused_mut)]
let mut object_331 = object.key("Tags").start_object();
crate::json_ser::serialize_structure_crate_model_tag_values(&mut object_331, var_330)?;
object_331.finish();
}
if let Some(var_332) = &input.cost_categories {
#[allow(unused_mut)]
let mut object_333 = object.key("CostCategories").start_object();
crate::json_ser::serialize_structure_crate_model_cost_category_values(
&mut object_333,
var_332,
)?;
object_333.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_group_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GroupDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_334) = &input.r#type {
object.key("Type").string(var_334.as_str());
}
if let Some(var_335) = &input.key {
object.key("Key").string(var_335.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sort_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SortDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_336) = &input.key {
object.key("Key").string(var_336.as_str());
}
if let Some(var_337) = &input.sort_order {
object.key("SortOrder").string(var_337.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_service_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServiceSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_338) = &input.ec2_specification {
#[allow(unused_mut)]
let mut object_339 = object.key("EC2Specification").start_object();
crate::json_ser::serialize_structure_crate_model_ec2_specification(
&mut object_339,
var_338,
)?;
object_339.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_rightsizing_recommendation_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RightsizingRecommendationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_340) = &input.recommendation_target {
object.key("RecommendationTarget").string(var_340.as_str());
}
{
object
.key("BenefitsConsidered")
.boolean(input.benefits_considered);
}
Ok(())
}
pub fn serialize_structure_crate_model_subscriber(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Subscriber,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_341) = &input.address {
object.key("Address").string(var_341.as_str());
}
if let Some(var_342) = &input.r#type {
object.key("Type").string(var_342.as_str());
}
if let Some(var_343) = &input.status {
object.key("Status").string(var_343.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cost_allocation_tag_status_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CostAllocationTagStatusEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_344) = &input.tag_key {
object.key("TagKey").string(var_344.as_str());
}
if let Some(var_345) = &input.status {
object.key("Status").string(var_345.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cost_category_inherited_value_dimension(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CostCategoryInheritedValueDimension,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_346) = &input.dimension_name {
object.key("DimensionName").string(var_346.as_str());
}
if let Some(var_347) = &input.dimension_key {
object.key("DimensionKey").string(var_347.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cost_category_split_charge_rule_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CostCategorySplitChargeRuleParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_348) = &input.r#type {
object.key("Type").string(var_348.as_str());
}
if let Some(var_349) = &input.values {
let mut array_350 = object.key("Values").start_array();
for item_351 in var_349 {
{
array_350.value().string(item_351.as_str());
}
}
array_350.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_dimension_values(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DimensionValues,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_352) = &input.key {
object.key("Key").string(var_352.as_str());
}
if let Some(var_353) = &input.values {
let mut array_354 = object.key("Values").start_array();
for item_355 in var_353 {
{
array_354.value().string(item_355.as_str());
}
}
array_354.finish();
}
if let Some(var_356) = &input.match_options {
let mut array_357 = object.key("MatchOptions").start_array();
for item_358 in var_356 {
{
array_357.value().string(item_358.as_str());
}
}
array_357.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tag_values(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TagValues,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_359) = &input.key {
object.key("Key").string(var_359.as_str());
}
if let Some(var_360) = &input.values {
let mut array_361 = object.key("Values").start_array();
for item_362 in var_360 {
{
array_361.value().string(item_362.as_str());
}
}
array_361.finish();
}
if let Some(var_363) = &input.match_options {
let mut array_364 = object.key("MatchOptions").start_array();
for item_365 in var_363 {
{
array_364.value().string(item_365.as_str());
}
}
array_364.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_cost_category_values(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CostCategoryValues,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_366) = &input.key {
object.key("Key").string(var_366.as_str());
}
if let Some(var_367) = &input.values {
let mut array_368 = object.key("Values").start_array();
for item_369 in var_367 {
{
array_368.value().string(item_369.as_str());
}
}
array_368.finish();
}
if let Some(var_370) = &input.match_options {
let mut array_371 = object.key("MatchOptions").start_array();
for item_372 in var_370 {
{
array_371.value().string(item_372.as_str());
}
}
array_371.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_ec2_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Ec2Specification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_373) = &input.offering_class {
object.key("OfferingClass").string(var_373.as_str());
}
Ok(())
}