pub fn serialize_structure_crate_input_accept_grant_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AcceptGrantInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.grant_arn {
object.key("GrantArn").string(var_1.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_check_in_license_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CheckInLicenseInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2) = &input.license_consumption_token {
object.key("LicenseConsumptionToken").string(var_2.as_str());
}
if let Some(var_3) = &input.beneficiary {
object.key("Beneficiary").string(var_3.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_checkout_borrow_license_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CheckoutBorrowLicenseInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_4) = &input.license_arn {
object.key("LicenseArn").string(var_4.as_str());
}
if let Some(var_5) = &input.entitlements {
let mut array_6 = object.key("Entitlements").start_array();
for item_7 in var_5 {
{
#[allow(unused_mut)]
let mut object_8 = array_6.value().start_object();
crate::json_ser::serialize_structure_crate_model_entitlement_data(
&mut object_8,
item_7,
)?;
object_8.finish();
}
}
array_6.finish();
}
if let Some(var_9) = &input.digital_signature_method {
object.key("DigitalSignatureMethod").string(var_9.as_str());
}
if let Some(var_10) = &input.node_id {
object.key("NodeId").string(var_10.as_str());
}
if let Some(var_11) = &input.checkout_metadata {
let mut array_12 = object.key("CheckoutMetadata").start_array();
for item_13 in var_11 {
{
#[allow(unused_mut)]
let mut object_14 = array_12.value().start_object();
crate::json_ser::serialize_structure_crate_model_metadata(&mut object_14, item_13)?;
object_14.finish();
}
}
array_12.finish();
}
if let Some(var_15) = &input.client_token {
object.key("ClientToken").string(var_15.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_checkout_license_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CheckoutLicenseInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.product_sku {
object.key("ProductSKU").string(var_16.as_str());
}
if let Some(var_17) = &input.checkout_type {
object.key("CheckoutType").string(var_17.as_str());
}
if let Some(var_18) = &input.key_fingerprint {
object.key("KeyFingerprint").string(var_18.as_str());
}
if let Some(var_19) = &input.entitlements {
let mut array_20 = object.key("Entitlements").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_entitlement_data(
&mut object_22,
item_21,
)?;
object_22.finish();
}
}
array_20.finish();
}
if let Some(var_23) = &input.client_token {
object.key("ClientToken").string(var_23.as_str());
}
if let Some(var_24) = &input.beneficiary {
object.key("Beneficiary").string(var_24.as_str());
}
if let Some(var_25) = &input.node_id {
object.key("NodeId").string(var_25.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_grant_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateGrantInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_26) = &input.client_token {
object.key("ClientToken").string(var_26.as_str());
}
if let Some(var_27) = &input.grant_name {
object.key("GrantName").string(var_27.as_str());
}
if let Some(var_28) = &input.license_arn {
object.key("LicenseArn").string(var_28.as_str());
}
if let Some(var_29) = &input.principals {
let mut array_30 = object.key("Principals").start_array();
for item_31 in var_29 {
{
array_30.value().string(item_31.as_str());
}
}
array_30.finish();
}
if let Some(var_32) = &input.home_region {
object.key("HomeRegion").string(var_32.as_str());
}
if let Some(var_33) = &input.allowed_operations {
let mut array_34 = object.key("AllowedOperations").start_array();
for item_35 in var_33 {
{
array_34.value().string(item_35.as_str());
}
}
array_34.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_grant_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateGrantVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_36) = &input.client_token {
object.key("ClientToken").string(var_36.as_str());
}
if let Some(var_37) = &input.grant_arn {
object.key("GrantArn").string(var_37.as_str());
}
if let Some(var_38) = &input.grant_name {
object.key("GrantName").string(var_38.as_str());
}
if let Some(var_39) = &input.allowed_operations {
let mut array_40 = object.key("AllowedOperations").start_array();
for item_41 in var_39 {
{
array_40.value().string(item_41.as_str());
}
}
array_40.finish();
}
if let Some(var_42) = &input.status {
object.key("Status").string(var_42.as_str());
}
if let Some(var_43) = &input.status_reason {
object.key("StatusReason").string(var_43.as_str());
}
if let Some(var_44) = &input.source_version {
object.key("SourceVersion").string(var_44.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_license_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLicenseInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_45) = &input.license_name {
object.key("LicenseName").string(var_45.as_str());
}
if let Some(var_46) = &input.product_name {
object.key("ProductName").string(var_46.as_str());
}
if let Some(var_47) = &input.product_sku {
object.key("ProductSKU").string(var_47.as_str());
}
if let Some(var_48) = &input.issuer {
#[allow(unused_mut)]
let mut object_49 = object.key("Issuer").start_object();
crate::json_ser::serialize_structure_crate_model_issuer(&mut object_49, var_48)?;
object_49.finish();
}
if let Some(var_50) = &input.home_region {
object.key("HomeRegion").string(var_50.as_str());
}
if let Some(var_51) = &input.validity {
#[allow(unused_mut)]
let mut object_52 = object.key("Validity").start_object();
crate::json_ser::serialize_structure_crate_model_datetime_range(&mut object_52, var_51)?;
object_52.finish();
}
if let Some(var_53) = &input.entitlements {
let mut array_54 = object.key("Entitlements").start_array();
for item_55 in var_53 {
{
#[allow(unused_mut)]
let mut object_56 = array_54.value().start_object();
crate::json_ser::serialize_structure_crate_model_entitlement(
&mut object_56,
item_55,
)?;
object_56.finish();
}
}
array_54.finish();
}
if let Some(var_57) = &input.beneficiary {
object.key("Beneficiary").string(var_57.as_str());
}
if let Some(var_58) = &input.consumption_configuration {
#[allow(unused_mut)]
let mut object_59 = object.key("ConsumptionConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_consumption_configuration(
&mut object_59,
var_58,
)?;
object_59.finish();
}
if let Some(var_60) = &input.license_metadata {
let mut array_61 = object.key("LicenseMetadata").start_array();
for item_62 in var_60 {
{
#[allow(unused_mut)]
let mut object_63 = array_61.value().start_object();
crate::json_ser::serialize_structure_crate_model_metadata(&mut object_63, item_62)?;
object_63.finish();
}
}
array_61.finish();
}
if let Some(var_64) = &input.client_token {
object.key("ClientToken").string(var_64.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_license_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLicenseConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_65) = &input.name {
object.key("Name").string(var_65.as_str());
}
if let Some(var_66) = &input.description {
object.key("Description").string(var_66.as_str());
}
if let Some(var_67) = &input.license_counting_type {
object.key("LicenseCountingType").string(var_67.as_str());
}
if let Some(var_68) = &input.license_count {
object.key("LicenseCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_68).into()),
);
}
if let Some(var_69) = &input.license_count_hard_limit {
object.key("LicenseCountHardLimit").boolean(*var_69);
}
if let Some(var_70) = &input.license_rules {
let mut array_71 = object.key("LicenseRules").start_array();
for item_72 in var_70 {
{
array_71.value().string(item_72.as_str());
}
}
array_71.finish();
}
if let Some(var_73) = &input.tags {
let mut array_74 = object.key("Tags").start_array();
for item_75 in var_73 {
{
#[allow(unused_mut)]
let mut object_76 = array_74.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_76, item_75)?;
object_76.finish();
}
}
array_74.finish();
}
if let Some(var_77) = &input.disassociate_when_not_found {
object.key("DisassociateWhenNotFound").boolean(*var_77);
}
if let Some(var_78) = &input.product_information_list {
let mut array_79 = object.key("ProductInformationList").start_array();
for item_80 in var_78 {
{
#[allow(unused_mut)]
let mut object_81 = array_79.value().start_object();
crate::json_ser::serialize_structure_crate_model_product_information(
&mut object_81,
item_80,
)?;
object_81.finish();
}
}
array_79.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_license_conversion_task_for_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLicenseConversionTaskForResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_82) = &input.resource_arn {
object.key("ResourceArn").string(var_82.as_str());
}
if let Some(var_83) = &input.source_license_context {
#[allow(unused_mut)]
let mut object_84 = object.key("SourceLicenseContext").start_object();
crate::json_ser::serialize_structure_crate_model_license_conversion_context(
&mut object_84,
var_83,
)?;
object_84.finish();
}
if let Some(var_85) = &input.destination_license_context {
#[allow(unused_mut)]
let mut object_86 = object.key("DestinationLicenseContext").start_object();
crate::json_ser::serialize_structure_crate_model_license_conversion_context(
&mut object_86,
var_85,
)?;
object_86.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_license_manager_report_generator_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLicenseManagerReportGeneratorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.report_generator_name {
object.key("ReportGeneratorName").string(var_87.as_str());
}
if let Some(var_88) = &input.r#type {
let mut array_89 = object.key("Type").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.report_context {
#[allow(unused_mut)]
let mut object_92 = object.key("ReportContext").start_object();
crate::json_ser::serialize_structure_crate_model_report_context(&mut object_92, var_91)?;
object_92.finish();
}
if let Some(var_93) = &input.report_frequency {
#[allow(unused_mut)]
let mut object_94 = object.key("ReportFrequency").start_object();
crate::json_ser::serialize_structure_crate_model_report_frequency(&mut object_94, var_93)?;
object_94.finish();
}
if let Some(var_95) = &input.client_token {
object.key("ClientToken").string(var_95.as_str());
}
if let Some(var_96) = &input.description {
object.key("Description").string(var_96.as_str());
}
if let Some(var_97) = &input.tags {
let mut array_98 = object.key("Tags").start_array();
for item_99 in var_97 {
{
#[allow(unused_mut)]
let mut object_100 = array_98.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_100, item_99)?;
object_100.finish();
}
}
array_98.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_license_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLicenseVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.license_arn {
object.key("LicenseArn").string(var_101.as_str());
}
if let Some(var_102) = &input.license_name {
object.key("LicenseName").string(var_102.as_str());
}
if let Some(var_103) = &input.product_name {
object.key("ProductName").string(var_103.as_str());
}
if let Some(var_104) = &input.issuer {
#[allow(unused_mut)]
let mut object_105 = object.key("Issuer").start_object();
crate::json_ser::serialize_structure_crate_model_issuer(&mut object_105, var_104)?;
object_105.finish();
}
if let Some(var_106) = &input.home_region {
object.key("HomeRegion").string(var_106.as_str());
}
if let Some(var_107) = &input.validity {
#[allow(unused_mut)]
let mut object_108 = object.key("Validity").start_object();
crate::json_ser::serialize_structure_crate_model_datetime_range(&mut object_108, var_107)?;
object_108.finish();
}
if let Some(var_109) = &input.license_metadata {
let mut array_110 = object.key("LicenseMetadata").start_array();
for item_111 in var_109 {
{
#[allow(unused_mut)]
let mut object_112 = array_110.value().start_object();
crate::json_ser::serialize_structure_crate_model_metadata(
&mut object_112,
item_111,
)?;
object_112.finish();
}
}
array_110.finish();
}
if let Some(var_113) = &input.entitlements {
let mut array_114 = object.key("Entitlements").start_array();
for item_115 in var_113 {
{
#[allow(unused_mut)]
let mut object_116 = array_114.value().start_object();
crate::json_ser::serialize_structure_crate_model_entitlement(
&mut object_116,
item_115,
)?;
object_116.finish();
}
}
array_114.finish();
}
if let Some(var_117) = &input.consumption_configuration {
#[allow(unused_mut)]
let mut object_118 = object.key("ConsumptionConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_consumption_configuration(
&mut object_118,
var_117,
)?;
object_118.finish();
}
if let Some(var_119) = &input.status {
object.key("Status").string(var_119.as_str());
}
if let Some(var_120) = &input.client_token {
object.key("ClientToken").string(var_120.as_str());
}
if let Some(var_121) = &input.source_version {
object.key("SourceVersion").string(var_121.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_token_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTokenInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_122) = &input.license_arn {
object.key("LicenseArn").string(var_122.as_str());
}
if let Some(var_123) = &input.role_arns {
let mut array_124 = object.key("RoleArns").start_array();
for item_125 in var_123 {
{
array_124.value().string(item_125.as_str());
}
}
array_124.finish();
}
if let Some(var_126) = &input.expiration_in_days {
object.key("ExpirationInDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_126).into()),
);
}
if let Some(var_127) = &input.token_properties {
let mut array_128 = object.key("TokenProperties").start_array();
for item_129 in var_127 {
{
array_128.value().string(item_129.as_str());
}
}
array_128.finish();
}
if let Some(var_130) = &input.client_token {
object.key("ClientToken").string(var_130.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_grant_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteGrantInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_131) = &input.grant_arn {
object.key("GrantArn").string(var_131.as_str());
}
if let Some(var_132) = &input.status_reason {
object.key("StatusReason").string(var_132.as_str());
}
if let Some(var_133) = &input.version {
object.key("Version").string(var_133.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_license_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteLicenseInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_134) = &input.license_arn {
object.key("LicenseArn").string(var_134.as_str());
}
if let Some(var_135) = &input.source_version {
object.key("SourceVersion").string(var_135.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_license_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteLicenseConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_136) = &input.license_configuration_arn {
object
.key("LicenseConfigurationArn")
.string(var_136.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_license_manager_report_generator_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteLicenseManagerReportGeneratorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_137) = &input.license_manager_report_generator_arn {
object
.key("LicenseManagerReportGeneratorArn")
.string(var_137.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_token_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteTokenInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_138) = &input.token_id {
object.key("TokenId").string(var_138.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_extend_license_consumption_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ExtendLicenseConsumptionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_139) = &input.license_consumption_token {
object
.key("LicenseConsumptionToken")
.string(var_139.as_str());
}
if input.dry_run {
object.key("DryRun").boolean(input.dry_run);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_access_token_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAccessTokenInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_140) = &input.token {
object.key("Token").string(var_140.as_str());
}
if let Some(var_141) = &input.token_properties {
let mut array_142 = object.key("TokenProperties").start_array();
for item_143 in var_141 {
{
array_142.value().string(item_143.as_str());
}
}
array_142.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_grant_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetGrantInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_144) = &input.grant_arn {
object.key("GrantArn").string(var_144.as_str());
}
if let Some(var_145) = &input.version {
object.key("Version").string(var_145.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_license_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetLicenseInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.license_arn {
object.key("LicenseArn").string(var_146.as_str());
}
if let Some(var_147) = &input.version {
object.key("Version").string(var_147.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_license_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetLicenseConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_148) = &input.license_configuration_arn {
object
.key("LicenseConfigurationArn")
.string(var_148.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_license_conversion_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetLicenseConversionTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_149) = &input.license_conversion_task_id {
object
.key("LicenseConversionTaskId")
.string(var_149.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_license_manager_report_generator_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetLicenseManagerReportGeneratorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_150) = &input.license_manager_report_generator_arn {
object
.key("LicenseManagerReportGeneratorArn")
.string(var_150.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_license_usage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetLicenseUsageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_151) = &input.license_arn {
object.key("LicenseArn").string(var_151.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_associations_for_license_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAssociationsForLicenseConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_152) = &input.license_configuration_arn {
object
.key("LicenseConfigurationArn")
.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()),
);
}
if let Some(var_154) = &input.next_token {
object.key("NextToken").string(var_154.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_distributed_grants_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDistributedGrantsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_155) = &input.grant_arns {
let mut array_156 = object.key("GrantArns").start_array();
for item_157 in var_155 {
{
array_156.value().string(item_157.as_str());
}
}
array_156.finish();
}
if let Some(var_158) = &input.filters {
let mut array_159 = object.key("Filters").start_array();
for item_160 in var_158 {
{
#[allow(unused_mut)]
let mut object_161 = array_159.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_161, item_160)?;
object_161.finish();
}
}
array_159.finish();
}
if let Some(var_162) = &input.next_token {
object.key("NextToken").string(var_162.as_str());
}
if let Some(var_163) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_163).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_failures_for_license_configuration_operations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFailuresForLicenseConfigurationOperationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_164) = &input.license_configuration_arn {
object
.key("LicenseConfigurationArn")
.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()),
);
}
if let Some(var_166) = &input.next_token {
object.key("NextToken").string(var_166.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_license_configurations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListLicenseConfigurationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_167) = &input.license_configuration_arns {
let mut array_168 = object.key("LicenseConfigurationArns").start_array();
for item_169 in var_167 {
{
array_168.value().string(item_169.as_str());
}
}
array_168.finish();
}
if let Some(var_170) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_170).into()),
);
}
if let Some(var_171) = &input.next_token {
object.key("NextToken").string(var_171.as_str());
}
if let Some(var_172) = &input.filters {
let mut array_173 = object.key("Filters").start_array();
for item_174 in var_172 {
{
#[allow(unused_mut)]
let mut object_175 = array_173.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_175, item_174)?;
object_175.finish();
}
}
array_173.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_license_conversion_tasks_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListLicenseConversionTasksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_176) = &input.next_token {
object.key("NextToken").string(var_176.as_str());
}
if let Some(var_177) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_177).into()),
);
}
if let Some(var_178) = &input.filters {
let mut array_179 = object.key("Filters").start_array();
for item_180 in var_178 {
{
#[allow(unused_mut)]
let mut object_181 = array_179.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_181, item_180)?;
object_181.finish();
}
}
array_179.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_license_manager_report_generators_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListLicenseManagerReportGeneratorsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_182) = &input.filters {
let mut array_183 = object.key("Filters").start_array();
for item_184 in var_182 {
{
#[allow(unused_mut)]
let mut object_185 = array_183.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_185, item_184)?;
object_185.finish();
}
}
array_183.finish();
}
if let Some(var_186) = &input.next_token {
object.key("NextToken").string(var_186.as_str());
}
if let Some(var_187) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_187).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_licenses_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListLicensesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_188) = &input.license_arns {
let mut array_189 = object.key("LicenseArns").start_array();
for item_190 in var_188 {
{
array_189.value().string(item_190.as_str());
}
}
array_189.finish();
}
if let Some(var_191) = &input.filters {
let mut array_192 = object.key("Filters").start_array();
for item_193 in var_191 {
{
#[allow(unused_mut)]
let mut object_194 = array_192.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_194, item_193)?;
object_194.finish();
}
}
array_192.finish();
}
if let Some(var_195) = &input.next_token {
object.key("NextToken").string(var_195.as_str());
}
if let Some(var_196) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_196).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_license_specifications_for_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListLicenseSpecificationsForResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.resource_arn {
object.key("ResourceArn").string(var_197.as_str());
}
if let Some(var_198) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_198).into()),
);
}
if let Some(var_199) = &input.next_token {
object.key("NextToken").string(var_199.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_license_versions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListLicenseVersionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_200) = &input.license_arn {
object.key("LicenseArn").string(var_200.as_str());
}
if let Some(var_201) = &input.next_token {
object.key("NextToken").string(var_201.as_str());
}
if let Some(var_202) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_202).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_received_grants_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListReceivedGrantsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_203) = &input.grant_arns {
let mut array_204 = object.key("GrantArns").start_array();
for item_205 in var_203 {
{
array_204.value().string(item_205.as_str());
}
}
array_204.finish();
}
if let Some(var_206) = &input.filters {
let mut array_207 = object.key("Filters").start_array();
for item_208 in var_206 {
{
#[allow(unused_mut)]
let mut object_209 = array_207.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_209, item_208)?;
object_209.finish();
}
}
array_207.finish();
}
if let Some(var_210) = &input.next_token {
object.key("NextToken").string(var_210.as_str());
}
if let Some(var_211) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_211).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_received_grants_for_organization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListReceivedGrantsForOrganizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_212) = &input.license_arn {
object.key("LicenseArn").string(var_212.as_str());
}
if let Some(var_213) = &input.filters {
let mut array_214 = object.key("Filters").start_array();
for item_215 in var_213 {
{
#[allow(unused_mut)]
let mut object_216 = array_214.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_216, item_215)?;
object_216.finish();
}
}
array_214.finish();
}
if let Some(var_217) = &input.next_token {
object.key("NextToken").string(var_217.as_str());
}
if let Some(var_218) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_218).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_received_licenses_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListReceivedLicensesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_219) = &input.license_arns {
let mut array_220 = object.key("LicenseArns").start_array();
for item_221 in var_219 {
{
array_220.value().string(item_221.as_str());
}
}
array_220.finish();
}
if let Some(var_222) = &input.filters {
let mut array_223 = object.key("Filters").start_array();
for item_224 in var_222 {
{
#[allow(unused_mut)]
let mut object_225 = array_223.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_225, item_224)?;
object_225.finish();
}
}
array_223.finish();
}
if let Some(var_226) = &input.next_token {
object.key("NextToken").string(var_226.as_str());
}
if let Some(var_227) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_227).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_received_licenses_for_organization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListReceivedLicensesForOrganizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_228) = &input.filters {
let mut array_229 = object.key("Filters").start_array();
for item_230 in var_228 {
{
#[allow(unused_mut)]
let mut object_231 = array_229.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_231, item_230)?;
object_231.finish();
}
}
array_229.finish();
}
if let Some(var_232) = &input.next_token {
object.key("NextToken").string(var_232.as_str());
}
if let Some(var_233) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_233).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_resource_inventory_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListResourceInventoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_234) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_234).into()),
);
}
if let Some(var_235) = &input.next_token {
object.key("NextToken").string(var_235.as_str());
}
if let Some(var_236) = &input.filters {
let mut array_237 = object.key("Filters").start_array();
for item_238 in var_236 {
{
#[allow(unused_mut)]
let mut object_239 = array_237.value().start_object();
crate::json_ser::serialize_structure_crate_model_inventory_filter(
&mut object_239,
item_238,
)?;
object_239.finish();
}
}
array_237.finish();
}
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_240) = &input.resource_arn {
object.key("ResourceArn").string(var_240.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tokens_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTokensInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_241) = &input.token_ids {
let mut array_242 = object.key("TokenIds").start_array();
for item_243 in var_241 {
{
array_242.value().string(item_243.as_str());
}
}
array_242.finish();
}
if let Some(var_244) = &input.filters {
let mut array_245 = object.key("Filters").start_array();
for item_246 in var_244 {
{
#[allow(unused_mut)]
let mut object_247 = array_245.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_247, item_246)?;
object_247.finish();
}
}
array_245.finish();
}
if let Some(var_248) = &input.next_token {
object.key("NextToken").string(var_248.as_str());
}
if let Some(var_249) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_249).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_usage_for_license_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListUsageForLicenseConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_250) = &input.license_configuration_arn {
object
.key("LicenseConfigurationArn")
.string(var_250.as_str());
}
if let Some(var_251) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_251).into()),
);
}
if let Some(var_252) = &input.next_token {
object.key("NextToken").string(var_252.as_str());
}
if let Some(var_253) = &input.filters {
let mut array_254 = object.key("Filters").start_array();
for item_255 in var_253 {
{
#[allow(unused_mut)]
let mut object_256 = array_254.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_256, item_255)?;
object_256.finish();
}
}
array_254.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_reject_grant_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RejectGrantInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_257) = &input.grant_arn {
object.key("GrantArn").string(var_257.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_258) = &input.resource_arn {
object.key("ResourceArn").string(var_258.as_str());
}
if let Some(var_259) = &input.tags {
let mut array_260 = object.key("Tags").start_array();
for item_261 in var_259 {
{
#[allow(unused_mut)]
let mut object_262 = array_260.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_262, item_261)?;
object_262.finish();
}
}
array_260.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_263) = &input.resource_arn {
object.key("ResourceArn").string(var_263.as_str());
}
if let Some(var_264) = &input.tag_keys {
let mut array_265 = object.key("TagKeys").start_array();
for item_266 in var_264 {
{
array_265.value().string(item_266.as_str());
}
}
array_265.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_license_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateLicenseConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_267) = &input.license_configuration_arn {
object
.key("LicenseConfigurationArn")
.string(var_267.as_str());
}
if let Some(var_268) = &input.license_configuration_status {
object
.key("LicenseConfigurationStatus")
.string(var_268.as_str());
}
if let Some(var_269) = &input.license_rules {
let mut array_270 = object.key("LicenseRules").start_array();
for item_271 in var_269 {
{
array_270.value().string(item_271.as_str());
}
}
array_270.finish();
}
if let Some(var_272) = &input.license_count {
object.key("LicenseCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_272).into()),
);
}
if let Some(var_273) = &input.license_count_hard_limit {
object.key("LicenseCountHardLimit").boolean(*var_273);
}
if let Some(var_274) = &input.name {
object.key("Name").string(var_274.as_str());
}
if let Some(var_275) = &input.description {
object.key("Description").string(var_275.as_str());
}
if let Some(var_276) = &input.product_information_list {
let mut array_277 = object.key("ProductInformationList").start_array();
for item_278 in var_276 {
{
#[allow(unused_mut)]
let mut object_279 = array_277.value().start_object();
crate::json_ser::serialize_structure_crate_model_product_information(
&mut object_279,
item_278,
)?;
object_279.finish();
}
}
array_277.finish();
}
if let Some(var_280) = &input.disassociate_when_not_found {
object.key("DisassociateWhenNotFound").boolean(*var_280);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_license_manager_report_generator_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateLicenseManagerReportGeneratorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_281) = &input.license_manager_report_generator_arn {
object
.key("LicenseManagerReportGeneratorArn")
.string(var_281.as_str());
}
if let Some(var_282) = &input.report_generator_name {
object.key("ReportGeneratorName").string(var_282.as_str());
}
if let Some(var_283) = &input.r#type {
let mut array_284 = object.key("Type").start_array();
for item_285 in var_283 {
{
array_284.value().string(item_285.as_str());
}
}
array_284.finish();
}
if let Some(var_286) = &input.report_context {
#[allow(unused_mut)]
let mut object_287 = object.key("ReportContext").start_object();
crate::json_ser::serialize_structure_crate_model_report_context(&mut object_287, var_286)?;
object_287.finish();
}
if let Some(var_288) = &input.report_frequency {
#[allow(unused_mut)]
let mut object_289 = object.key("ReportFrequency").start_object();
crate::json_ser::serialize_structure_crate_model_report_frequency(
&mut object_289,
var_288,
)?;
object_289.finish();
}
if let Some(var_290) = &input.client_token {
object.key("ClientToken").string(var_290.as_str());
}
if let Some(var_291) = &input.description {
object.key("Description").string(var_291.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_license_specifications_for_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateLicenseSpecificationsForResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_292) = &input.resource_arn {
object.key("ResourceArn").string(var_292.as_str());
}
if let Some(var_293) = &input.add_license_specifications {
let mut array_294 = object.key("AddLicenseSpecifications").start_array();
for item_295 in var_293 {
{
#[allow(unused_mut)]
let mut object_296 = array_294.value().start_object();
crate::json_ser::serialize_structure_crate_model_license_specification(
&mut object_296,
item_295,
)?;
object_296.finish();
}
}
array_294.finish();
}
if let Some(var_297) = &input.remove_license_specifications {
let mut array_298 = object.key("RemoveLicenseSpecifications").start_array();
for item_299 in var_297 {
{
#[allow(unused_mut)]
let mut object_300 = array_298.value().start_object();
crate::json_ser::serialize_structure_crate_model_license_specification(
&mut object_300,
item_299,
)?;
object_300.finish();
}
}
array_298.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_service_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateServiceSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_301) = &input.s3_bucket_arn {
object.key("S3BucketArn").string(var_301.as_str());
}
if let Some(var_302) = &input.sns_topic_arn {
object.key("SnsTopicArn").string(var_302.as_str());
}
if let Some(var_303) = &input.organization_configuration {
#[allow(unused_mut)]
let mut object_304 = object.key("OrganizationConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_organization_configuration(
&mut object_304,
var_303,
)?;
object_304.finish();
}
if let Some(var_305) = &input.enable_cross_accounts_discovery {
object.key("EnableCrossAccountsDiscovery").boolean(*var_305);
}
Ok(())
}
pub fn serialize_structure_crate_model_entitlement_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EntitlementData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_306) = &input.name {
object.key("Name").string(var_306.as_str());
}
if let Some(var_307) = &input.value {
object.key("Value").string(var_307.as_str());
}
if let Some(var_308) = &input.unit {
object.key("Unit").string(var_308.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_metadata(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Metadata,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_309) = &input.name {
object.key("Name").string(var_309.as_str());
}
if let Some(var_310) = &input.value {
object.key("Value").string(var_310.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_issuer(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Issuer,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_311) = &input.name {
object.key("Name").string(var_311.as_str());
}
if let Some(var_312) = &input.sign_key {
object.key("SignKey").string(var_312.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_datetime_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatetimeRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_313) = &input.begin {
object.key("Begin").string(var_313.as_str());
}
if let Some(var_314) = &input.end {
object.key("End").string(var_314.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_entitlement(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Entitlement,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_315) = &input.name {
object.key("Name").string(var_315.as_str());
}
if let Some(var_316) = &input.value {
object.key("Value").string(var_316.as_str());
}
if let Some(var_317) = &input.max_count {
object.key("MaxCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_317).into()),
);
}
if let Some(var_318) = &input.overage {
object.key("Overage").boolean(*var_318);
}
if let Some(var_319) = &input.unit {
object.key("Unit").string(var_319.as_str());
}
if let Some(var_320) = &input.allow_check_in {
object.key("AllowCheckIn").boolean(*var_320);
}
Ok(())
}
pub fn serialize_structure_crate_model_consumption_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConsumptionConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_321) = &input.renew_type {
object.key("RenewType").string(var_321.as_str());
}
if let Some(var_322) = &input.provisional_configuration {
#[allow(unused_mut)]
let mut object_323 = object.key("ProvisionalConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_provisional_configuration(
&mut object_323,
var_322,
)?;
object_323.finish();
}
if let Some(var_324) = &input.borrow_configuration {
#[allow(unused_mut)]
let mut object_325 = object.key("BorrowConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_borrow_configuration(
&mut object_325,
var_324,
)?;
object_325.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_326) = &input.key {
object.key("Key").string(var_326.as_str());
}
if let Some(var_327) = &input.value {
object.key("Value").string(var_327.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_product_information(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProductInformation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_328) = &input.resource_type {
object.key("ResourceType").string(var_328.as_str());
}
if let Some(var_329) = &input.product_information_filter_list {
let mut array_330 = object.key("ProductInformationFilterList").start_array();
for item_331 in var_329 {
{
#[allow(unused_mut)]
let mut object_332 = array_330.value().start_object();
crate::json_ser::serialize_structure_crate_model_product_information_filter(
&mut object_332,
item_331,
)?;
object_332.finish();
}
}
array_330.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_license_conversion_context(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LicenseConversionContext,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_333) = &input.usage_operation {
object.key("UsageOperation").string(var_333.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_report_context(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReportContext,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_334) = &input.license_configuration_arns {
let mut array_335 = object.key("licenseConfigurationArns").start_array();
for item_336 in var_334 {
{
array_335.value().string(item_336.as_str());
}
}
array_335.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_report_frequency(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReportFrequency,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_337) = &input.value {
object.key("value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_337).into()),
);
}
if let Some(var_338) = &input.period {
object.key("period").string(var_338.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Filter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_339) = &input.name {
object.key("Name").string(var_339.as_str());
}
if let Some(var_340) = &input.values {
let mut array_341 = object.key("Values").start_array();
for item_342 in var_340 {
{
array_341.value().string(item_342.as_str());
}
}
array_341.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_inventory_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InventoryFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_343) = &input.name {
object.key("Name").string(var_343.as_str());
}
if let Some(var_344) = &input.condition {
object.key("Condition").string(var_344.as_str());
}
if let Some(var_345) = &input.value {
object.key("Value").string(var_345.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_license_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LicenseSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_346) = &input.license_configuration_arn {
object
.key("LicenseConfigurationArn")
.string(var_346.as_str());
}
if let Some(var_347) = &input.ami_association_scope {
object.key("AmiAssociationScope").string(var_347.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_organization_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OrganizationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object
.key("EnableIntegration")
.boolean(input.enable_integration);
}
Ok(())
}
pub fn serialize_structure_crate_model_provisional_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProvisionalConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_348) = &input.max_time_to_live_in_minutes {
object.key("MaxTimeToLiveInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_348).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_borrow_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BorrowConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_349) = &input.allow_early_check_in {
object.key("AllowEarlyCheckIn").boolean(*var_349);
}
if let Some(var_350) = &input.max_time_to_live_in_minutes {
object.key("MaxTimeToLiveInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_350).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_product_information_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProductInformationFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_351) = &input.product_information_filter_name {
object
.key("ProductInformationFilterName")
.string(var_351.as_str());
}
if let Some(var_352) = &input.product_information_filter_value {
let mut array_353 = object.key("ProductInformationFilterValue").start_array();
for item_354 in var_352 {
{
array_353.value().string(item_354.as_str());
}
}
array_353.finish();
}
if let Some(var_355) = &input.product_information_filter_comparator {
object
.key("ProductInformationFilterComparator")
.string(var_355.as_str());
}
Ok(())
}