pub fn serialize_structure_crate_input_associate_accounts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateAccountsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.account_ids {
let mut array_2 = object.key("AccountIds").start_array();
for item_3 in var_1 {
{
array_2.value().string(item_3.as_str());
}
}
array_2.finish();
}
if let Some(var_4) = &input.arn {
object.key("Arn").string(var_4.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_pricing_rules_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociatePricingRulesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_5) = &input.arn {
object.key("Arn").string(var_5.as_str());
}
if let Some(var_6) = &input.pricing_rule_arns {
let mut array_7 = object.key("PricingRuleArns").start_array();
for item_8 in var_6 {
{
array_7.value().string(item_8.as_str());
}
}
array_7.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_associate_resources_to_custom_line_item_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchAssociateResourcesToCustomLineItemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_9) = &input.billing_period_range {
#[allow(unused_mut)]
let mut object_10 = object.key("BillingPeriodRange").start_object();
crate::json_ser::serialize_structure_crate_model_custom_line_item_billing_period_range(
&mut object_10,
var_9,
)?;
object_10.finish();
}
if let Some(var_11) = &input.resource_arns {
let mut array_12 = object.key("ResourceArns").start_array();
for item_13 in var_11 {
{
array_12.value().string(item_13.as_str());
}
}
array_12.finish();
}
if let Some(var_14) = &input.target_arn {
object.key("TargetArn").string(var_14.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_disassociate_resources_from_custom_line_item_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDisassociateResourcesFromCustomLineItemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_15) = &input.billing_period_range {
#[allow(unused_mut)]
let mut object_16 = object.key("BillingPeriodRange").start_object();
crate::json_ser::serialize_structure_crate_model_custom_line_item_billing_period_range(
&mut object_16,
var_15,
)?;
object_16.finish();
}
if let Some(var_17) = &input.resource_arns {
let mut array_18 = object.key("ResourceArns").start_array();
for item_19 in var_17 {
{
array_18.value().string(item_19.as_str());
}
}
array_18.finish();
}
if let Some(var_20) = &input.target_arn {
object.key("TargetArn").string(var_20.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_billing_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBillingGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_21) = &input.account_grouping {
#[allow(unused_mut)]
let mut object_22 = object.key("AccountGrouping").start_object();
crate::json_ser::serialize_structure_crate_model_account_grouping(&mut object_22, var_21)?;
object_22.finish();
}
if let Some(var_23) = &input.computation_preference {
#[allow(unused_mut)]
let mut object_24 = object.key("ComputationPreference").start_object();
crate::json_ser::serialize_structure_crate_model_computation_preference(
&mut object_24,
var_23,
)?;
object_24.finish();
}
if let Some(var_25) = &input.description {
object.key("Description").string(var_25.as_str());
}
if let Some(var_26) = &input.name {
object.key("Name").string(var_26.as_str());
}
if let Some(var_27) = &input.primary_account_id {
object.key("PrimaryAccountId").string(var_27.as_str());
}
if let Some(var_28) = &input.tags {
#[allow(unused_mut)]
let mut object_29 = object.key("Tags").start_object();
for (key_30, value_31) in var_28 {
{
object_29.key(key_30.as_str()).string(value_31.as_str());
}
}
object_29.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_custom_line_item_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCustomLineItemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_32) = &input.billing_group_arn {
object.key("BillingGroupArn").string(var_32.as_str());
}
if let Some(var_33) = &input.billing_period_range {
#[allow(unused_mut)]
let mut object_34 = object.key("BillingPeriodRange").start_object();
crate::json_ser::serialize_structure_crate_model_custom_line_item_billing_period_range(
&mut object_34,
var_33,
)?;
object_34.finish();
}
if let Some(var_35) = &input.charge_details {
#[allow(unused_mut)]
let mut object_36 = object.key("ChargeDetails").start_object();
crate::json_ser::serialize_structure_crate_model_custom_line_item_charge_details(
&mut object_36,
var_35,
)?;
object_36.finish();
}
if let Some(var_37) = &input.description {
object.key("Description").string(var_37.as_str());
}
if let Some(var_38) = &input.name {
object.key("Name").string(var_38.as_str());
}
if let Some(var_39) = &input.tags {
#[allow(unused_mut)]
let mut object_40 = object.key("Tags").start_object();
for (key_41, value_42) in var_39 {
{
object_40.key(key_41.as_str()).string(value_42.as_str());
}
}
object_40.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_pricing_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePricingPlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_43) = &input.description {
object.key("Description").string(var_43.as_str());
}
if let Some(var_44) = &input.name {
object.key("Name").string(var_44.as_str());
}
if let Some(var_45) = &input.pricing_rule_arns {
let mut array_46 = object.key("PricingRuleArns").start_array();
for item_47 in var_45 {
{
array_46.value().string(item_47.as_str());
}
}
array_46.finish();
}
if let Some(var_48) = &input.tags {
#[allow(unused_mut)]
let mut object_49 = object.key("Tags").start_object();
for (key_50, value_51) in var_48 {
{
object_49.key(key_50.as_str()).string(value_51.as_str());
}
}
object_49.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_pricing_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePricingRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_52) = &input.billing_entity {
object.key("BillingEntity").string(var_52.as_str());
}
if let Some(var_53) = &input.description {
object.key("Description").string(var_53.as_str());
}
if let Some(var_54) = &input.modifier_percentage {
object.key("ModifierPercentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_54).into()),
);
}
if let Some(var_55) = &input.name {
object.key("Name").string(var_55.as_str());
}
if let Some(var_56) = &input.operation {
object.key("Operation").string(var_56.as_str());
}
if let Some(var_57) = &input.scope {
object.key("Scope").string(var_57.as_str());
}
if let Some(var_58) = &input.service {
object.key("Service").string(var_58.as_str());
}
if let Some(var_59) = &input.tags {
#[allow(unused_mut)]
let mut object_60 = object.key("Tags").start_object();
for (key_61, value_62) in var_59 {
{
object_60.key(key_61.as_str()).string(value_62.as_str());
}
}
object_60.finish();
}
if let Some(var_63) = &input.tiering {
#[allow(unused_mut)]
let mut object_64 = object.key("Tiering").start_object();
crate::json_ser::serialize_structure_crate_model_create_tiering_input(
&mut object_64,
var_63,
)?;
object_64.finish();
}
if let Some(var_65) = &input.r#type {
object.key("Type").string(var_65.as_str());
}
if let Some(var_66) = &input.usage_type {
object.key("UsageType").string(var_66.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_billing_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteBillingGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_67) = &input.arn {
object.key("Arn").string(var_67.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_custom_line_item_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteCustomLineItemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_68) = &input.arn {
object.key("Arn").string(var_68.as_str());
}
if let Some(var_69) = &input.billing_period_range {
#[allow(unused_mut)]
let mut object_70 = object.key("BillingPeriodRange").start_object();
crate::json_ser::serialize_structure_crate_model_custom_line_item_billing_period_range(
&mut object_70,
var_69,
)?;
object_70.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_pricing_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeletePricingPlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_71) = &input.arn {
object.key("Arn").string(var_71.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_pricing_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeletePricingRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_72) = &input.arn {
object.key("Arn").string(var_72.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_accounts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateAccountsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_73) = &input.account_ids {
let mut array_74 = object.key("AccountIds").start_array();
for item_75 in var_73 {
{
array_74.value().string(item_75.as_str());
}
}
array_74.finish();
}
if let Some(var_76) = &input.arn {
object.key("Arn").string(var_76.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_pricing_rules_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociatePricingRulesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_77) = &input.arn {
object.key("Arn").string(var_77.as_str());
}
if let Some(var_78) = &input.pricing_rule_arns {
let mut array_79 = object.key("PricingRuleArns").start_array();
for item_80 in var_78 {
{
array_79.value().string(item_80.as_str());
}
}
array_79.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_account_associations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAccountAssociationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.billing_period {
object.key("BillingPeriod").string(var_81.as_str());
}
if let Some(var_82) = &input.filters {
#[allow(unused_mut)]
let mut object_83 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_list_account_associations_filter(
&mut object_83,
var_82,
)?;
object_83.finish();
}
if let Some(var_84) = &input.next_token {
object.key("NextToken").string(var_84.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_billing_group_cost_reports_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListBillingGroupCostReportsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.billing_period {
object.key("BillingPeriod").string(var_85.as_str());
}
if let Some(var_86) = &input.filters {
#[allow(unused_mut)]
let mut object_87 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_list_billing_group_cost_reports_filter(
&mut object_87,
var_86,
)?;
object_87.finish();
}
if let Some(var_88) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_88).into()),
);
}
if let Some(var_89) = &input.next_token {
object.key("NextToken").string(var_89.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_billing_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListBillingGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_90) = &input.billing_period {
object.key("BillingPeriod").string(var_90.as_str());
}
if let Some(var_91) = &input.filters {
#[allow(unused_mut)]
let mut object_92 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_list_billing_groups_filter(
&mut object_92,
var_91,
)?;
object_92.finish();
}
if let Some(var_93) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_93).into()),
);
}
if let Some(var_94) = &input.next_token {
object.key("NextToken").string(var_94.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_custom_line_items_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListCustomLineItemsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_95) = &input.billing_period {
object.key("BillingPeriod").string(var_95.as_str());
}
if let Some(var_96) = &input.filters {
#[allow(unused_mut)]
let mut object_97 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_list_custom_line_items_filter(
&mut object_97,
var_96,
)?;
object_97.finish();
}
if let Some(var_98) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_98).into()),
);
}
if let Some(var_99) = &input.next_token {
object.key("NextToken").string(var_99.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_custom_line_item_versions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListCustomLineItemVersionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_100) = &input.arn {
object.key("Arn").string(var_100.as_str());
}
if let Some(var_101) = &input.filters {
#[allow(unused_mut)]
let mut object_102 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_list_custom_line_item_versions_filter(
&mut object_102,
var_101,
)?;
object_102.finish();
}
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.next_token {
object.key("NextToken").string(var_104.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_pricing_plans_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPricingPlansInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_105) = &input.billing_period {
object.key("BillingPeriod").string(var_105.as_str());
}
if let Some(var_106) = &input.filters {
#[allow(unused_mut)]
let mut object_107 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_list_pricing_plans_filter(
&mut object_107,
var_106,
)?;
object_107.finish();
}
if let Some(var_108) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_108).into()),
);
}
if let Some(var_109) = &input.next_token {
object.key("NextToken").string(var_109.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_pricing_plans_associated_with_pricing_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPricingPlansAssociatedWithPricingRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_110) = &input.billing_period {
object.key("BillingPeriod").string(var_110.as_str());
}
if let Some(var_111) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_111).into()),
);
}
if let Some(var_112) = &input.next_token {
object.key("NextToken").string(var_112.as_str());
}
if let Some(var_113) = &input.pricing_rule_arn {
object.key("PricingRuleArn").string(var_113.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_pricing_rules_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPricingRulesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_114) = &input.billing_period {
object.key("BillingPeriod").string(var_114.as_str());
}
if let Some(var_115) = &input.filters {
#[allow(unused_mut)]
let mut object_116 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_list_pricing_rules_filter(
&mut object_116,
var_115,
)?;
object_116.finish();
}
if let Some(var_117) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_117).into()),
);
}
if let Some(var_118) = &input.next_token {
object.key("NextToken").string(var_118.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_pricing_rules_associated_to_pricing_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPricingRulesAssociatedToPricingPlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_119) = &input.billing_period {
object.key("BillingPeriod").string(var_119.as_str());
}
if let Some(var_120) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_120).into()),
);
}
if let Some(var_121) = &input.next_token {
object.key("NextToken").string(var_121.as_str());
}
if let Some(var_122) = &input.pricing_plan_arn {
object.key("PricingPlanArn").string(var_122.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_resources_associated_to_custom_line_item_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListResourcesAssociatedToCustomLineItemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_123) = &input.arn {
object.key("Arn").string(var_123.as_str());
}
if let Some(var_124) = &input.billing_period {
object.key("BillingPeriod").string(var_124.as_str());
}
if let Some(var_125) = &input.filters {
#[allow(unused_mut)]
let mut object_126 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_list_resources_associated_to_custom_line_item_filter(&mut object_126, var_125)?;
object_126.finish();
}
if let Some(var_127) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_127).into()),
);
}
if let Some(var_128) = &input.next_token {
object.key("NextToken").string(var_128.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_129) = &input.tags {
#[allow(unused_mut)]
let mut object_130 = object.key("Tags").start_object();
for (key_131, value_132) in var_129 {
{
object_130.key(key_131.as_str()).string(value_132.as_str());
}
}
object_130.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_billing_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBillingGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_133) = &input.arn {
object.key("Arn").string(var_133.as_str());
}
if let Some(var_134) = &input.computation_preference {
#[allow(unused_mut)]
let mut object_135 = object.key("ComputationPreference").start_object();
crate::json_ser::serialize_structure_crate_model_computation_preference(
&mut object_135,
var_134,
)?;
object_135.finish();
}
if let Some(var_136) = &input.description {
object.key("Description").string(var_136.as_str());
}
if let Some(var_137) = &input.name {
object.key("Name").string(var_137.as_str());
}
if let Some(var_138) = &input.status {
object.key("Status").string(var_138.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_custom_line_item_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateCustomLineItemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_139) = &input.arn {
object.key("Arn").string(var_139.as_str());
}
if let Some(var_140) = &input.billing_period_range {
#[allow(unused_mut)]
let mut object_141 = object.key("BillingPeriodRange").start_object();
crate::json_ser::serialize_structure_crate_model_custom_line_item_billing_period_range(
&mut object_141,
var_140,
)?;
object_141.finish();
}
if let Some(var_142) = &input.charge_details {
#[allow(unused_mut)]
let mut object_143 = object.key("ChargeDetails").start_object();
crate::json_ser::serialize_structure_crate_model_update_custom_line_item_charge_details(
&mut object_143,
var_142,
)?;
object_143.finish();
}
if let Some(var_144) = &input.description {
object.key("Description").string(var_144.as_str());
}
if let Some(var_145) = &input.name {
object.key("Name").string(var_145.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_pricing_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePricingPlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.arn {
object.key("Arn").string(var_146.as_str());
}
if let Some(var_147) = &input.description {
object.key("Description").string(var_147.as_str());
}
if let Some(var_148) = &input.name {
object.key("Name").string(var_148.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_pricing_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePricingRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_149) = &input.arn {
object.key("Arn").string(var_149.as_str());
}
if let Some(var_150) = &input.description {
object.key("Description").string(var_150.as_str());
}
if let Some(var_151) = &input.modifier_percentage {
object.key("ModifierPercentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_151).into()),
);
}
if let Some(var_152) = &input.name {
object.key("Name").string(var_152.as_str());
}
if let Some(var_153) = &input.tiering {
#[allow(unused_mut)]
let mut object_154 = object.key("Tiering").start_object();
crate::json_ser::serialize_structure_crate_model_update_tiering_input(
&mut object_154,
var_153,
)?;
object_154.finish();
}
if let Some(var_155) = &input.r#type {
object.key("Type").string(var_155.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_line_item_billing_period_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomLineItemBillingPeriodRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.inclusive_start_billing_period {
object
.key("InclusiveStartBillingPeriod")
.string(var_156.as_str());
}
if let Some(var_157) = &input.exclusive_end_billing_period {
object
.key("ExclusiveEndBillingPeriod")
.string(var_157.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_account_grouping(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AccountGrouping,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_158) = &input.linked_account_ids {
let mut array_159 = object.key("LinkedAccountIds").start_array();
for item_160 in var_158 {
{
array_159.value().string(item_160.as_str());
}
}
array_159.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_computation_preference(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComputationPreference,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_161) = &input.pricing_plan_arn {
object.key("PricingPlanArn").string(var_161.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_line_item_charge_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomLineItemChargeDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_162) = &input.flat {
#[allow(unused_mut)]
let mut object_163 = object.key("Flat").start_object();
crate::json_ser::serialize_structure_crate_model_custom_line_item_flat_charge_details(
&mut object_163,
var_162,
)?;
object_163.finish();
}
if let Some(var_164) = &input.percentage {
#[allow(unused_mut)]
let mut object_165 = object.key("Percentage").start_object();
crate::json_ser::serialize_structure_crate_model_custom_line_item_percentage_charge_details(&mut object_165, var_164)?;
object_165.finish();
}
if let Some(var_166) = &input.r#type {
object.key("Type").string(var_166.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_create_tiering_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateTieringInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_167) = &input.free_tier {
#[allow(unused_mut)]
let mut object_168 = object.key("FreeTier").start_object();
crate::json_ser::serialize_structure_crate_model_create_free_tier_config(
&mut object_168,
var_167,
)?;
object_168.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_list_account_associations_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListAccountAssociationsFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_169) = &input.association {
object.key("Association").string(var_169.as_str());
}
if let Some(var_170) = &input.account_id {
object.key("AccountId").string(var_170.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_list_billing_group_cost_reports_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListBillingGroupCostReportsFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_171) = &input.billing_group_arns {
let mut array_172 = object.key("BillingGroupArns").start_array();
for item_173 in var_171 {
{
array_172.value().string(item_173.as_str());
}
}
array_172.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_list_billing_groups_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListBillingGroupsFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_174) = &input.arns {
let mut array_175 = object.key("Arns").start_array();
for item_176 in var_174 {
{
array_175.value().string(item_176.as_str());
}
}
array_175.finish();
}
if let Some(var_177) = &input.pricing_plan {
object.key("PricingPlan").string(var_177.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_list_custom_line_items_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListCustomLineItemsFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_178) = &input.names {
let mut array_179 = object.key("Names").start_array();
for item_180 in var_178 {
{
array_179.value().string(item_180.as_str());
}
}
array_179.finish();
}
if let Some(var_181) = &input.billing_groups {
let mut array_182 = object.key("BillingGroups").start_array();
for item_183 in var_181 {
{
array_182.value().string(item_183.as_str());
}
}
array_182.finish();
}
if let Some(var_184) = &input.arns {
let mut array_185 = object.key("Arns").start_array();
for item_186 in var_184 {
{
array_185.value().string(item_186.as_str());
}
}
array_185.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_list_custom_line_item_versions_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListCustomLineItemVersionsFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_187) = &input.billing_period_range {
#[allow(unused_mut)]
let mut object_188 = object.key("BillingPeriodRange").start_object();
crate::json_ser::serialize_structure_crate_model_list_custom_line_item_versions_billing_period_range_filter(&mut object_188, var_187)?;
object_188.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_list_pricing_plans_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListPricingPlansFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_189) = &input.arns {
let mut array_190 = object.key("Arns").start_array();
for item_191 in var_189 {
{
array_190.value().string(item_191.as_str());
}
}
array_190.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_list_pricing_rules_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListPricingRulesFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_192) = &input.arns {
let mut array_193 = object.key("Arns").start_array();
for item_194 in var_192 {
{
array_193.value().string(item_194.as_str());
}
}
array_193.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_list_resources_associated_to_custom_line_item_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListResourcesAssociatedToCustomLineItemFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_195) = &input.relationship {
object.key("Relationship").string(var_195.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_custom_line_item_charge_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateCustomLineItemChargeDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_196) = &input.flat {
#[allow(unused_mut)]
let mut object_197 = object.key("Flat").start_object();
crate::json_ser::serialize_structure_crate_model_update_custom_line_item_flat_charge_details(&mut object_197, var_196)?;
object_197.finish();
}
if let Some(var_198) = &input.percentage {
#[allow(unused_mut)]
let mut object_199 = object.key("Percentage").start_object();
crate::json_ser::serialize_structure_crate_model_update_custom_line_item_percentage_charge_details(&mut object_199, var_198)?;
object_199.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_tiering_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateTieringInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_200) = &input.free_tier {
#[allow(unused_mut)]
let mut object_201 = object.key("FreeTier").start_object();
crate::json_ser::serialize_structure_crate_model_update_free_tier_config(
&mut object_201,
var_200,
)?;
object_201.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_line_item_flat_charge_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomLineItemFlatChargeDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_202) = &input.charge_value {
object.key("ChargeValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_202).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_line_item_percentage_charge_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomLineItemPercentageChargeDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_203) = &input.percentage_value {
object.key("PercentageValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_203).into()),
);
}
if let Some(var_204) = &input.associated_values {
let mut array_205 = object.key("AssociatedValues").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_create_free_tier_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateFreeTierConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_207) = &input.activated {
object.key("Activated").boolean(*var_207);
}
Ok(())
}
pub fn serialize_structure_crate_model_list_custom_line_item_versions_billing_period_range_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListCustomLineItemVersionsBillingPeriodRangeFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_208) = &input.start_billing_period {
object.key("StartBillingPeriod").string(var_208.as_str());
}
if let Some(var_209) = &input.end_billing_period {
object.key("EndBillingPeriod").string(var_209.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_custom_line_item_flat_charge_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateCustomLineItemFlatChargeDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_210) = &input.charge_value {
object.key("ChargeValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_210).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_update_custom_line_item_percentage_charge_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateCustomLineItemPercentageChargeDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_211) = &input.percentage_value {
object.key("PercentageValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_211).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_update_free_tier_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateFreeTierConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_212) = &input.activated {
object.key("Activated").boolean(*var_212);
}
Ok(())
}